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 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 (essays and posts under her name), which she drafts herself. 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.
## Mode: light or heavy
Decide this before writing; the choice is itself skip-prone, so make it first.
- **Heavy** — a standalone HTML/shareable deliverable, anything someone other than Ida reads, or 300+ words of new prose in a deliverable file. Full pass, and **Step 0: write the seed first, then generate from it** (the seed is step 1's claim checklist written before the draft, not after). Save it where the seed-gate hook looks for it (see How It Fires on the published page); give it three headings — **Substance** (facts from source with members NAMED: the actual fibers, the five care actions, the real number, never a category noun), **Reader** (who reads it, what they leave able to do), **Standard** (the register target with one pasted exemplar). A large `.html` write is denied until the seed exists; a large `.md` deliverable gets a reminder.
For a long explanatory deliverable (roughly 1,500 words of prose or more), add a cold read by a stronger model before shipping, briefed to flag every passage a first-time reader would have to read twice.
- **Light** — verbatim chat copy, log and notebook entries, short vault additions, single paragraphs, ordinary project-file edits. The fast pass only: sentence and stress tests, the scan, a quick read of the named checks. No seed file, no fielded note.
## 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.
- **Heavy mode starts at the seed (Step 0, above), not the draft.** A weak first draft is a generation problem before a revision one: writing from the topic produces the gist, and the gist is abstract. When the draft still comes out abstract, the seed was thin; thicken the seed rather than tuning the sentences.
## Writing Norms
### Sentences and Words
**Active voice.** Passive hides the actor and flattens the writing.
**Concrete over abstract — name the members.** Name the thing, not the category. When a category noun stands in for members that are short and nameable, name them: "washing, bleaching, drying, ironing, and dry cleaning," not "each thing you can do to a garment." The "thing you can/do to X" phrase is the tell and the scan flags it; a bare category noun ("the methods") the scan can't see, so that one is yours to catch.
**Verbs must be physically true.** Picture the verb happening to its subject. If it can't happen to that thing, use the verb that names what actually happens. Two forms:
- An impossible action on a physical thing: a pound "holds" yarn, hanks "fill" a pound, a weight "contains" length. Instead: "a pound of this yarn is shorter."
- A physical verb borrowed for something abstract: a finding "lands," a number "sits at," a pattern "surfaces," a plan "carries" risk. Instead: the finding "shows," the number "is," the pattern "appears," the plan "risks."
Read for this in every draft. The scan can't detect it.
**Read numbers and notation out literally.** Every figure or notation the reader has to interpret gets one sentence saying what it means in the world: "40 denier: 9,000 metres of this yarn weighs 40 grams," "40/2: two size-40 strands twisted together." Financial and technical figures need the same treatment.
**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.
**No appositive tail.** A sentence that ends on "[clause], [short appositive or -ed/-ing phrase]" leans on cadence the way LLM prose does: "one duty, exercised in ink," "the ISO set, close but not identical," "gray dashes, no green," "the safe way, full stop." Rewrite the tail into a full clause, or cut it. The mechanical scan catches three literal forms of this; the shape is general, so read for the rest.
**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.
### Explaining Something New
When the reader is meeting the material for the first time (study materials, how-tos, setup docs, client explainers), three more checks apply. They come from the yarn-numbering study guide (2026-10-05), where the sentences were grammatical and the reader still got lost.
**Sort the terms by kind before drafting.** List every term the reader may not know and name what kind of thing each is: a unit, a method, a result, a category, a notation. Then flag every word that does more than one job. "Denier" names a method and also the unit of its answer; "count" meant three different things on one page. Give the reader the sorted list up front, and wherever a double-duty word switches jobs, say which job it is doing. A definition says what a word means, but the reader also needs to know what kind of thing it is: Ida's question was whether denier measured width or length.
**Define before use, in the order the reader meets things.** Walk the piece in the reader's order, with diagrams, labels, buttons, and captions included, and confirm that no term appears before the sentence that defines it. In the yarn guide, the first diagram used "denier" and "hank" in its labels before any text defined them.
**Give every rule its cause.** State the chain that produces a rule along with the rule: "a heavier yarn puts more grams on the scale, so the number goes up." A reader who has the cause can rebuild the rule; a reader who has only the rule has to memorise it.
### 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.
**Heading a section with its subject, as a noun phrase, is the default.** A reader skimming the headings alone should learn what the document covers. Five failures Claude's drafts keep producing:
- **A count in place of names.** "Two figures" says how many; name them.
- **A question in place of the claim or the measure.** "Will the money last," "Why each is a single number." Name the measure, or state the answer the section gives.
- **The source in place of the content.** "Survey results" says where the numbers came from, not what they are.
- **A metaphor verb.** "How the budget is built" dresses up "reasoning."
- **A pronoun.** "Keeping it current."
**Worked example: a heading rewrite** (invented for the published copy, following the pattern of a real rewrite Ida made of Claude's headings on a planning document, 2026-10-05). The document is a neighborhood tool library's annual report. Claude's version first, then the rewrite:
- "Membership" → "Membership and Loan Figures"
- "Two numbers" → "Active Members and Monthly Loans"
- "How the budget is built" → "Repair Budget Reasoning"
- "Why each tool has one fee" → "Single Late Fee Averages Loan Length"
- "Will the fund last" → "Probability the Repair Fund Covers the Year"
- "Survey results" → "Members' Ratings of Tool Condition"
- "What's Not Captured in the Count" → "Not Accounted for in the Loan Count"
- "Keeping it current" → "Keeping the Inventory Records Current"
The rewritten headings are longer and plainer: each names its subject in full, and none asks a question or reaches for a figure of speech. "How to log a returned tool" stays as written, because that section is a procedure, so how-to headings stay for steps.
## 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 document is for Ida's own use, settle how she'll use it before drafting: what she reads first leads, each practice is headed by its action or question, and each reference names its content (the statement, the quote, the person) instead of pointing at it. 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.** In heavy mode this checklist is the seed's Substance list, already written (Step 0); in light mode, list the claims first — every fact, number, hedge, and attribution, quotes marked verbatim. Write the passage fresh from the list (sentence boundaries, count, and order are free), then verify against it: everything present, nothing invented, judgments at the same strength. The success test: a reader who knows the source finds every fact and 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. A clean scan is necessary but not sufficient: it can't see a nameable category noun or a subtle appositive tail, so step 4's reading checks carry those, and a clean scan is never a finished pass.
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, or that fail the five patterns under Headings above (count, question, source, metaphor verb, pronoun). Three tests from 2026-09-23, on taglines, decks, and subheads especially: it names a specific thing, not an abstraction ("One method, warranted" fails); it never tells the reader how to feel ("the part a lawyer will enjoy" fails); parallel subheads carry the noun, not a pronoun chain ("what it warrants / what it leaves unsaid" fails). The register to match is a grounded New Yorker deck, not a clickbait tease.
- **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.
- **Name the members:** sweep every category noun and "thing you can/do to X" phrase; name short, known members. The scan flags the tell phrases, but a bare category noun it can't, in body prose and interface strings alike.
- **Appositive tails:** read each sentence's ending; rewrite "[clause], [short appositive]" as a full clause or cut it. The scan catches the literal forms; read for the rest.
- **Coined labels:** if the draft invented a two-or-three-word handle and built on it, replace every use with the plain description. Names that have to stay (a concept, a label on a page, a YAML key, a file name, a script flag) and that Claude or another model coined: list them for Ida to approve or rename before the deliverable ships. Usually the list is empty.
- **Physically true verbs:** picture each verb happening to its subject; replace any action that can't happen to that thing, and any physical verb borrowed for an abstraction (lands, sits at, surfaces, carries).
- **Explaining something new:** if the reader is new to the material, run the three checks under Explaining Something New: terms sorted by kind with double-duty words flagged, no term used before its definition (diagrams and labels included), and every rule given its cause.
- **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 claim or figure the piece rests on 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 one-line Markdown blockquote beginning `> Revision pass:` (renders like `> Verified:`, so it reads as required output, not prose). Light mode leads with the scan result: `> Revision pass: scan 14→9, 5 kept; two teasing headers rewritten` (or `> Revision pass: scan clean`). Heavy mode uses fixed fields, a missing one flagging a skipped step: `> Revision pass: seed 11 particulars | scan 14→9 | members 2 named | tails 3 rewritten`. The scan count is required. One line, in chat, never the file; observability, not ceremony.
### 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.
- Counts, questions, sources or metaphor verbs in place of the subject: "Two numbers," "Will the fund last," "Survey results," "How the budget is built." Name the subject as a noun phrase. Worked before/after in SKILL.md, Headings.
## 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: thirteen sections, sixteen 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"
section "Category noun for nameable members (name them if short/known)"
# Added 2026-09-23 (design pass by a stronger model). Catches the tell PHRASES only; a bare
# category noun with no phrase ("the methods") stays with the step-4 reading check.
grep -inE "thing(s)? (you|one|we|to)( can| could| do| does| might| get)|each (thing|step|kind|type|way|method|option|part|one|item)|(two|three|four|five|six|seven|eight|nine|ten|several|a few|a couple of|numerous|various|multiple) (ways|things|kinds|types|steps|methods|options|parts|forms|sorts|categories|areas)|(every|any|each) (kind|type|sort) of" "$f"
section "Appositive tail (comma + short trailing phrase; judge each)"
# Added 2026-09-23. Trailing "…, <1-4 words><end>". Excludes list/table/heading
# lines and tails that open a real clause (and/or/but/which/because/…).
grep -nE ", [A-Za-z][A-Za-z'-]*( [A-Za-z][A-Za-z'-]*){0,3}[.);:!?\"']*$" "$f" \
| grep -vE "^[0-9]*:?[[:space:]]*([-*|>#]|[0-9]+[.)])" \
| grep -viE ", (and|or|but|nor|so|because|if|when|while|though|although|since|that|which|who|whom|whose|as|than|yet) "
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.
- 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 standalone document that will be sent or published, including files written to a scratch directory
- 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
- Claude Code on a Mac. The skill itself is one folder: instructions, four reference files, and a scan script.
- Four small scripts installed outside the skill folder. Claude Code calls them hooks: they run at fixed moments whether or not the AI remembers the skill. Two report after the AI writes, and two can refuse an action outright. They aren't published here because they're wired to the rest of Ida's setup, but How It Fires, below, describes each one.
- Nothing else. No services, no accounts, no credentials.
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 the checks moved, one at a time, outside the AI's control. Four scripts now run at fixed points. Three of them watch only the documents the AI writes for Ida to read and work from, such as study guides, reference sheets and explainers, and leave her notes alone:
- The seed gate runs before the AI creates or edits one of those documents. If the new text holds 150 words of prose or more and no seed exists for that document yet, the script refuses the write. Once a seed exists, every later write to that document passes. The seed is a short note written before the draft: the facts the piece must carry, who will read it, and a sample of the register to aim for.
- The re-scan runs after the AI creates or edits any file with a paragraph or more of new prose, about 40 words. It scans that prose again and reports the hit count into the conversation, so a skipped revision can't hide.
- The heading check runs after the AI creates or edits one of those documents. It pulls out the title and headings and shows them back as a list to judge one by one.
- The send gate runs when the AI opens one of those documents in Ida's browser for her to read. It refuses until two records exist, both newer than the document: the revision note from the pass, and a screenshot check of the document at phone and laptop width.
The two gates can stop an action, and the other two can only report. If a gate itself breaks, it lets the action through, because a gate that wrongly blocks work does more harm than one that occasionally misses.
Every step marked model happens only if the AI follows its own written instructions. The steps marked script run no matter what.
The scripts still have blind spots. The re-scan only reports, so the AI can still ignore what it says. When the AI edits part of an existing document, the re-scan and the seed gate check only the new text, and problems in the surrounding text pass unseen. The first three scripts watch only the AI's own tools for writing files, so a document the AI changes by running a small program passes all three unchecked. The gates confirm that a seed and a revision note exist, but not that either is any good. The send gate covers only the moment the AI opens a document: a document Ida opens herself, or one shared another way, passes unchecked. And text delivered straight into conversation never touches a file, so no script 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.
Before drafting, the AI picks a mode. Heavy covers a document written for Ida to read and work from, anything read by someone other than Ida, and any 300 words or more of new prose in a deliverable. A heavy piece starts from the seed, so the draft is built from a list of named facts rather than from a general sense of the topic, and an explanatory piece of roughly 1,500 words or more also gets a cold read by a stronger model before it ships. Light covers chat copy, log entries and short additions to notes. It runs the sentence checks, the scan and the named checks, and skips the seed.
- 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.
- 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. - 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. - Named checks. Headings read alone as a list, each stating its section's contents; list items varied when three end the same way; category nouns replaced by the things they stand for; every verb checked for whether it can physically happen to its subject; coined labels replaced with plain descriptions; register checked against the exemplars (
exemplars.md, withcraft-principles.mdfor judgment calls). When the reader is new to the material, three more checks apply: every unfamiliar term sorted by what kind of thing it is, no term used before it's defined, and every rule given its cause. - Grounding audit. Every load-bearing claim points to a source, gets cut, or becomes an open question.
- 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.
- Scale to stakes. Longer pieces get more structural work, but every piece, however short, gets the full scan.
- Revision note. One line in chat, leading with the scan count, so a skipped scan is visible. A heavy piece's note has fixed fields (seed, scan, named members, rewritten tails), so a missing field shows which step was skipped.
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 eleven sections the scan had then:
$ 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.
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.
Five entries to the Gotchas list, the grounding audit step, and the rewrite-from-source instruction, each after a specific failure.
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.
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.
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.
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.
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.
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 document for Ida to read, such as a study guide, pulls out its 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.
A design pass by a stronger model split the skill into two modes and added the seed: for heavy pieces, the AI writes down the facts, the reader and the target register before drafting, since a draft written from a topic comes out abstract. The seed gate went in the same day to refuse writing a large document without one. The scan gained two sections, for category phrases like "each thing you can do to a garment" and for sentences that trail off in a short tacked-on phrase. The heading check gained three tests after copy that passed the scan still read weak: a heading names a specific thing, never tells the reader how to feel, and parallel subheads carry the noun rather than a pronoun.
A study guide on how yarn thickness is numbered had grammatical sentences and still lost its reader: one word named both a measuring method and the unit of its answer, and a diagram used terms before the text defined them. Three checks came out of it, now in the Explaining Something New section. The same week, Ida rewrote a set of Claude's headings, and the five ways they failed (a count, a question, a source, a metaphor verb or a pronoun standing in for the subject) became the heading rules, with an invented before-and-after list in the published file.
Twice in one day, a page reached Ida without the revision pass. One was drafted in one session and sent in the next, so no write-time script ever saw it. Small programs were also writing many pages, and the write-time scripts don't watch those. The AI opening the document for Ida is the one step every document passes through on its way to her, so the send gate checks there for the revision note and the screenshots.