The same Claude that invents follower counts also tightens prose beautifully. The difference is 47 rules.
In Part 1, I described how the code-to-writing ratio inverts completely: AI generates my code, but I generate my prose. The inversion created a problem. AI keeps making the same editing mistakes unless I tell it not to. So I built a system.
I asked AI to tighten a paragraph about David Crawshaw's position on agent harnesses. Crawshaw's original stance was nuanced: harnesses are "critical" but "as interesting as compiler optimizations during the megahertz explosion." Real but eclipsed. AI rewrote this as "agent harnesses haven't improved much," flipping the nuance from acknowledgment to dismissal.
One word choice. The meaning flipped completely. Crawshaw wasn't dismissing harnesses. He was contextualizing them. AI compressed a qualified position into a simpler framing and fabricated meaning in the process.
I added one rule to my content-revision.md file: preserve the original author's nuance when paraphrasing. Never compress a qualified position into a single adjective.
It never happened again. Mistake, rule, prevention. The same mechanism that fixed my code.
the file that grew through failure
In the engineering series, CLAUDE.md was the breakthrough. A 189-line file encoding every mistake so the AI never repeats it. Wrong Docker platform flag. Incorrect distance formula. Non-conventional commit messages. Each rule traces to a real production failure.
content-revision.md is the writing equivalent. It started as a handful of voice reminders after my first article. By the fourth article, it had grown to 47 rules across five categories: voice rules, formatting patterns, a verification checklist, AI-sounding patterns to avoid, and prompting strategies. Every rule maps to a real mistake I caught during revision.
The AI-sounding patterns section is where most rules accumulate. Em-dash overuse: AI uses 10+ per article, humans use 2-3. The hedge cascade: "It's worth noting that..." Genericizing specifics: "43 seconds into a Docker build" rewritten to "shortly after starting the build." Each pattern was invisible to me until I caught AI doing it, and now I can't unsee it.
The engineering parallel is direct. In my deployer agent project, a 919-line prompt has a CRITICAL FIXES section where every rule maps to a deployment failure: uppercase server types that broke case-sensitive APIs, Docker images built on ARM that failed on AMD64 servers, shell escaping that corrupted bcrypt hashes. The prompt uses "MUST" 50+ times and "NON-NEGOTIABLE" multiple times. That language isn't politeness. It's engineering born from real deployment pain.
content-revision.md uses the same approach. "Every number attached to a social post must be manually verified." "Always go back to the primary source and compare wording." These aren't style suggestions. They're rules that exist because the alternative was publishing something false.
the 5-pass system
The biggest mistake I made early on was asking AI to "revise this article." Whole-article revision produces a mushy, over-edited result that loses voice. The fix was structured passes, each with one job:
- Structure and flow. AI analyzes the overall argument, identifies sections that are too long or thin, flags filler. I don't let it rewrite anything in this pass. I read its analysis and restructure manually.
- Factual verification. Human only. Every link clicked. Every number checked against the source. Every quote compared to the original. AI cannot do this pass. It will tell you links resolve without checking them. This is exclusively human work, and it's the most tedious pass, which is why I do it second while I'm still fresh.
- Voice and tone. AI checks against my voice rules, but I revise in sections, not whole-article. Whole-article revision causes voice drift: consistent in section 1, generic by section 6.
- Technical accuracy. AI flags potential inaccuracies in library names, version numbers, API behaviors. I use this as a signal of what to double-check, not as a source of truth.
- Formatting. AI enforces inline code for technical terms, bold-lead paragraph consistency, link formatting. This pass must be whole-article because section-by-section formatting causes inconsistency:
CLAUDE.mdgets backticked in section 2 but appears plain in section 5.
The order matters. Structure first because it moves paragraphs, invalidating line-level edits. Voice third because structural changes introduce AI-sounding language. Formatting last because it's mechanical. The pipeline turns an amorphous "editing" process into repeatable, debuggable steps.
six prompting strategies, each from a failure
Every strategy in content-revision.md was learned the hard way.
"Feed the voice rules first." On article 2, AI produced generic corporate prose on the first revision pass. The content went in before the constraints. Now the voice rules go in before anything else. Result: immediate voice compliance instead of fighting drift for three rounds.
"Revise in sections, not whole-article." Learned when whole-article revision produced my voice in section 1 and someone else's by section 6. The model's context window is large. Its attention is not uniform.
"Ask for options, not rewrites." Learned when AI confidently rewrote Crawshaw's nuance into something flatter. Now I ask for three alternative phrasings instead of a single rewrite. Options preserve editorial judgment. A single rewrite replaces it.
"Show, don't describe, the tone." "Write in a direct, conversational tone" produces garbage. Pasting three paragraphs of my actual writing and saying "match this" produces my voice. Examples beat instructions.
"Constrain the rewrite scope." "Improve this paragraph" means AI rewrites everything, including the parts that work. "Tighten the second sentence and make the transition to paragraph 3 smoother" means AI touches only what's broken.
"If you're reverting AI changes, stop." The writing equivalent of a failed deployment. Three AI revision passes maximum per section. After that, diminishing returns. If I'm reverting more than I'm keeping, the pass isn't working. Adjust the constraint, don't run another pass.
one pattern, two files
Mitchell Hashimoto calls this "harness engineering." Every time an agent makes a mistake, engineer a solution so it never happens again. His Ghostty AGENTS.md file has lines that each map to a previously fixed bad behavior.
Boris Cherny, who leads Claude Code at Anthropic, ships 10-30 PRs a day without writing code by hand since November. Anthropic reports a 200% productivity increase with Claude Code. That number doesn't come from a better model. It comes from the accumulated infrastructure around the model: instruction files, workflows, constraints.
The parallel between code and writing is structural, not metaphorical:
CLAUDE.md: "MUST use--platform linux/amd64" came from a realexec format erroron a Hetzner servercontent-revision.md: "Preserve the original author's nuance" came from a real nuance flip during revision- Both: mistake, rule, prevention
In my booking system project, AI wrote freeform commit messages for 13 days. I added one line to CLAUDE.md prescribing Conventional Commits. From that moment: 100% compliance. In my writing workflow, AI hedged every claim with "It's worth noting that..." I added one line to content-revision.md listing it as an AI-sounding pattern to avoid. The pattern stopped immediately.
The mechanism works the same way regardless of domain.
why the skill file beats the model
The same Claude that fabricates follower counts and invents project descriptions from repo names also tightens wordy paragraphs and enforces formatting rules across 2,000 words without drift. The difference between these two versions of Claude isn't the model. It's the 47 rules.
"If a stronger model doesn't improve your agent, your engineering is the bottleneck."
Armand Ruiz's summary of the Manus architecture lands the point. Manus has been refactored five times since launch. The engineering around the model matters more than the model itself.
Anthropic's own Skills Guide calls this "execution design": the shift from crafting prompts to designing execution systems. The 5-pass revision system is execution design applied to writing. The 47 rules are the execution layer. The model is the runtime.
when one file isn't enough
content-revision.md is getting big. Voice rules, formatting patterns, verification checklist, AI-sounding patterns, prompting strategies. Five different concerns in one file.
Heinrich argues that single skill files can't capture real domain depth. The next step is "skill graphs": networks of small composable markdown files connected by links, where the agent navigates to exactly what the current task requires. His plugin is 249 interconnected files that teach agents to build knowledge systems.
content-revision.md is approaching that threshold. The fabrication taxonomy alone has 8 categories, each with a root cause and a specific verification method. That could be its own reference document. The graph structure would let a revision agent load only the rules relevant to the current pass rather than all 47 every time.
But that's the future. Today, the file works because it's complete, tested, and specific. Every rule earned its place through failure. Hashimoto calls it harness engineering. Anthropic calls it execution design. I call it content-revision.md. The mechanism is what matters: mistake, rule, prevention. The accumulated, failure-tested constraints that make the model work for me instead of against me.
Postscript, Feb 2026: The 47 rules became 250+. The one file became 23 — a full brain/ directory with skills, prompts, workflows, and lessons. The closing section of this article asked "when one file isn't enough?" The answer came faster than expected. Part 4 shows what the brain looks like.
The skill file tells AI what to do. But what does it do when I'm not watching? Part 3 maps the fabrication taxonomy: everything AI lies about when asked to edit an article.
This is part 2 of a series on AI-assisted writing. Part 1: "AI Writes Code, I Write Prose" explains why the ratio inverts. Part 3: "Everything AI Fabricates When Editing an Article" maps the fabrication taxonomy. Part 4: "The System Outgrew the Series" traces the evolution. Part 5: "I Gave My AI a Brain" builds the brain.
Built in Porto. Data from real articles, real revision passes, real fabrications caught.