AI writes 90% of my code and 0% of my first drafts.
David Crawshaw reports that in one year, coding agents went from writing 25% of his code to 90%. His reading-to-writing ratio shifted from 50-50 to 95-5. He reads almost everything now, writes almost nothing. Peter Steinberger takes it further: agents write pretty much 100% of the code on his 300,000-line TypeScript project.
By that logic, AI should write most of my articles. It writes none of the first draft.
I shipped four articles about AI-assisted engineering over the past month. Each one went through 5+ revision passes with Claude. By the third article, I had a clear sense of what AI could and couldn't do in my writing workflow. It could tighten my prose, catch structural problems, and enforce formatting rules. It couldn't write an opening paragraph that sounded like me. It couldn't identify which commit hash proved my point. It couldn't tell whether a URL it generated actually resolved to a real page.
In code, AI generates and I debug. In writing, I generate and AI edits.
what AI actually does in my writing workflow
After 20+ revision passes across four articles, I settled on a 7-step editorial handoff:
- I write the first draft. Outline, anecdotes, data, claims, structure.
- AI does structural editing. Identifies flow problems, flags sections that are too long or thin.
- I apply structural changes. Accept, reject, or modify.
- AI does line editing. Tightens prose, enforces formatting patterns, catches inconsistencies.
- I do factual verification. Every link, every number, every name, every date.
- AI does a final formatting pass. Inline code, bold-lead consistency, link format.
- I read the final version aloud. If any sentence sounds like it was written by AI, I rewrite it.
Steps 2, 4, and 6 are AI. Steps 1, 3, 5, and 7 are human. The AI does the editing. I do the generating and the verifying.
AI is reliably good at the editing tasks. It catches structural problems I miss, tightens wordy paragraphs, and enforces formatting rules across a full article without drift. Structural analysis, parallel construction, compression. These are editing tasks, not generation tasks.
I don't ask AI to write my articles. I ask it to tighten my prose, enforce my formatting, and find structural problems. It's an editor, not a writer.
why the ratio inverts
The inversion happens because voice is harder to specify than conventions.
My CLAUDE.md file for code gets 100% compliance on commit format. "Use Conventional Commits" is a complete specification. The AI follows it every time. I can specify indentation rules, naming conventions, import ordering, test structure. These are conventions. They have unambiguous right answers.
"Write like André" is not a complete specification.
I tried. Voice rules ("first person singular, direct, opinionated, measured"), example paragraphs, explicit instructions to "match this exactly." It works for about four sections. By section 6 of a whole-article revision, the voice drifts. The prose is competent but it sounds like a capable writer who is not me. Hedging creeps in. Sentences get more balanced, more cautious. The specific details I fight for ("43 seconds into a Docker build") get generalized ("shortly after starting the build").
Conventions are specifiable. Voice isn't. Not yet.
CLAUDE.mdgets 100% commit format compliance. No amount of voice rules gets 100% voice compliance. The gap between what I can specify for code and what I can specify for writing is where the inversion lives.
The pattern shows up at company scale too. At Craft Docs, Balint Orosz rebuilt the engineering workflow around AI agents. Engineers ditched code reviews entirely for AI-generated code. Customer support became the heaviest AI adopter, automating workflows without engineering help. The tasks that responded best to AI were the ones with clear conventions: code structure, ticket routing, workflow automation. The tasks that resisted were the ones requiring judgment that's harder to encode.
the bottleneck moves but stays human
In code, the human bottleneck is architecture, debugging, and scope decisions. AI generates the scaffolding. I decide what to build, catch the bugs it introduces (fix-to-feature ratio 0.6-2.4x across my 7 projects), and make the calls the model can't make.
In writing, the human bottleneck is argument, evidence, and voice. AI doesn't know my stories or which commit hash proves my point. It doesn't know that debugging the bcrypt escaping bug meant SSH-ing into a production server to trace how bash was interpreting $2b$12$ hash characters. I know that because I lived it. The first draft is human because the evidence is human.
Aruna Ranganathan and Maggie Ye found the same pattern in a 200-person study. AI doesn't reduce work. It intensifies it. The sense of having a "partner" creates momentum but masks cognitive overload. In my writing workflow, the intensification is measurable: 20+ revision passes across four articles. Each pass teaches me something about what AI can and can't do. The passes themselves are the work. The human must click every link, check every number, read every original quote. That verification work doesn't compress with better models.
the revision-to-draft ratio
In the engineering series, I track the fix-to-feature ratio: how many fix commits follow each feature commit. In writing, the equivalent is the revision-to-draft ratio. How many passes does it take to get from first draft to publishable?
Across four articles: 5+ revision passes each. Five different types of pass, each catching different problems.
Structure catches flow breaks and filler sections. Factual verification catches fabricated metrics, invented dates, and URLs that 404. Voice catches hedge cascades, false balance, and transition padding. Technical accuracy catches wrong library names and incorrect API claims. Formatting catches inconsistent inline code and broken link formats.
The thing I keep re-learning: factual verification must be human. AI confirms links are valid without clicking them, validates follower counts without checking the profile, and agrees quotes are accurate without comparing them to the original source. In my most recent article about AI memory systems, I caught 10 corrections that AI missed. AI had written that Levelsio "posted a prompt" when he asked a question. It described convergence as "identical architecture" when "nearly identical" was more accurate. Every one of those fabrications survived multiple AI revision passes. The human pass caught them.
when to stop
Three AI revision passes maximum per section. After that, diminishing returns.
I learned this the hard way. On the third article, I ran six revision passes on the opening section. Each pass tightened something. Each pass also introduced something new. By pass 4, hedging had crept back in. "This is something I observed" replaced "I saw this." By pass 5, I was reverting changes from pass 3. The voice had drifted so far from mine that I was spending more time correcting the AI's corrections than I saved on the original edit.
AI will revise indefinitely. Each pass introduces new changes: some improvements, some regressions. The regressions are subtle. A specific number gets rounded. A direct claim gets qualified. An em dash appears where a period would be more direct. If I'm not watching for these, they accumulate.
My rule now: if I'm reverting AI changes, I stop. I've passed the point of useful AI input.
what the inversion predicts
The inversion isn't permanent. It's a snapshot of where the technology boundary sits in February 2026.
Voice resists specification today because the tools for specifying it are primitive. I can write "match this voice" and paste an example paragraph. That's the state of the art. Skill graphs, fine-tuned voice models, and longer example banks are all attempts to close the gap. Mitchell Hashimoto's harness engineering shows the pattern from the code side: every failure mode gets encoded, and the specification gets more complete over time.
In code, a minimum viable CLAUDE.md is 50 lines. My most complete one reached 438. Conventions that seemed impossible to specify in January were fully automated by February. Commit format, test structure, error handling patterns, deployment configuration. Each one started as a natural-language rule and became a reliable constraint. The same progression will happen for voice. Today I specify voice with example paragraphs and rough guidelines. In a year, the specification tools will be more precise. The question isn't whether AI will write first drafts. It's when the tools catch up to the complexity of voice.
For now, the inversion holds. I write my code with AI and my prose without it. The ratio flips, the bottleneck stays human, and the work that matters is the work the machine can't do yet.
Postscript, Feb 2026: The inversion I described was temporary. Within weeks of writing this, I built a content brain — 250+ rules across 23 files — where AI writes first drafts from structured evidence. The boundary moved not because models got better, but because the harness got more sophisticated. Part 4 traces what happened.
The inversion tells me what AI can and can't do in my writing workflow. But knowing the boundary isn't enough. I needed a system that gets better over time. My content-revision.md has 47 rules, each one a mistake I caught. Part 2 shows the system.
This is part 1 of a series on AI-assisted writing. Part 2: "47 Rules, Each from a Real Mistake" shows the system. Part 3: "Everything AI Fabricates When Editing an Article" maps the 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.