diff --git a/docs/index.rst b/docs/index.rst
index 7126d02..e1283e7 100644
--- a/docs/index.rst
+++ b/docs/index.rst
@@ -83,9 +83,8 @@
 
 **Patches**
 
-If you want to contribute a patch to libunwind, the best place for that is
-`Phabricator <https://llvm.org/docs/Phabricator.html>`_. Please include [libunwind] in the subject and
-add `cfe-commits` as a subscriber. Also make sure you are subscribed to the `cfe-commits mailing list`_.
+If you want to contribute a patch to libunwind, please start by reading the LLVM
+`documentation about contributing <https://www.llvm.org/docs/Contributing.html>`__.
 
 **Discussion and Questions**
 
