Align prose with STYLE.md across modules 01-07 and top-level README

Replace residual em-dashes, arrow-notation shorthand, and a handful of
filler intensifiers; fix two small typos. Add .gitignore to keep the
working CHANGES.md audit out of the repo.

Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>

03-autocomplete/README.md

@@ -1,8 +1,10 @@
 # Autocomplete
 
+> **Heads up:** Autocomplete is the least important of the three in-editor modes covered in this guide, and its share of day-to-day AI-assisted coding has shrunk as in-project chat and agentic workflows have taken over. If you don't currently use ghost-text autocomplete, you can skim this section and move on to [section 04](../04-conversations/) without missing anything that later sections depend on. The traps below (especially around verification) still matter if you *do* use it.
+
 ## Key idea
 
-Autocomplete is the lowest-friction way to work with an AI assistant: ghost text appears as you type, you accept with Tab or keep typing to ignore. It is the *one* form of AI assistance that does not require you to write a prompt — the act of typing is the prompt.
+Autocomplete is the lowest-friction way to work with an AI assistant: ghost text appears as you type, you accept with Tab or keep typing to ignore. It is the *one* form of AI assistance that does not require you to write a prompt. The act of typing is the prompt.
 
 That cheapness is its strength and its trap. Because accepting a suggestion is a single keystroke, it is easy to accept code you did not actually read. The skill of using autocomplete well is almost entirely about *what you accept* and *what you reject*, not about how you invoke it.
 
@@ -21,7 +23,7 @@ As you type, the extension sends a window of context (the current file, usually
 
 **Examples (early 2026):** GitHub Copilot, Codeium, Cursor Tab, Continue.dev, Microsoft Copilot in VS Code. Most agentic tools (Claude Code, Cline) do *not* provide ghost-text autocomplete — they're optimized for chat-and-agent interaction. If you want autocomplete and an agentic tool, you generally run two extensions side by side.
 
-The model is small and fast on purpose; the latency budget is the time between your keystrokes, which is short. Don't expect the depth of reasoning you get from a chat-with-a-frontier-model — autocomplete is pattern completion, not analysis.
+The model is small and fast on purpose; the latency budget is the time between your keystrokes, which is short. Don't expect the depth of reasoning you get from a chat-with-a-frontier-model. Autocomplete is pattern completion, not analysis.
 
 
 ## Where autocomplete shines
@@ -35,7 +37,7 @@ The common thread: the model has all the information it needs *in the few lines
 
 ## Where autocomplete fails
 
-- **Anything that requires understanding a wider context.** If the right answer depends on what a function in another file does, autocomplete will guess — and the guess looks plausible.
+- **Anything that requires understanding a wider context.** If the right answer depends on what a function in another file does, autocomplete will guess. The guess looks plausible.
 - **Novel logic.** If you are doing something the codebase has not done before, the model will pattern-match to something *similar* and produce confident-looking code that is subtly wrong.
 - **Anything where "correct" is non-obvious from the surface.** Off-by-one indices, edge cases in numerical code, units, sign conventions, the precise contract of an API you are calling.
 
@@ -44,13 +46,13 @@ The common thread: the model has all the information it needs *in the few lines
 
 ### Read the suggestion before accepting it
 
-The cost of accepting wrong code that *looks* right is high. You will find the bug an hour later in a debugger when you could have caught it in 200 milliseconds. If a suggestion is more than a few lines, the right move is to read it, decide, and either accept or rewrite — don't Tab-and-pray.
+The cost of accepting wrong code that *looks* right is high. You will find the bug an hour later in a debugger when you could have caught it in 200 milliseconds. If a suggestion is more than a few lines, the right move is to read it, decide, and either accept or rewrite. Don't Tab-and-pray.
 
 A useful threshold: if the suggestion is longer than the comment or signature that triggered it, slow down.
 
 ### Do not autocomplete your verification
 
-This is the single most damaging autocomplete failure mode in scientific and engineering code.
+This is the most damaging autocomplete failure mode in scientific and engineering code.
 
 Whether your verification is a formal unit test, a sanity-check script, a comparison against a known answer, or a hand-checked numerical result, it is supposed to be *your* expression of what the code should do. If the model writes the check based on the code, the check passes by construction and confirms nothing.
 
@@ -75,18 +77,18 @@ Autocomplete is one rung of a ladder. Step off when:
 
 ## A historical note: inline edits
 
-Older guides and tutorials (and the 2024-era marketing for Copilot and Cursor) put **inline edit** — highlight a block, press Cmd+K, type *"make this async"* — alongside autocomplete as the second main in-editor interaction. The pattern emerged in 2023 alongside instruction-tuned LLMs (ChatGPT, GPT-4), which were the first models that could reliably turn a natural-language instruction into a code transformation. It sat between the earlier completion-only era (autocomplete, powered by Codex and similar) and the agentic loops that followed. The hotkey still exists in most tools, but the pattern is fading because in-project chat does the same job with better context.
+Older guides and tutorials (and the 2024-era marketing for Copilot and Cursor) put **inline edit** (highlight a block, press Cmd+K, or type *"make this async"*) alongside autocomplete as the second main in-editor interaction. The pattern emerged in 2023 alongside instruction-tuned LLMs (ChatGPT, GPT-4), which were the first models that could reliably turn a natural-language instruction into a code transformation. It sat between the earlier completion-only era (autocomplete, powered by Codex and similar) and the agentic loops that followed. The hotkey still exists in most tools, but the pattern is fading because in-project chat does the same job with better context.
 
-If you have *highlighted code and a one-sentence instruction*, an inline edit and an in-project chat message produce essentially the same diff. The chat panel just makes it easier to follow up, ask why, or refine. We don't teach inline edit as a primary workflow here. If your tool of choice still leans on it, the same one-sentence-spec discipline applies.
+If you have *highlighted code and a one-sentence instruction*, an inline edit and an in-project chat message produce essentially the same change. The chat panel just makes it easier to follow up, ask why, or refine it. We don't teach inline edit as a primary workflow here. If your tool of choice still leans on it, the same one-sentence-spec discipline applies.
 
 
 ## Habits that survive tool changes
 
-The tools will keep changing. These habits do not:
+The tools will keep changing, but these are still good habits to follow:
 
 - **Read every accepted suggestion.** Even short ones. Especially short ones in numerical code, where a sign flip looks the same as the right answer.
-- **Keep the cycle tight.** If autocomplete is producing more than ~10 lines at a time for you, you are no longer reviewing in real time — you are reading code the AI wrote, which is a different mode.
-- **Use version control as a safety net.** Commit before a stretch of heavy AI-assisted coding. `git diff` is the last line of defense.
+- **Keep the cycle tight.** If autocomplete is producing more than ~10 lines at a time for you, you are no longer reviewing in real time. You are reading code the AI wrote, which is a different mode.
+- **Use version control as a safety net.** Commit before a stretch of heavy AI-assisted coding. `git diff` is your fallback check.
 - **Verify with your own checks.** The check has to come from you, not from the AI that wrote the code.
 - **Be willing to turn it off.** Autocomplete is the right tool sometimes and the wrong tool other times. Toggling it off for a session where you want to think is a real productivity move.