← Back to the essay

One of Ida's skills

Write Better

When the AI drafts prose for Ida — a log entry, a research summary, copy she'll use as written — this skill makes it rewrite the draft before handing it over. Ida never invokes it; it kicks in on its own whenever the AI is the one doing the writing. (Her own words are off limits to it: fixing those is a separate, mechanical-only skill called /cleanup.)

Most of this page, and the skill it documents, was written by AI, specifically Claude Opus 4.8 and 5. Write Better is a skill Ida's AI wrote and revises from her feedback; the same AI compiled this page from the skill's files and the dated failure log that drove each change, and Ida edited it. The essay it belongs to, Obsessing Over AI Agents Is Slowing You Down, is entirely her writing.

The Skill Files


The largest skill of the set: instructions, four reference files, and a scan script. This is a snapshot of the real thing; the working copy is canonical and keeps evolving.

write-better/ ├── SKILL.md — the instructions: norms, the revision pass ├── references/ │ ├── llm-tells.md — catalog of AI writing tells │ ├── construction.md — revision procedures from a style manual │ ├── craft-principles.md — stance-level principles │ └── exemplars.md — the target register, plus a failure case └── scripts/ └── scan.sh — the mechanical scan
write-better/SKILL.md
The complete skill file. Click to read it here.
Download
---
name: write-better
description: Writing norms and an enforced revision pass for when Claude is the primary drafter. Fires mechanically, not by judgment: load and run this skill before (a) any Write or Edit that adds a paragraph or more of prose to a vault file — deliverables, research summaries, project logs, notebook entries, web copy, synthesis docs — (b) delivering copy in chat that Ida will use verbatim (page copy, descriptions, titles), at any length, or (c) authoring an Artifact or standalone HTML/shareable deliverable Ida will send or publish (a file written to scratchpad rather than the vault still fires the rule). Does NOT fire for: editing Ida's own words (that's /cleanup), code or YAML-only edits, one-line factual additions, or conversational replies. NOT for Ida's byline writing, which has its own drafting path. This skill always rewrites the wording; for mechanical-only fixes with the words left intact, use /cleanup. Run the revision pass and end with its revision note before delivering; don't offer.
---

# Write Better

Norms for when Claude is doing the heavy lift on writing. This covers client-facing materials, formatted dictation, comms copy, research summaries, descriptions, and anything where Claude drafts and Ida sends or lightly edits.

This is NOT for Ida's original writing (thought pieces, essays, posts). That has its own norms in the Content Creation Pipeline.

**This skill always rewrites the words.** Changing the wording is the point, not a risk to manage. When the input is existing text to improve — Claude's own draft or another model's output — write-better rebuilds it; preserving the wording is never the write-better mode. If you want only mechanical fixes (typos, punctuation, speech-to-text artifacts) with the wording left intact, that is `/cleanup`, not this skill. There is no light-touch version of write-better.

## Why These Norms Exist

LLM training produces writing that is fluent, structured, and confident — and also generic, over-polished, and full of identifiable patterns. These patterns are baked into the weights as "good writing" but are not good writing. They flatten voice, patronize readers, impose narrative where none is needed, and betray machine authorship to anyone paying attention. This skill exists to catch and override those defaults.

**The operative test (Ida, 2026-07-20, from the deep-reckoning writing standard).** Under every tell below sits one question: does a construction *reduce or reproduce the reader's decoding load?* The tells always add load, however well they read, which is why fluency is the thing to distrust rather than trust. This reframes each tell from a small deduction into a category error: a document written to be understood that adds decoding cost works against its own reason to exist. The same test runs at the passage level: a passage whose information the intended reader already holds adds decoding cost and nothing else, so cut it however well it reads. Dense prose is Ida's weakest channel, so the cost lands doubly. Say the complicated thing simply; never make it simpler than it is.

## When to Use

- **The firing rule is mechanical.** Run this skill's revision pass before (a) any Write or Edit adding a paragraph or more of prose to a vault file — including project logs and notebook entries — (b) delivering verbatim-use copy in chat, at any length, or (c) authoring an Artifact or any standalone HTML/shareable deliverable Ida will send or publish. File location does not exempt it: a page written to scratchpad rather than the vault still fires the rule.
- Does not fire for: Ida's own words (that's /cleanup), her byline writing, code or YAML-only edits, one-line factual additions, conversational replies.
- Ida points at something Claude drafted and asks for improvement → back through this skill. If the words are Ida's, only /cleanup touches them.
- Load and run, don't offer. Never ask first, never deliver the first draft.

When invoked, load `references/llm-tells.md` and `references/construction.md`, and apply all norms below.

## Assess Before Writing

- **Is the source material clear enough to draft from?** If there's ambiguity about audience, tone, purpose, or key content decisions, ask before writing.
- **Is there existing writing in this context to match?** If adding to or following up on something Ida already wrote, read it first and match the register.
- **Who is this for?** Match the register to the relationship and context. A team note is warm and invitational. Feedback to a client is collegial and direct. A proposal is precise and structured. Match the level of detail to the reader's expertise as well. A technical reader wants the mechanism, and hand-holding only slows them. A lay reader needs the terms unpacked. Wrong depth misfires like wrong register.
- **If working from dictation:** preserve Ida's language and framing. Tighten (cut filler, clean speech artifacts), but don't paraphrase or reinterpret. When a phrase is Ida's, keep it.
- **If synthesizing from existing notes or research:** the source material is the ceiling, not the floor. Preserve exact titles, exact attributions, exact language. Organize and compress — don't embellish, reframe, or editorialize.

## Writing Norms

### Sentences and Words

**Active voice.** Passive hides the actor and flattens the writing.

**Concrete over abstract.** Name the thing, not the category.

**Cut throat-clearing.** No sentences that announce what you're about to say. Get to the verb.

**Vary sentence length.** Short sentences for weight. Longer sentences to develop and breathe.

**Earn every word.** If a sentence could lose a word without losing meaning, lose the word. If a paragraph could lose a sentence, lose the sentence.

**Don't over-structure.** Not everything needs a header, a bullet list, or parallel construction. Let the content determine the form.

**Complete, grounded sentences over gestures.** A fragment used for punch ("Not just backing it, but using it.") gestures at a point without landing it. Write the full sentence that states the claim.

**Convincing, not persuasive.** Convincing is grounded — the claim earns belief because it's specific and sourced. Persuasive is rhetorical lift: cadence, contrast, and punch standing in for substance (internet-marketing slop). When a point can be grounded in the source material, state the grounded version. A gesture ("actually using it and saying what for") is weaker than the finding underneath it ("the strongest predictor of adoption is whether leaders use it themselves"). Reach for the evidence, not the cadence.

**Punctuation:** Prefer periods and commas. Colons for lists or elaboration. Semicolons sparingly. Minimize em dashes.

*Scan for:* any word or phrase from `references/llm-tells.md`. Em dashes. Tricolon lists. Sentences starting with "This" referring vaguely to the previous sentence. Sentence fragments used as rhetorical gestures (esp. "Not just X, but Y").

### Structure

**Let the content's shape set the form.** Don't default to a bullet list because there are several points — prose carries reasoning better; lists are for genuinely parallel items. If they're not parallel, it's not a list.

**Vary the shape of items.** When every item is the same length and rhythm, it reads as a template and flattens emphasis. The important one can run long; a minor one can be a clause.

**Lead with substance.** Cut orienting preamble if the first real point can open. Setup sentences are usually deletable.

**Cut what the reader already knows.** A passage that establishes or justifies something the intended reader already holds adds no information, however true it is. Cut the background they already have and the case for why the subject matters. Open on what they don't have.

**Don't impose symmetry.** Real content is asymmetric. The strongest point earns more room; don't pad the others to match.

**Order by what matters,** not by the order the source happened to present things.

**Don't over-section.** A header every few lines fragments more than it organizes.

*Scan for:* lists whose items are uniform in length and construction. Setup-before-substance openings. Passages establishing context the intended reader already has. Padding added for symmetry. A bullet list where prose would carry the reasoning better.

### Register

**Write like a competent person talking to competent people.** Clear, direct, unshowy. The reader notices what's being said, not how.

**Write to people, not about situations.** "Here's what you'll be doing" instead of "The activities will consist of."

**Warmth through specificity, not adjectives.** If the warmth isn't grounded in something specific, cut it.

**No salesmanship.** Don't inflate, don't pitch, don't add urgency that isn't there. State what's true.

**No diagnostic register.** Don't name what's broken, warn about consequences, or prescribe what needs to happen. Present what was heard, not what's wrong. "Just because people are using the same words doesn't mean they're working towards the same ends" (observational) — not "If the retreat lands on only one framing, people will feel unheard" (diagnostic).

**No contrastive expertise framing.** Don't frame Ida's expertise against a foil ("most facilitation treats all groups the same"). Frame from inside the expertise, not against an imagined opponent. This instinct is deep and persistent.

*Scan for:* sweeping comparisons or uniqueness claims. Diagnostic language (prescribing, warning). Expertise framed against a foil. Overly balanced paragraph structures.

### Presenting Information, Research, and Findings

**Describe what the information shows, then stop.** "Three of four interviewees named role clarity unprompted" is evidence. "Role clarity emerged as a dominant theme" is interpretation dressed as evidence.

**Present information at the same altitude it was found.** A data point is a data point. A pattern is a pattern. A speculation is a speculation. Don't promote things up the ladder.

**No superlatives or intensity markers.** Drop "remarkably," "strikingly," "notably," "unprecedented."

**No dramatic framing.** "Income generation outside institutional scaffolding has no precedent in the earnings history" describes. "Every single dollar came from institutional employment" amplifies.

**No narrative arc imposed on facts.** Lay the information flat so the reader can see their own patterns in it.

**When multiple interpretations exist, hold them open.** "This could mean X or Y" is more useful than picking one.

**Questions over verdicts.** "Worth asking whether this pattern holds under pressure" — not "this is a red flag." Only render a verdict when Ida specifically asks for one.

*Scan for:* interpretive gloss — any sentence drawing a conclusion not in the source. If you can't point to the source that says it, cut it. Rhetorical scaffolding — sentences that anticipate and defuse concerns the reader hasn't raised. Information promoted above its actual altitude. Fabricated titles or citations — never generate a title from memory; retrieve it from the source.

### Headings

**State the content, not a reaction to it.** Headers should tell you what the section contains without reading it.

*Scan for:* vague pronouns ("it," "this," "that") standing in for the actual subject. Teasing or dramatic headers that build intrigue instead of conveying content.

## Revise Before Delivering

The norms above describe the target. They don't enforce themselves: generating text and auditing text are different acts, and a fluent first draft embeds the tells even when the norms are known. Never deliver the first draft. Run every step below and end with the revision note, so a skipped pass is visible. The pass constructs as well as catches: cutting a tell leaves a hole the same trained rhythm refills, and step 2 is the method that fills it properly.

1. **Structure first — and rewrite from source if the draft is weak.** Before sentence work, check the shape: right form (would prose beat this list, or vice versa — and where the content is structural or relational, would a diagram or table beat prose? Dense prose is Ida's weakest channel, spatial her strongest), strongest point up front, nothing padded for symmetry. If the draft is weak at this level — wrong shape, wrong register, tells throughout — do not tune it. Go back to the source material and rewrite from it with the norms in front of you. Tuning a weak draft polishes the wrong thing.

   **Rewrite by claim checklist — the claim is the unit of fidelity, never the sentence.** Extract the passage's claims into a checklist first: every fact, number, confidence, hedge, and attribution, with quotes marked verbatim. Write the passage fresh from the checklist — sentence boundaries, sentence count, claim order, and which claim leads are all free. Then verify the checklist against the new text: everything present, nothing invented, judgments at the same strength. The checklist is what makes rewriting safe, and it audits the prior draft too — the 2026-07-17 reckoning test caught two claims the earlier build had silently dropped and a hedge the line edit itself had weakened. "Preserve the substance" means preserve the checklist, never the wording. The success test for a rewrite: a reader who knows the source finds every fact and every caveat, and cannot map sentences one-to-one.

2. **Construction pass — build the prose; full method in `references/construction.md`.** Three diagnostics, applied to every sentence and passage:
   - **Sentence test:** read the first seven or eight words of each sentence (skip a short introductory phrase). They should reach a short, concrete subject naming the main character, then a verb naming its specific action. Flag abstract-noun subjects (nominalizations), seven-plus words before any verb, and empty verbs (is, has, occurred, was based). To rewrite: find the characters (hiding in possessives, of/by phrases, adjectives, or missing entirely), turn their actions from nouns back into verbs, make the characters the subjects, and join clauses with because, if, when, although.
   - **Flow test:** each sentence opens with information the reader already has and ends with what's new. Read the sentence openings in sequence — they should name a small, consistent set of topics. When old-before-new conflicts with active voice, old-before-new wins.
   - **Stress test:** the last few words of a sentence carry the emphasis. End on the newsworthy element, never a qualifier, an attribution, or a flourish. Fixes: trim the end, shift peripheral ideas left, shift new information right. A passage's opening sentence should end on the themes the passage develops.

   Apply the reference file's concision principles while rewriting (delete implied words, replace phrases with words, negatives to affirmatives). On short copy this step collapses to the sentence and stress tests — seconds, not minutes.

3. **Mechanical scan — run `scripts/scan.sh` on the draft file and look at every hit. Not optional, and not a final proofread: run it before you finalize so its hits shape the rewrite, and report its result in the revision note (step 8) so a skipped scan is visible.** For chat copy, write the draft to the scratchpad and scan it the same way. The script is the single source of truth for the scan strings; a hit is a judgment prompt, not an auto-delete. The categories it covers: contrast constructions and X-not-Y handles (`not just`, `it's not`, `, not `); em dashes (period or comma instead?); ` than ` — judge whether it lands at the end of a sentence or list item, the comparative-kicker position; aphoristic kickers (`the real`, `matters most`, `the one to`); marketing-CTA register (`worth` + gerund, `Have a look`, `Learn more`, `Explore`, `Discover`, `→`); intensifiers and weasel words; passive voice (judge each hit by the three passive questions in `references/construction.md` — passive is sometimes the right choice); nominalization chains; duplicate words; drama filler; and the vocabulary tells (`delve`, `crucial`, `leverage`, `utilize`, `foster`, `landscape`, the `sharpen` family, `straightforward`, `comprehensive`, `robust`) that slip past a constructions-only scan.

4. **Named checks — answer each one; none is optional.**
   - **Headings:** read all headings alone, as a list. Each must state what its section contains. Rewrite any that tease, react, or fill.
   - **List shape:** if three or more items in a list end the same way (same rhythm, same punchy landing), vary them or convert to prose.
   - **Coined labels:** if the draft invented a two-or-three-word handle and built on it, replace every use with the plain description.
   - **Idiom and jargon:** any idiom or term of art Ida doesn't already use gets replaced with the literal action; technical terms are defined inline on first use.
   - **Register and gestalt:** does any line read as a pitch, an ad, or prose impressed with itself — crowning its own claims, escalating without new evidence? Would a competent person say this sentence aloud to a colleague? When in doubt, compare against `references/exemplars.md`: the bar states a claim and supplies the evidence; the anti-bar states a claim and praises it.
   - **Prose about itself:** cut any sentence about the writing or the reader instead of the subject — meta-commentary labels ("Why it lands"), pre-handled objections, "why this matters" framing. See the classic-style principles in `references/craft-principles.md`.

5. **Grounding audit — claims and numbers, not just phrasing.** Go through every load-bearing claim or figure and do one of: point to the primary source, cut it, or recast it as an open question. Verify numbers against the primary file, never a subagent's summary (a summary is a lead, not a source). Tag each claim by evidence type — sourced fact vs. inference, and internal/self-knowledge vs. external/market — and don't let an internal source settle a market question. Keep genuinely grounded claims firm; this is calibration, not blanket hedging.

6. **For each hit, do one of three things:** ground it (state the specific or sourced version), complete it (turn a fragment into a full sentence), or cut it.

7. **Scale to the stakes — depth, never coverage.** Length scales the structural work, the passage-level construction diagnostics (flow, topic strings), and the grounding audit — not the checks. A two-line copy block still gets the sentence and stress tests, the full mechanical scan, and the register check; short copy is where register tells concentrate and every word counts.

8. **Revision note.** End with a single terse line in chat, formatted as a one-line Markdown blockquote that always begins `> Revision pass:` — the blockquote renders italic with a left band, matching the `> Verified:` block, so it reads as a required mechanical output rather than prose. It leads with the scan result, then names what the pass changed: `> Revision pass: scan 14 → 9 fixed, 5 kept as meaningful; rewrote two teasing headers, cut three kickers` (or `> Revision pass: scan clean` when nothing fired and nothing needed changing). The scan count is required — a note without it means `scripts/scan.sh` (step 3) was skipped, which is not allowed. The fixed prefix plus the scan count is what makes the note countable and makes a skipped scan visible. Never longer than one line; this is observability, not ceremony. The note goes in chat, never in the file.

### Log entries and durable notes

When the prose is a log entry, notebook entry, or addition to running notes, run this compact variant: summarize the outcome rather than narrating the play-by-play; neutral verbs, no intensity beats ("that's the name," "couldn't crack," "the breakthrough"); match the density and register of the entries already in the file; run the mechanical scan. A log is a reference document read months later, not a recap of how the session felt.

## Gotchas

- **Synthesis fuses adjacent ideas into a wrong middle conclusion.** Two distinct claims in source don't authorize a third connecting claim. Preserve them as distinct. If a relationship between ideas isn't stated in the source, it doesn't go in the deliverable.
- **Synthesis degrades the source.** The source material is the ceiling, not the floor. Resist reframing, editorializing, or "improving" while organizing. Any sentence in the synthesis that can't be traced to a specific source must be cut.
- **A flagged instance is a sample, not an incident.** When Ida catches a wording or naming failure, sweep the whole deliverable for that class — a grep or one targeted read-through — before or immediately after fixing the instance she named. Each catch marks a class already in the document; fixing only the named instance ships the rest.
- **Diagnostic register and contrastive framing recur within a session even after correction.** Both are deep instincts, not one-off slips. After writing or revising, scan headings and topic sentences again — even sections already corrected — for prescription, warning, or "most X don't Y" framing.
- **Titles, citations, and URLs get generated instead of retrieved.** Default is retrieval — open the source, read the file, check the page. Never generate a title from memory or inference. Especially damaging for Ida's own published work.
- **Call preps drift into briefing memos.** Cue cards, not memos. Questions and decision points only — short bullets. No internal reasoning, no narrating Ida's instincts, no restating context she already carries. Halve any draft that reads like a briefing.
references/ and scripts/
All six companion files, each its own fold-out; two are described rather than shown.
Download all
llm-tells.mdcatalog of AI writing tells, each with a worked replacement
# LLM Tells to Avoid

Patterns baked into LLM weights as "good writing" that signal machine-generated text.

## Words
- "Delve," "crucial," "leverage," "lever," "utilize," "foster"
- "Landscape" (as metaphor)
- "Load-bearing" (as metaphor for "important" / "essential")
- "Sharpen," "sharper," "sharpened," "sharpening" (as metaphor for clarifying/refining)
- "Straightforward," "comprehensive," "robust"
- "Earns" / "earns its keep" / "earns its cost" (as metaphor for being worth it — overused filler verb; say plainly what makes it worth the cost)

## Phrases
- "It's important to note that..."
- "It's worth noting..."
- "Interestingly,..."
- "Let's..." as sentence opener
- "In today's [x]..."

## Sentence Constructions
- "It's not just X, it's also Y" — including fragment variants ("Not just X, but Y," "Less Z, more W"). Very common, very bad. Worst as a verbless fragment: it gestures at a contrast instead of stating a grounded claim. Replace with a complete sentence that says the thing.
- Trailing antithesis — a sentence or clause that ends with a comma and a negating tail ("X, not Y," "X, never Z," "X, rather than W"). The tail adds emphasis-by-contrast instead of information and torques the claim toward what it isn't. Cut the tail and state X directly. E.g. "priced in, never itemized" → "priced in without itemizing"; "background courage, not the lead" → "background courage"; "test against buyer profiles, not instinct" → "test against buyer profiles." A contrast whose two sides are both real content may stay — but once, where it does its work, not restated per section. Density is its own tell: a document can pass this check sentence-by-sentence and still seesaw on every paragraph.
- Tricolon lists (three parallel items in a row)
- Em dashes for parenthetical asides (overused)
- Colon or semicolon that defers the point — a colon or semicolon chopping a sentence to postpone what it says where a full stop would deliver it. Not a fix for overused em dashes; it produces the same choppy, withheld read. Reserve the colon for a genuine list or a single elaboration.
- "This [noun] is a [adjective] that [verb]..." as opening
- Rhetorical scaffolding — sentences that set up a concern to knock it down. Includes: "These are not obstacles to adoption," "What does help:," "This doesn't mean X. Rather, it means Y." Patronizing because it anticipates an objection the reader hasn't raised and corrects it. The full family: preemptive objection handling, setup-then-deliver, corrective framing.
- Interpretive gloss — editorial conclusions appended to findings as if they're part of the evidence. "The barrier is trying it, not mastering it." "In other words," "Put simply," "The takeaway is." If the source doesn't say it, the sentence shouldn't be there.

## Headings
- Vague pronouns in section titles: "How to Get the Most Out of It," "What This Means for You," "Why It Matters." State the actual subject.
- Teasing or dramatic headers: "The core gap identified," "The distinction that matters," "What's newly in play." State the content, not a reaction to it.

## Structural
- Overly balanced paragraphs
- Conclusions that restate the opening
- Hedging before making a point
- List items uniform in length and construction — templated rhythm that flattens emphasis
- Setup-before-substance: orienting preamble in front of the first real point
- Symmetry imposed on asymmetric content (padding minor points to match the strong one)
- Defaulting to a bullet list where prose would carry the reasoning better

## Coined Labels and Handles
- Compressing a plainly-described idea into a pithy two-or-three-word handle ("channel not project," "flow-balance gate," "depth-first"), then building on the handle. Puts the decoding cost on the reader. Describe the idea in plain words each time, or use Ida's existing term.
- Hyphenated compound handles — coining by hyphenation instead of by naming: "the regret-if-dropped condition," "the funded-plus-fitting-plus-non-hierarchical conjunction," "the fewer-larger, reputation-fed shape." Same decoding cost as a coined label; a rule against coined names doesn't catch these, so the density relocates here. Unpack into a plain clause ("the risk she'd regret dropping it"). One repeated key phrase used verbatim throughout is fine; a fresh hyphen-handle per paragraph is the tell.
- Analyst-jargon as vocabulary: "cognitive architecture," "load-bearing," "installation," "the machine." If Ida doesn't use the term, the draft doesn't either.

## Marketing and CTA Register
- "Worth sharing," "worth a look," "Have a look →," "Learn more," "Discover," "Explore" — content-marketing furniture. State what the thing is; the reader decides whether to look.

## Idiom and Jargon as Flourish
- Idioms and terms of art the reader may not share ("keep me whole," "if the floor won't move," undefined "depot repair"). Idiom only when it's a term Ida clearly understands and already uses. State the literal action. Define any technical term inline on first use.

## Process and Audit Vocabulary in Deliverables
- Sentences addressed to the writing process or a verifier instead of the reader: "Derivation:", "not softened upward, not suppressed," "per the ~50% anchor," "stated as an open question, not a directive," "this is the honest read." Also internal skill or pipeline vocabulary ("records-answerable," "only-living-it," "the recon," "the gate") reaching reader-facing prose. Provenance and audit trail belong in structure — tags, footnotes, expandable blocks — never performed in sentences. Translate the term or move the information into the structure that carries it.

## Legalistic and Mechanistic Register
- Dressing a plain human act in juridical or machine vocabulary. "Rule," "ruling," "binding," "adjudicate," "sign-off" for a person weighing something and reacting; "the mechanism," "executes," "governs," "supersedes" for ordinary steps. It reads as formal and hard to follow: the reader decodes a courtroom or a machine instead of the action. Say what happens ("you weigh what comes back and react, and your input shapes the next pass"), not "your rulings bind." Ties to the analyst-jargon and pipeline-vocabulary entries above, where "the gate" already lands; a skill's own internal decision-terms are the common source, so translate every one for the reader.

## Document Self-Narration
- Sentences about the document instead of the subject: "This sheet holds the overview," "This section grounds the moves… It does not re-open the verdict," "held once," "It is not used to re-weight any path." One orienting line per section at most; every other sentence is about the subject. (The scan-level shape of SKILL.md's "prose about itself" check.)

## Dramatic Narration in Logs
- Play-by-play with intensity beats ("That's the name." "The shift we couldn't crack an hour ago") in an entry meant as a durable reference. Logs get neutral, pragmatic outcome summaries.

## Drama and Pacing Filler
- Phrases that perform significance and slow delivery: "here's the thing," "let's state this plainly," "make no mistake," "to be clear." State the point without the drumroll. (Ida's list, 2026-07-03 spec review.)
- Mechanical-precision verbs on ordinary observations: "splits cleanly," "maps neatly," "slots in." Companion to the analyst-jargon entry above.
construction.mddescription only — the file itself isn't published

The mechanical revision procedures, distilled from Style: Lessons in Clarity and Grace (Williams, Bizup, Colomb): the subject-and-verb sentence diagnostic, old-before-new flow, end-stress emphasis, six concision rules, and the three questions for judging a passive.

Described rather than shown, because it condenses lessons from a book worth buying.

craft-principles.mdstance-level principles, reconstructed and labeled as such
# Craft Principles (Reconstructed)

_Distilled from Claude's training knowledge of two works Ida selected for the corpus (2026-07-03). Reconstructed — no full-text access; principles only, no quotes or page references. The third corpus work, Style: Lessons in Clarity and Grace, is covered by `construction.md`, distilled from the real text (2026-07-04)._

## Classic style (Thomas & Turner, *Clear and Simple as the Truth* — reconstructed)

- Prose is a window on the subject. The reader looks through it, never at it.
- The stance is presentation, not persuasion: the writer shows what they see, confident the reader, treated as an equal, will see it too. No selling, no hedging, no anticipating objections.
- The working test: is any sentence doing something other than presenting the subject — promoting it, defending it, or commenting on the writing itself? Most LLM tells fail exactly this test: meta-commentary, preemptive objection handling, teasing headers, and CTA flourishes are all prose aware of itself or working on the reader.

## Craft discipline (Kidder & Todd, *Good Prose* — reconstructed)

- Plain style is a discipline, not an absence of style. Restraint reads as confidence.
- Distrust mannerism: any recurring verbal trick eventually writes the prose for you. (This is the mechanism behind LLM tells — trained rhythms generating text instead of the subject generating it.)
- The writer serves the material; a sentence that shows off is about the writer.
- Revision is where writing happens. First drafts are for finding out what you have.
exemplars.mddescription only — the file itself isn't published

Sets the target register with three published pieces and Ida's notes on what each does; one block of real model output sits opposite as the failure case.

Described rather than shown, because the failure case quotes a third party's material.

scan.shthe mechanical scan: eleven sections, fourteen greps
#!/bin/bash
# Mechanical scan for the write-better revision pass (step 3).
# Single source of truth for the scan strings — SKILL.md references this script.
# Usage: scan.sh <file>
# Prints each hit with line number. A hit is a judgment prompt, not an auto-delete.

f="$1"
[ -f "$f" ] || { echo "usage: scan.sh <file>"; exit 1; }

section() { printf '\n## %s\n' "$1"; }

section "Contrast constructions / X-not-Y handles (incl. trailing-antithesis tails)"
grep -inE "not just|isn't just|it's not|, not |, never |, rather than " "$f"

section "Em dashes (period or comma instead?)"
grep -n " — " "$f"

section "Comparative kickers (judge: sentence- or item-final?)"
grep -in " than " "$f"

section "Aphoristic kickers"
grep -inE "the real |matters most|the one to " "$f"

section "Marketing-CTA register"
grep -inE "worth [a-z]+ing|worth a look|have a look|learn more|explore|discover|→" "$f"

section "Intensifiers and weasel words (cut or justify each)"
grep -inwE "very|clearly|significantly|substantially|relatively|quite|extremely|remarkably|obviously|certainly|literally" "$f"
grep -in "of course" "$f"

section "Passive voice (judge by the three passive questions in construction.md)"
grep -inE "[[:<:]](is|are|was|were|be|been|being) [a-z]+(ed|en|wn|ne)[[:>:]]" "$f"

section "Nominalization chains (rewrite method in construction.md)"
grep -inE "[a-z](tion|sion|ment|ence|ance|ency)s? (of|by|for) " "$f"

section "Duplicate words"
grep -inE "[[:<:]]([a-z]+) \1[[:>:]]" "$f"

section "Drama and false-weight filler (incl. mechanical-precision verbs)"
grep -inE "load-bearing|cleanly|neatly|slots in|here's the thing|plainly|make no mistake|to be clear" "$f"

section "Vocabulary tells (grep explicitly — they slip past a constructions-only scan)"
# Folded in 2026-07-07 from the live SKILL.md (edited 2026-07-05, after this spec froze) and llm-tells.md.
# These are cataloged in references/llm-tells.md; grep them so they are caught mechanically, not by eye.
grep -inwE "lever|leverage|delve|crucial|utilize|foster|landscape|straightforward|comprehensive|robust" "$f"
grep -inE "sharp(en|er|ened|ening)" "$f"
grep -in "cognitive architecture" "$f"

exit 0
scan-fixture.mdplanted test strings with the expected hit count
# Scan fixture

Planted strings for scripts/scan.sh, one line per scan section. Re-run after any edit to scan.sh and compare against the recorded count at the bottom.

It's not just a tool, not a toy.
The plan — such as it is — needs work.
This version reads better than the last one did.
Honestly, the real work matters most here.
Learn more about what's worth exploring →
This is very clearly important, of course.
The proposal was rejected by the committee.
The implementation of the plan required the assessment of risks.
We reviewed the the document.
Here's the thing: the design is load-bearing and splits cleanly.
We will leverage the landscape to delve into crucial improvements and sharpen the approach.

Expected result: every one of the 11 sections prints at least one hit; 13 hit lines total (the intensifier and vocabulary sections each run two greps and print their planted line twice).

What It Is


Whenever the AI drafts prose Ida will need to live with — a project log, a research summary, or anything of length delivered in chat for her to read and work from — this skill makes it rewrite the draft before delivering it. Every draft that matches the list below gets the rewrite. The AI does not get to decide whether a draft deserves it, because earlier versions let it decide, and it passed on revising far too many things. The only judgment the AI keeps comes later, line by line, and that part is shown in The Scan in Practice.

◇ Fires
  • any write or edit adding a paragraph or more of prose to a file, including project logs and notebook entries
  • copy delivered in chat that Ida will use verbatim, at any length
  • any artifact or standalone HTML deliverable that will be sent or published, including files written to a scratch directory
◇ Does not fire
  • Ida's own words, which route to /cleanup
  • her byline writing, which has its own drafting path
  • code or YAML-only edits
  • one-line factual additions
  • conversational replies

The last item on the Fires list was added after the AI wrote a shareable page in a temporary folder and skipped the skill entirely; the rules at the time only mentioned files in Ida's notes.

What It Needs to Run


How It Fires


Here is what happens, in order. Ida asks for something — say, a summary of a research session. The AI recognizes that what it's about to write is the kind of prose this skill covers, so it loads the skill before drafting. It writes a draft. It runs the scan script on the draft and reads what got flagged. It rewrites. Then it saves the file and reports to Ida in one line: how many things the scan flagged, and what it did about them.

Everything in that sequence depends on the AI following its own written instructions. The instructions are just words; nothing forces the AI to obey them, and for a while it often didn't. So one piece was moved outside the AI's control: after any file the AI writes, a separate script runs the same scan again, automatically, and reports the count into the conversation. This script can't stop a bad text from going out and can't rewrite anything. All it does is make a skipped revision impossible to hide. It exists because the AI's compliance proved unreliable.

modelrecognizes the situation matches the skill, loads it and two reference files
modeldrafts
modelruns the scan script on the draft file, reads the hits
modelrewrites (the steps of the pass are in the next section)
modelwrites the file
scriptfires after the write, re-scans the written prose, reports the count into the conversation
modelresolves anything the script surfaced, reports the revision note in chat

Every step marked model happens only if the AI follows its own written instructions, and nothing checks that it did. The step marked script runs no matter what.

The script has three blind spots. It can only report: it tells the AI what the scan found, and it cannot stop a text from going out or rewrite anything itself, so ignoring the report stays possible. When the AI edits part of an existing document, the script checks only the changed part, and problems in the surrounding text pass unseen. And text delivered straight into conversation never touches a file, so the script never sees it; catching those drafts depends on the AI checking itself.

The Revision Pass


First the AI drafts. Then it audits the draft against the tells list (llm-tells.md) and rewrites, because a fluent first draft carries the tells even when the AI knows the norms.

  1. Structure first. Check shape before sentences: right form, strongest point first, nothing padded for symmetry. If the shape is wrong, the AI doesn't polish sentences: it goes back to the source material and redrafts. It pulls every fact, number, hedge, and attribution into a checklist, writes fresh from the checklist, then verifies nothing got dropped.
  2. Construction pass (construction.md). Three diagnostics on every sentence: does it reach a short concrete subject and a real verb early; does it open on what the reader already has and close on what's new; do the last few words carry the emphasis.
  3. Mechanical scan (scan.sh). Run the scan script on the draft file; chat copy gets written to a scratch file and scanned the same way. Run it early, so hits shape the rewrite.
  4. Named checks. Headings read alone as a list, each stating its section's contents; list items varied when three end the same way; coined labels replaced with plain descriptions; register checked against the exemplars (exemplars.md, with craft-principles.md for judgment calls).
  5. Grounding audit. Every load-bearing claim points to a source, gets cut, or becomes an open question.
  6. Judging the flags. For each line the scan flagged, the AI makes a call: is this actually a problem? If it isn't, the line stays. If it is, there are three fixes: tie the claim to a source, finish the thought, or delete it.
  7. Scale to stakes. Longer pieces get more structural work, but every piece, however short, gets the full scan.
  8. Revision note. One line in chat, leading with the scan count, so a skipped scan is visible.

The Scan in Practice


Real scan output on a real draft: a notebook entry logging one of the AI's own errors, written during the session that produced an earlier version of this page. Six hits across four of the scan's eleven sections:

$ scan.sh nb-entry.md

## Contrast constructions / X-not-Y handles
5: **The pattern:** Claude never established which machine…

## Em dashes (period or comma instead?)
1: ### 2026-07-30 — Reported deleted logs and a backup gap…

## Aphoristic kickers
5: **The pattern:** Claude never established which machine…
9: **Applies to:** Any claim about backups, installed tools…

## Nominalization chains
3: **What happened:** Measuring write-better usage for a garden…
5: **The pattern:** Claude never established which machine…

Hit lines are truncated here for width; nothing else is cut.

False positives are the normal case. The em-dash grep and the passive-voice pattern fire on correct prose, so a large share of hits get judged and kept. This entry scanned at nine hit lines before the pass and six after, and all six remaining were judged and kept. The script's header states the working rule: a hit is a judgment prompt, not an auto-delete.

Effectiveness and Limits


A scan of thirty days of session logs counted 275 revision notes across 730 sessions. That measures how often the pass ran, not whether the output got better. The one quality figure in the record: one miss in roughly 116 invocations. That figure is a minimum, since it counts only the misses Ida caught and logged.

Ida's own read, from July: the skill helps, the output still isn't great, and it spends a lot of tokens for taste-driven results. She reads that as a sign of how pervasive the underlying writing weakness is. Whether a different model would do better on something this taste-dependent is still open.

The checks no script can catch — headings, register, list shape, coined labels — have no mechanical backstop. A heading that violated a stated rule passed both enforcement layers in July; a model-based judge was considered as the fix and declined as costing more than a single logged miss justified.

Changes So Far


The changes that altered the design, from the dated failure log. The direction is consistent: the early fixes added knowledge, which did not work, and the later ones added enforcement.

Apr 14 · Created

Written after model writing habits turned up in client-facing work. Norms only: a list of tells, plus rules for register and for presenting findings.

May–Jul 1 · Content added

Five entries to the Gotchas list, the grounding audit step, and the rewrite-from-source instruction, each after a specific failure.

Jun 19 · Rebuilt as an enforced pass

A long page-copy session showed the skill was all norms and no application: it described the tells but never made the AI audit its own draft, so they survived even with the skill loaded. The diagnosis: every prior fix had added knowledge, and the tells kept slipping because generating text and auditing text are different acts.

Jul 10 · Rewriting made explicit, scan made reportable

Asked to improve a report "without losing any of the substance," the AI ran two conservative passes that kept the original wording and left the tells intact. Two fixes: a line stating the skill always rewrites the wording, and a requirement that the revision note lead with the scan count.

Jul 12 · Scratch files brought inside the trigger

The AI drafted a guide as a shareable artifact, published it without running the skill, and claimed compliance. The trigger had been written around vault files, so a file written to a temporary directory matched nothing.

Jul 17 · The scan moved from instruction to enforcement

The required scan got skipped twice more, so it stopped being an instruction alone. An enforcement script now runs the scan after every write and reports the hit count whether or not the pass was run by hand.

Jul 20 · The tells put under one test

Every tell reframed as one question: does this construction add decoding load for the reader? Imported from a writing standard developed for the deep-reckoning skill, it made fluency itself the thing to distrust.

Aug 2 · A second enforcement script

After misses kept showing up in titles and headings — the things no text-pattern search can catch — a second script was added. It fires when the AI writes a web page, pulls out the page's title and headings, and shows them back to the AI as a list to judge one by one. The full model-based judge stayed in reserve.