Judgement and taste
Your writing voice, captured and checked
A way to keep what an AI agent drafts in my name sounding like me. A profile measured from my own writing, a script that counts the phrases I've struck, run again until the draft passes, a reviewer that reads only the finished text, and every correction folded back in with its date. It is a house style guide, run on every draft the way a linter, a program that flags known mistakes, runs over code.
One of 15 patterns I've found working with AI coding agents. An agent drafted the words from my notes, and I haven't edited them yet. See all 15, or read how they are made.
An agent drafted the words from my notes, and I haven't edited them yet. The code was run before it went in.
The problem
AI coding agents, models that write code and text from instructions in a chat, draft a lot of what goes out under my name: reports, emails, pages on this site, the words on buttons. Left alone, the drafts sound like the model. They use the em dash, a long dash I don't type. They reach for words I don't use, open with a set-up sentence, and state an absence as a verdict on someone's work.
A paragraph in the agent's instructions saying "write like me" helps for a while. Then the same correction comes back a week later in another project, and I make it again. Over time my rules ended up spread across the agent's standing instructions, several skills (short sets of instructions an agent loads for one kind of task) and each project's notes. There was no way to tell whether a draft had met any of them.
The idea
Treat the voice as something measured and tested, not described. It runs as a loop of four parts, and the last feeds the first.
- A profile drawn from my own writing. I built it from 30 published essays, 9 business documents I signed and 95 paragraphs of notes I wrote this year without a model. It records numbers rather than adjectives: my median paragraph is 49 words and the 95th percentile is 95, and in this year's plain-text notes there are 15 spaced hyphens and no em dash. Each kind of writing, such as a report, an email or a page, gets its own section. The samples stay private; the profile holds the measurements, a description of each habit and a few short quoted fragments.
- A mechanical check, run until it passes. A script reads the draft and prints one line per hit: a phrase I've struck, an absolute aimed at people or their work ("nobody", "nothing"), an em dash, a paragraph over 95 words. Quoted text and code are skipped. The agent fixes every line and runs it again, three rounds at most. It is a count, not a grade.
- A cold reader. A reviewer that has seen nothing of how the draft was made reads only the text as a visitor would see it, and scores it against a rubric: a fixed list of criteria, each with a real before and after. It runs as a sub-agent, a second agent started for one task.
- Corrections folded back, dated. When I strike a line or say a draft sounds off, the agent records my words, the line, what replaced it and the rule it implies, in a log with the date. A rule that can be counted goes into the script. One that needs judgement goes into the rubric. The profile's date is refreshed each time.
The cold reader has its own page, which covers how the text is rendered and what the reviewer is asked. In this loop it is the half that needs judgement; the script is the half that can be counted.
Each part is familiar on its own. Vale, a prose linter, checks text against a published style guide, and a cold read by someone who hasn't seen the drafts is long-standing editorial practice. What I think is different here is that the rules come from one person's own writing and grow from their corrections.
A version small enough to read
Three made-up samples stand in for my writing. The script measures two things from them, the longest paragraph and whether an em dash appears, and keeps a short struck list with the date each phrase was added. It checks a before and an after paragraph. Then a reader strikes one more phrase and the after paragraph is checked again.
// A tiny voice check. The profile is measured from samples of your own// writing; the struck list is what a reader has struck from your drafts,// each with the date it was added. A draft passes when nothing on either// list turns up. Run with: bun check.ts
// Three short samples of the writer's own prose (made up for this example;// in real use these stay private and only the numbers leave).const samples = [ "I spent the morning with the import script. It reads the export, checks each row against the schema and writes what it can. Rows it can't read go to a separate file with the reason beside them, which is more than I expected.", "The release went out at four. Two people tested it on their own phones first, and one found a button that sat under the keyboard. We moved it.", "I think the slow part is the image step, not the upload. I'd like to measure it before changing anything, so I've added a timer and will look again on Friday.",];
const EM_DASH = "\u2014"; // written as an escape so this file has none of its ownconst words = (s: string) => s.split(/\s+/).filter(Boolean).length;
// The profile: numbers read from the samples, not chosen by hand.const profile = { maxParagraphWords: Math.max(...samples.map(words)), usesEmDash: samples.some((s) => s.includes(EM_DASH)),};
// Struck by a reader, with the date each was added. Feedback lands here.type Struck = { pattern: RegExp; note: string; added: string };const struck: Struck[] = [ { pattern: /\bhonestly\b/i, note: "intensifier", added: "2026-03-02" }, { pattern: /\bgame-changer\b/i, note: "hype; say what changed", added: "2026-03-02" }, { pattern: /\bleverage\b/i, note: "say 'use'", added: "2026-03-09" }, { pattern: /\bmust\b/i, note: "reads as an order; 'would need to'", added: "2026-03-09" },];
// Absolutes aimed at people or their work: say where you looked instead.const absolutes = /\b(nobody|no one|nothing|never|always|everyone)\b/gi;
function check(draft: string): string[] { const hits: string[] = []; // Quoted text is someone else's words, so it is not counted. const text = draft.replace(/"[^"]*"/g, '""'); for (const s of struck) { const m = text.match(s.pattern); if (m) hits.push(`Struck "${m[0]}" (${s.note}, added ${s.added})`); } for (const m of text.matchAll(absolutes)) hits.push(`Absolute "${m[0]}"`); if (!profile.usesEmDash && text.includes(EM_DASH)) hits.push("Em dash (none in your samples)"); const n = words(text); if (n > profile.maxParagraphWords) hits.push(`${n} words (your longest sample is ${profile.maxParagraphWords})`); return hits;}
function report(label: string, draft: string) { const hits = check(draft); console.log(`${label}: ${hits.length ? "FAIL" : "PASS"}`); for (const h of hits) console.log(` ${h}`);}
console.log(`Profile from ${samples.length} samples: paragraphs up to ${profile.maxParagraphWords} words, em dash ${profile.usesEmDash ? "used" : "not used"}.\n`);
const before = `Honestly, the new deploy script is a game-changer ${EM_DASH} but nobody checks the backups and nothing records who ran it. We must leverage the old scripts and never ship without a review.`;report("Before", before);
const after = "The new deploy script runs the database step in one command. In terms of backups, I couldn't see where they are checked. Recording who ran each deploy would make a bad release easier to trace. I'd suggest a review before each release.";report("After", after);
// A reader passes the draft but strikes a phrase the list did not have.// It goes on the list, dated, and the same draft is checked again.struck.push({ pattern: /\bin terms of\b/i, note: "formal; say the thing", added: "2026-03-16" });console.log('\nReader strikes "in terms of" on 2026-03-16; added to the list.\n');report("After, checked again", after);
const final = "The new deploy script runs the database step in one command. I couldn't see where backups are checked. Recording who ran each deploy would make a bad release easier to trace. I'd suggest a review before each release.";report("Final", final);Run with Bun, a JavaScript runtime, it prints:
Profile from 3 samples: paragraphs up to 43 words, em dash not used.
Before: FAIL Struck "Honestly" (intensifier, added 2026-03-02) Struck "game-changer" (hype; say what changed, added 2026-03-02) Struck "leverage" (say 'use', added 2026-03-09) Struck "must" (reads as an order; 'would need to', added 2026-03-09) Absolute "nobody" Absolute "nothing" Absolute "never" Em dash (none in your samples)After: PASS
Reader strikes "in terms of" on 2026-03-16; added to the list.
After, checked again: FAIL Struck "In terms of" (formal; say the thing, added 2026-03-16)Final: PASSThe before paragraph trips all four struck phrases, three absolutes and the em dash. The after paragraph passes the list as it stood. Then a reader strikes "in terms of", which the list did not have. It goes on with its date, the same paragraph now fails, and the final version passes. The list only grows from a correction, so it records what this reader objects to rather than what a model guesses they might.
How the loop runs on my drafts
The agent drafts for the kind of writing it is, runs the script until it passes, and gives a text file of the result to the cold reader. The reader scores 11 of the rubric's 16 criteria from 0 to 2, so 22 at most, and a draft is ready at 18 with no zero. The other five are the script's. A web page is scored on four of the criteria, 8 at most, and is ready at 7 once every reference a first-time visitor couldn't follow is fixed.
The agent revises from the lines the reader quoted and goes round again, three rounds at most. Every draft reaches me with its scores beside it: the script's result, the judged total, any criterion under full marks with the line that cost it, and what the check could not see.
I set the thresholds on two versions of one note of advice I wrote for a client: the first draft an agent wrote, which I rejected, and the final I approved. The reader scored the approved one 16 of 18 and the rejected one 3 of 18, with six zeros; the rubric had 18 points then. The script failed the rejected draft on the lines I had struck by hand.
Not the same as how agents talk to me
The profile is only for text that goes out as me. How agents reply to me in a chat is a separate set of rules in their standing instructions, written for a reader with many pieces of work open at once. The answer comes first, the piece of work is named, every ticket number is explained and every claim has its evidence beside it. Those are still prose rules with no script behind them.
Where the plain form falls short
The plain form is a paragraph of instructions saying "write like me", perhaps with a few samples pasted in. These are the problems I've met.
- Samples get reused as stock phrases. Paste in a few paragraphs and the agent reuses their best phrases in every draft. The profile keeps only a few short fragments, treats each as evidence and allows it once per piece.
- A borrowed word list bans words you use. Published lists of the words models overuse are a good start, but some of them are words I do use, such as "robust". I kept only the ones with no hits in my own writing.
- A rule for one reader misleads with another. A criterion written to help a non-technical client follow a report made public pages read as if written for a child. Pages now have a separate set of criteria, written for an interested adult.
- The loop run over my own text. When I asked an agent to tidy something I had written, the loop's rewrites replaced my phrasing with the model's. Now my own text keeps my words, and only the facts I ask about change.
- A reviewer who watched the draft tends to agree with it. A reviewer given the conversation or the source reads the writer's intent into the page. The cold reader gets the rendered text and nothing else.
- Rewrites add claims. A suggested rewrite can sound better and say more than my notes and source material support. Rewrites are checked against those before they go in.
- A pass that misses the tone. A sentence can be cold without one struck word in it. The script can't see that, which is what the reader is for.
Trade-offs
- The profile is dated. Most of my essays are from 2013 and 2014, so some of their turns of phrase are ones I've partly outgrown. The profile says so, and for reports and emails it relies on what I've written recently.
- The script is tuned for reports and emails to clients. On a technical page it flags words such as "failure" and "must" that are fine there, so on those pages I pick another word and keep the meaning.
- Each draft costs a paid model run. The script is free to run and the cold read is not, so the read waits until the script passes.
- The lists grow. Every correction adds a line, and an old rule can outlive its reason. The dated log is what lets me find one and drop it.
When to use it, and when not to
It suits anyone who has agents drafting text that goes out under their name, and enough writing done without a model to measure. It is not for editing someone else's words, which keep the voice of the person who wrote them, or for how an agent talks to you in a chat. With only a few pieces of your own writing the numbers won't mean much, so start with the struck list and let corrections build it.
Example. The voice check, on GitHub
A draft skill for this pattern
A skill is a short set of instructions you give a coding agent so it applies a pattern the way you would. Copy the text below into a file called SKILL.md, in the folder your coding agent reads skills from. In Claude Code, Anthropic's coding agent, that is .claude/skills/voice-check/. It is a draft, and I haven't tried it on anyone else's project yet.
---name: voice-checkdescription: Use when an AI agent drafts text a person will send or publish under their own name (a report, an email, a page, product copy), to keep it in their voice. A profile measured from their own writing, a mechanical check run until it passes, a cold reader that sees only the rendered text, and every correction folded back into the lists with its date.---
# Voice check
A style guide that an agent reads is easy to drift from. This one is measuredfrom the person's own writing, checked by a script before anyone reads thedraft, read cold by a reviewer, and updated every time the person corrects adraft. Scores go beside every draft.
## Build the profile from their real writing
1. Collect writing the person wrote and sent themselves, with no model in the loop. Group it by kind of writing: essay, report, email, page or product copy, brief to their own team. Each kind gets its own section of the profile.2. Measure, rather than describe from memory: paragraph length (median and 95th percentile), sentence length, which dash they type, how often they contract, how often they hedge and what they hedge.3. List the words and phrases their writing never uses. A word with zero hits across the samples is a candidate for the struck list; a word they do use stays off it, even if a published list of "AI words" bans it.4. Keep the samples private. The profile carries numbers, descriptions of each habit and at most a few short fragments. Note what it was built from (how many pieces, which years) and the date.5. Quoted fragments in the profile are evidence, not a kit. Use any one at most once per piece.
## Run the mechanical check until it passes
1. Write a script that reads the draft and prints one line per hit, with the line number: struck phrases, absolutes aimed at people or their work ("nobody checks", "nothing records"), a dash they do not type, and any paragraph over the profile's limit.2. Skip quoted text and code, so quoting someone else's words is allowed.3. Exit with an error when the draft fails, so an agent can loop on it.4. Fix every listed line and run it again. Stop at a pass or after three rounds, and say which.
## Read it cold
1. Render the draft to plain text, in reading order. For a page, include labels and captions, never the source file.2. Give a fresh reviewer only that file and a rubric: fixed criteria, each scored 0 to 2, each with a real before and after. Nothing about how the draft was made. See the cold reader pattern for how the reviewer lists every reference a first-time visitor could not follow.3. The reviewer quotes every line that cost a point and suggests a rewrite.4. Set a threshold that counts as ready (a total, no zero on any criterion) and revise until the draft reaches it or the rounds run out.5. Never let a rewrite add a claim the records do not support.
## Fold every correction back in
1. When the person strikes a line or says how a draft sounds, record it in a dated log: their words, the line they reacted to, what replaced it, and the rule it implies. Add entries at the bottom; never rewrite old ones.2. If the rule can be counted, add it to the script's list with the date. If it needs judgement, add it to the rubric with the before and after.3. Refresh the date on the profile each time it changes.
## Calibrate
1. Keep two versions of one piece: the draft the person rejected and the version they approved. The script and the rubric should separate them.2. When a threshold moves, run both again.
## Show the scores
Every draft goes to the person with the script's result, the judged total,any criterion under full marks with its quoted line, and what the checkcannot see.
## What it does not do
It is for drafting as the person. It is not for editing text they wrotethemselves: change only what they asked, in their words, or the loop'srewrites replace their voice with the model's. It is not for someone else'stext, which keeps its own voice, or for the agent's own replies. The scriptcounts; it cannot tell a polite sentence from a cold one without a bannedword in it, which is what the reader is for. A profile built from oldwriting describes who they were then, so date it and say so. A rule tunedfor one reader can be wrong for another: a rule written to help anon-technical client can make a public page read as if written for a child.