tweak

src/FAQ.md

@@ -13,7 +13,19 @@ No -- right now, this is a work-in-progress being developed by [nikomatsakis], [
 
 ## Are these principles complete?
 
-No! They are still in draft form. We are still iterating on them and are interested in hearing from people who are active in the Rust community about whether they reflect what you love about Rust (and, if not, what might be changed). Another great idea is to try and use these principles to [guide design discussions and questions of team membership](https://rustacean-principles.netlify.app/#how-can-the-principles-be-used) to evaluate how useful they are.
+No! They are still in draft form. We are still iterating on them and are interested in hearing from people who are active in the Rust community about whether they reflect what you love about Rust (and, if not, what might be changed). That said, some aspects have gone through more iteration than others. Here is a list of some aspects of site and how well understood they are:
+
+| Aspect                                                 | Confidence                                  |
+| ------------------------------------------------------ | ------------------------------------------- |
+| The qualities listed in [How Rust empowers]            | High: we've iterated quite a bit on these   |
+| Ordering of the qualities                              | Medium: might still change this a bit       |
+| Mechanisms (e.g., [type safety])                       | Low: these have not seen a lot of iteration |
+| The qualities listed in [How to Rustacean]             | Medium: expect to tweak these               |
+| Examples in the qualities listed in [How to Rustacean] | Low: most of these aren't even written yet! |
+
+[How Rust empowers]: ./how_rust_empowers.md
+[How to Rustacean]: ./how_to_rustacean.md
+[type safety]: ./how_rust_empowers/reliable/type_safety.md
 
 ## Why develop these principles?
 

src/how_rust_empowers/reliable.md

@@ -21,7 +21,7 @@ What are some of the ways that we make Rust feel **reliable**?
 
 > Safe Rust code is guaranteed to avoid undefined behavior.
 
-Rust programmers never have to worry about notorious, hard-to-diagnose, harder-to-fix bugs like segfaults and data races. Rust's exposure to security vulnerabilities is much reduced as a result. However, static safety comes at the cost of increased overall complex (works against [supportive]). Figuring out the correct type annotations and other details can be difficult, working against [productivity].
+Rust programmers never have to worry about notorious, hard-to-diagnose, harder-to-fix bugs like segfaults and data races. Rust's exposure to security vulnerabilities is much reduced as a result. However, static safety comes at the cost of increased overall complexity (works against [supportive]). Figuring out the correct type annotations and other details can be difficult, working against [productivity].
 
 ### [Consider all cases](./reliable/consider_all_cases.md)
 

src/how_rust_empowers/supportive.md

@@ -13,7 +13,9 @@ Making Rust feel supportive can be in tension with Rust feeling [reliable]. It m
 
 What are some of the ways that we make Rust feel **supportive**?
 
-### Polished developer experience
+### [Polished developer experience](./supportive/polished.md)
+
+> The details count.
 
 Rust tools strive to provide a polished, smooth experience for our developers. One example is how the compiler offers quality error messages that attempt to not only indicate an error, but to teach the user how the language works, and offer helpful suggestions for how to fix their code. For tools like cargo, this manifests in careful CLI design that makes the "easy things easy" (but of course, for Rust to feel [versatile], we have to go beyond that).
 

src/how_rust_empowers/supportive/polished.md

@@ -1 +1,5 @@
 # Polished developer experience
+
+> The details count.
+
+Rust tools strive to provide a polished, smooth experience for our developers. One example is how the compiler offers quality error messages that attempt to not only indicate an error, but to teach the user how the language works, and offer helpful suggestions for how to fix their code. For tools like cargo, this manifests in careful CLI design that makes the "easy things easy" (but of course, for Rust to feel [versatile], we have to go beyond that).