Brief to draft.

Writing with an agent is not "press button, get content."

The first thing most people do with an AI writing tool is paste a half-baked prompt and hope for gold. What they get is generic prose with three em-dashes and two instances of "in today's rapidly evolving landscape." They paste it, tweak a sentence, call it done.

There's a better loop. It takes slightly longer. The output is dramatically better. It looks like this: brief, draft, critique, revise.

By the end of 90 minutes:

• A brief you can hand an agent for any short piece (caption, email, blog intro, product description).
• A drafting agent that writes a respectable first pass from that brief.
• A critiquing pass that identifies specific weaknesses in the draft.
• A revision pass that addresses the critique without destroying what worked.
• A polished piece at the end that actually sounds like you.

The loop applies to any short-form writing. Tweets, email subject lines, blog intros, product copy, meeting follow-ups. Long-form pieces (long blog posts, reports, books) need the same loop applied section by section.

Prereq: Module 005. You need prompt pattern fluency. Module 011 (voice sample) also helps.

Thinker on the four stages.

Four stages. Skip any of them and the output suffers.

Stage 1 is the whole game

Everything downstream depends on the brief. A bad brief produces a bad draft, which takes more work to critique and revise than a good brief would have in the first place.

A good brief has:

• The target reader. Not "general audience." Specifically who.
• The goal. What should the reader think, feel, or do after reading.
• The length. Target word or character count.
• The tone. In specific terms, not "professional but friendly."
• The key points. 3-5 things the piece must cover.
• The don't-dos. Things to avoid (buzzwords, AI tells, overused phrases).

Writing this brief takes 5 minutes. It replaces 30 minutes of iterating on a vague prompt.

Stage 2 should be fast

Give the agent the brief. Get a draft. Don't agonize over it.

The first draft is not the output. It's an input to the next stage. Its only job is to exist so you have something to react to.

Agents are pretty good at generating a first draft from a thorough brief. They're less good at generating something you'd actually send. Calibrate accordingly.

Stage 3 is the secret weapon

Most people skip critique. They write a brief, generate a draft, read it, tweak a sentence, call it done. The result is mediocre.

Critique is a separate pass. A separate agent or the same agent in a different prompt. "Here's a draft. Here's the original brief. List specific weaknesses: where the draft doesn't match the brief, where the prose is generic, where the voice is off."

Critique outputs a list of issues. Not a new draft. Just issues.

Stage 4 addresses critique

Revise based on the critique. Not "rewrite everything." Specifically address each issue.

For small pieces, you do the revision yourself. For longer ones, you can have an agent do it, with strict instructions to preserve the good parts.

The loop in practice

Start to finish for a 300-word piece:

• Stage 1 (brief): 5 minutes.
• Stage 2 (draft): 1 minute (agent time) + 2 minutes reading.
• Stage 3 (critique): 1 minute + 2 minutes reading.
• Stage 4 (revise): 10 minutes.

Total: ~20 minutes. Output: a piece that's genuinely yours, not AI-tinged.

Compare to: writing from scratch (45+ minutes) or typing a vague prompt and accepting what came out (5 minutes but the output is bad).

Talker on writing briefs that work.

A brief is the prompt for a writing task. It's where the whole loop succeeds or fails.

The brief template

## Brief: [title or description]

**Audience**: [Specific reader, 1 sentence]

**Goal**: [What this piece should do, 1 sentence]

**Length**: [Target words or characters]

**Tone**: [Specific adjectives, not generic]
- [Trait 1]
- [Trait 2]
- [Trait 3]

**Key points** (must include):
- [Point 1]
- [Point 2]
- [Point 3]

**Don't** (avoid):
- [Don't 1]
- [Don't 2]
- [Don't 3]

**Voice sample** (match this):
[2-3 sentences of your actual writing]

Eight fields. Takes 5 minutes to fill in. Every one earns its place.

The audience field

"Our users" is too vague. "Product-marketing managers at 50-500 person B2B SaaS companies, usually early in their role, skeptical of AI hype, looking for practical advice" is specific.

The more specific the audience, the sharper the draft. Generic audience produces generic prose. Specific audience produces prose with a voice.

The goal field

Not "be engaging." Something concrete:

• "Get the reader to click the sign-up button."
• "Make the reader understand why caching matters before they dismiss it."
• "Convince the reader their current workflow is broken."

Writing without a goal is ornamental. Writing with a goal bends every sentence toward outcome.

The don't-do list

Agents tend toward generic. Tell them what you're banning:

Don't:
- Use the phrase "in today's rapidly evolving landscape"
- Use the em-dash
- Use "unlock," "harness," "leverage," "transform"
- Start sentences with "In essence" or "Ultimately"
- Use generic metaphors (journey, unlock, deep dive)
- Use three adjectives in a row
- Use "it is worth noting that"

This list gets longer as you discover your personal AI tells. Keep it in a reusable file; attach it to every brief.

The voice sample

Two to three sentences of your actual writing. From your Module 011 voice sample, if you made one. From a recent email or blog post if not.

The voice sample is a calibration anchor. The agent reads your actual prose and patterns its output against it. Small change; big quality difference.

The draft prompt

Now combine brief + drafting instructions:

You are a drafting agent.

[Paste the brief here]

Produce a first draft that:
- Hits the target length.
- Addresses all key points.
- Matches the voice sample.
- Avoids everything in the don't list.

No preamble. Just the draft.

The draft agent's prompt is essentially the brief, wrapped with "produce a draft." The brief is doing the work; the agent's framing is trivial.

The critique prompt

A separate call:

You are a writing critic.

Here is the original brief:
[brief]

Here is a draft:
[draft]

List specific weaknesses in the draft. For each:
- Quote the specific line or phrase.
- Explain what's wrong (doesn't match brief, sounds generic,
  breaks a don't rule, off-voice).
- Suggest a specific fix.

Be direct. Don't soften. This draft will be improved; the goal
is improvement, not encouragement.

Critique output is a list of issues, each tied to a specific line. You'll use this as your revision checklist.

The revise prompt (optional)

For longer pieces, you can have an agent do the revision. Strict instructions:

You are a revision agent.

Here is the original brief:
[brief]

Here is the current draft:
[draft]

Here is the critique:
[critique]

Revise the draft to address every issue in the critique. Do not
make other changes. Preserve the structure, any phrases that
aren't flagged, and the overall voice.

Output the revised draft only. No explanation.

The "do not make other changes" rule is important. Without it, agents tend to rewrite everything, including the parts that worked.

Rememberer on draft history.

Every piece you write goes through multiple drafts. Saving those drafts is where most people slack, and where most quality control comes from.

The folder structure

~/.bot/drafts/
  2026-04-18-product-announcement/
    brief.md
    draft-v1.md
    critique-v1.md
    draft-v2.md
    critique-v2.md
    draft-final.md
    notes.md

One folder per piece. Every draft saved. Every critique saved. You can see the evolution.

This sounds like overkill for a 200-word announcement. It isn't. Writing is iterative, and the ability to look back and compare is how you learn.

The notes file

In the folder, a notes file with:

• What worked in each draft.
• What didn't.
• What you'd do differently next time.

Five minutes of notes, kept across months, is how you refine your own writing practice and your brief-writing technique. After ten pieces, patterns emerge. Your briefs get tighter. Your agents produce better first drafts.

The reusable components

Some brief components don't change piece to piece:

• Your voice sample.
• Your don't-do list.
• Common audience descriptions (if you write for consistent readers).

Keep these in ~/.bot/writing/shared.md. Every new brief references it rather than restating.

The version comparison habit

When revising, occasionally compare v1 against v3:

• What improved?
• What got worse?
• Is there anything from v1 that should have survived but didn't?

It's surprisingly common for the revision loop to over-correct. A fix for one issue introduces a new weakness. The only way to catch that is to compare across versions, which requires saving them.

The don't-keep list

Not everything belongs in the archive. Don't keep:

• Failed drafts where you restarted from scratch.
• Drafts from briefs that were themselves broken.
• Anything older than a year, usually.

The archive is reference material, not a hoard. Quarterly, prune what's no longer useful. Keep the folder light enough that future-you can actually browse it.

When you want the agent to see history

Occasionally, for a piece that's similar to something you wrote before, include the old piece in the brief:

**Reference** (I wrote this 3 months ago for a similar purpose, match the quality bar):
[paste the old piece]

The agent pattern-matches on quality, not just style. This can lift the floor on the draft without requiring more critique iterations.

Doer.

Time to push a real brief through the full four-stage loop and ship a polished draft.

Twelve minutes. Four stages. One short piece you could actually publish.

1. Write the brief (2 min).
2. Generate the draft (3 min).
3. Run the critique (3 min).
4. Revise against the critique (3 min), then lock it (1 min).

Twelve minutes of hands-on. Pick one short piece you actually need to write this week: a launch note, an update to your team, a 300-word post, a paragraph for a memo. Something real, not invented.

Goal:      [what this piece does for the reader]
Audience:  [who reads it, what they already know]
Angle:     [the one argument, not the topic]
Length:    [250 words / 500 words / 3 paragraphs]
Voice:     [two adjectives + one thing to avoid]
Structure: [opener, middle move, close]
Sources:   [links or paths the agent can pull from]
Avoid:     [clichés, phrases, angles that aren't yours]

1. Opener restates the headline instead of earning it.
2. Paragraph 3 contradicts the "avoid" list, uses "leverage" twice.
3. Middle move is missing, the piece has no argument,
   only description.
4. Ending is a summary, not a close. No reader takeaway.
5. Voice drifts into LinkedIn cadence around line 8.

cd ~/.bot/drafts/2026-04-18-piece/
git add .
git commit -m "brief to draft: launch note, final locked"

What just happened

You generated four artifacts: brief, draft, critique, revised draft. Each one is a record of a decision. Together they tell the story of how this piece got made. Future you can open that folder in six months and know exactly why the final sounds the way it does.

Notice what you did not do:

• You didn't one-shot the piece. You four-shot it.
• You didn't read the draft while it was generating. You reacted to the finished artifact.
• You didn't accept all five critique points. You picked the three that mattered.
• You didn't skip reading it out loud. The human ear is the last line of defense.

The 80/20 you just bought

Eighty percent of agent-assisted writing that feels like a human wrote it, not a language model, comes from splitting the work into four artifacts instead of one. The brief. The draft. The critique. The revise. Each is cheap on its own. Together, they produce output that holds up under attribution scrutiny and under your own taste. The remaining 20% (voice transfer, retrieval, multi-piece consistency) is Module 013 material.

Rookie has the three failures that kill this loop most often.

Three ways the four-stage loop goes sideways when you run it solo for the first time. Each one feels reasonable in the moment. Each one produces drafts that read like an agent wrote them, not you.

Failure 1. "Just write me something"

You skip the brief. You type "write a 300-word post about our Q1 launch" and hit enter. The agent writes 300 words. The words are grammatically correct. The words are also bland, generic, and indistinguishable from what the agent would write for any other company on any other launch.

The draft has no angle because you didn't pick one. No voice because you didn't specify one. No avoid list because you never wrote one. You got what you asked for, an essay that could be about anything, which is to say about nothing.

The fix is mechanical. No draft without a brief. Even a three-line brief beats no brief. Goal: get beta signups. Angle: the thing we built is faster than the incumbent by 40x. Avoid: "excited to announce." That's 30 seconds of work that changes the draft from forgettable to specific.

The rule: the brief is where you do the thinking. The draft is where the agent does the typing. If you swap those, you get an agent doing your thinking, which nobody wants.

Failure 2. Accepting the first draft

The agent produces draft-v1. You read it. It's... fine. It's coherent. The sentences parse. You think good enough, ship it.

Here's the trap: "fine" is the modal output of a language model. It's the average of every piece of writing in the training data. Average writing gets forwarded to spam folders. It does not get read.

Draft-v1 is a floor, not a ceiling. It's the starting point the agent gives you so you can see what's wrong with your brief. The critique stage exists specifically because first drafts are always close-but-off. Skipping the critique is skipping the work that makes the piece yours.

When you catch yourself about to ship draft-v1, ask: would I have written this sentence? Would I have used this word? If the answer is no on more than two sentences, run the critique. Every time.

Failure 3. Skipping critique to save time

You look at the clock. The meeting is in 10 minutes. You have draft-v1. The critique-and-revise step feels like a luxury. You skip it.

Here's the math. Running the critique takes 3 minutes. Running the revise takes 3 minutes. That's 6 minutes. The alternative, shipping draft-v1, costs you two things: one bad piece in public, and one hour later fixing it after your colleague pings you to say the third paragraph sounds off.

The 6 minutes of critique/revise is the cheapest time you will ever spend in the loop. Every minute you cut here costs you 10 minutes downstream. The critique is not a polish. It is the work.

If you genuinely have no time, ship draft-v1 with a note to yourself to run the critique tomorrow. Better to defer than to skip.

The underlying shape

All three failures come from treating the loop like a drafting tool instead of a collaboration. A drafting tool generates text. The loop produces a piece that carries your judgment at every stage: what to say (brief), how to say it (draft), what's wrong (critique), how to fix it (revise). Each stage is a place for your taste to show up. Skip a stage, and the agent's taste fills the gap.

Your job is to run all four stages, every time, even when it feels redundant. It isn't.

Manager on how this works inside a team that writes together.

One person running the loop produces one good piece. A team of five running the loop without a shared setup produces five pieces that sound like five different companies. Team writing with agents is mostly a question of shared infrastructure, not shared taste.

The three files that live in your repo

When your team writes with agents, three files need to exist in a shared location. A repo is ideal, a shared Drive works, a wiki page works. Pick one and link to it from everywhere.

• voice.md. Two paragraphs on how your company sounds. Three adjectives. Five phrases you use. Five phrases you don't. One real paragraph of writing from your highest-trusted author as a reference.
• brief-template.md. The eight-field brief template from Talker, with one filled-in example above it so new authors see how it's used.
• prompts/. The drafting prompt, critique prompt, and revise prompt, versioned. Each with a comment block at the top explaining what changed in the last revision.

These three files are the team's shared writing stack. Any author on the team can open them, fill a brief, run the loop, and produce a draft that sounds like the company. Without them, every author invents their own setup, and the outputs diverge.

Draft reviews, not draft approvals

The temptation with agent-assisted writing is to make the editor a gatekeeper: run your draft past me before you publish. That collapses under volume. If your team ships 30 pieces a week, the editor becomes the bottleneck.

Better model: reviews instead of approvals. The editor reviews the brief and the voice sample once per quarter, not every draft. Authors ship on their own authority. The editor spot-checks 10% of what shipped, flags patterns, and updates the shared voice file when something new emerges.

This shifts the editor's job from policing drafts to maintaining the system that produces drafts. Higher leverage. Less bottleneck. Authors get faster, editor gets more strategic work back.

The agent is the first reader

Re-read the critique prompt from Talker. Notice what it does: it reads the draft as a reader would. That means your team's agent is, in practice, the first reader every piece passes through. Before an editor, before a colleague, before the public.

This has a useful implication: upgrade the critique prompt and you upgrade every piece the team ships. Add a new critique rule ("call out any sentence that starts with a vague subject") and every author benefits from it the same day. The critique prompt becomes your highest-leverage editorial investment.

Keep the critique prompt in the shared prompts/ folder. Version it. Comment every change. Treat it like the style guide, because that is what it has become.

Voice drift across authors

Three authors, all running the loop, all using the shared voice file, will still produce drafts that sound subtly different. The difference is usually the brief. Author A writes briefs that over-specify structure; Author B writes briefs that under-specify angle; Author C writes briefs that ask for 500 words when 200 would do.

Surface this in a quarterly review. Read 10 recent drafts from each author. Identify one pattern per author. Coach on the brief, not the draft. The draft is downstream of the brief. Fix the brief, fix the drafts.

The handoff

When someone on your team leaves and their agent-assisted writing stack needs to transfer: if voice.md, brief-template.md, and prompts/ are in the repo, the handoff is complete. The new author reads the three files, runs their first loop, and produces something that sounds like the company from day one.

If those three files live in someone's Notion, someone's Claude project, someone's head, the handoff fails, and the new author spends two months inventing their own setup that quietly contradicts the original.

Boring is good. Shared files in a known location survive turnover.

Chief takes the risks that apply at scale.

Three risks that show up when your organization publishes at volume with AI-assisted writing. All three are underrated. All three are boardroom-level.

Risk 1. Attribution and disclosure

Every piece your company publishes carries an implicit claim: a human wrote this. The moment that claim becomes false, you have a governance question, and depending on your geography, a legal one.

Three positions a company can take:

• Disclose always. Every agent-assisted piece carries a note: drafted with AI, edited by [name]. Pro: honest. Con: readers discount the work; competitors without disclosure get perceived-quality wins.
• Disclose by threshold. Pieces above 70% agent-generated disclose; below 70%, they don't. Pro: practical. Con: the threshold is arbitrary and hard to audit.
• Never disclose, always human-edited. Treat the agent as a drafting tool the way you'd treat a word processor. Pro: matches how the tool is actually used. Con: one leaked prompt history becomes a PR incident.

There is no right answer at the level of principle. There is a right answer for your company, and leadership has to pick it, document it, and enforce it. Picking no policy is a policy, it just happens to be the one that blows up first.

Risk 2. Voice dilution at scale

A company's written voice is a compounding asset. Readers learn to recognize it. Regulators learn to trust it. Customers build expectations around it. It takes years to build and weeks to lose.

Agent-assisted writing, done without the loop, dilutes voice faster than any other single factor. The agent's baseline voice is the average of the training data, which is indistinguishable from the baseline of every other agent-written piece on the internet. If half your pieces sound like the company and half sound like "the internet", the company voice asset depreciates.

The governance response: every piece that leaves the company runs through the four-stage loop, against the shared voice file, with an editor spot-check on at least 10% of output. This is not a stylistic nicety. It is a brand-asset preservation policy.

When you see your company's voice slipping in shipped work, the fix is not usually a new hire. It is an upgraded voice file, tighter brief template, and better critique prompt. Three files.

Risk 3. Volume without value

Agent-assisted writing makes publishing 10x faster. The temptation is to publish 10x more. Six months later, your content team is shipping five times the volume at half the engagement, and nobody can say whether that's a win.

The trap: volume is easy to measure (pieces shipped), value is hard to measure (reader outcomes). Teams optimize what they measure. Absent a value metric, they ship more.

The governance response: tie content budgets to reader-outcome metrics, not volume. Engagement per piece. Qualified leads per piece. Retention lift per piece. Pick one. Report it monthly. If volume goes up and the outcome metric stays flat, the extra volume is noise and should be cut, regardless of how cheap it was to produce.

A useful heuristic for execs: if your content team tells you they can ship 3x more pieces this quarter, ask why is that good?. If they can name the reader behavior the extra volume produces, it might be good. If they can't, it isn't.

The governance frame

If your organization publishes at scale with agent assistance, three things need to exist as policy:

1. Disclosure standard. Written, signed, enforced. Whatever you pick, stick to it, and review annually.
2. Voice preservation. Shared voice file, brief template, critique prompt. Editor reviews the system, not every piece.
3. Value-tied budgets. Content spend tied to reader outcomes, not volume. Volume goals are a trailing metric at best.

None of these are technical problems. They are governance problems that happen to involve technology. The content team can run the loop. The policy has to come from leadership, and it has to come before the first piece ships at volume, not after the first public mistake.

The chief's two questions

Two things a board member should be able to answer about any piece the company publishes:

• Who is responsible for the voice of the company in writing, and where is the voice documented?
• What happens when a piece ships that doesn't sound like us?

If the answer to the first question takes more than 30 seconds, you have a governance problem. If the answer to the second is we retract, we correct, we update the voice file, you have a mature operation. If the answer is we'd have to figure that out, you have an incident waiting for a calendar to fall on.

Founder wraps it.

You, alone, at your desk, 20 minutes before a deadline, shipping a piece that sounds like you and not like ChatGPT. Here's the whole stack of this module, collapsed into one operator's workflow.

The 90-minute writing habit

When you write a real piece (launch note, update post, memo, essay), block 90 minutes. Not in pieces. One sitting.

• 10 minutes: fill the brief. All eight fields. Skip nothing.
• 15 minutes: generate draft-v1. Save. Step away for 2 minutes.
• 15 minutes: run the critique. Read it. Pick the top 3 points.
• 20 minutes: revise against the top 3. Generate draft-v2.
• 20 minutes: read aloud, hand-fix the sentences that made you pause, lock final.
• 10 minutes: commit the folder, tag what you learned.

If you have this habit, every piece you ship is a little more yours than the one before it. If you don't, every piece is a new adventure and you relearn the same lessons.

The folder you keep

One folder. Call it ~/.bot/drafts/. Every piece you run through the loop lives there as its own dated subfolder. Every subfolder has the same five files.

~/.bot/drafts/
  2026-04-12-launch-note/
    brief.md
    draft-v1.md
    critique-v1.md
    draft-v2.md
    final.md
  2026-04-15-q2-memo/
    brief.md
    draft-v1.md
    critique-v1.md
    draft-v2.md
    final.md

This is not architecture. This is housekeeping. The value is cumulative: over a year, you build a corpus of your own writing where every piece carries its brief and its critique alongside it. You can open any folder six months later and see exactly why the final sounds the way it does. Nobody else has this. It becomes yours.

The weekly writing review

Once a week, 15 minutes. Pick three pieces you shipped in the last seven days. For each:

• Read the final out loud one more time.
• Note one sentence that you wrote by hand after draft-v2.
• Note one critique point that actually improved the draft.
• Update ~/.bot/me.md if a new voice pattern emerged.

This is the founder's equivalent of a film critic watching their own reviews. It compounds. After 52 weeks, your voice file is 52 iterations sharper than when you started, and the agent's draft-v1 is 52 iterations closer to what you would have written anyway.

Using Claude to pre-edit Claude

A useful solo move: after the critique, before the revise, run a second critique from a different angle.

The first critique asks: what's weak about this draft against the brief?. The second critique asks: what would a reader who hates marketing writing say about this draft?. Or: what would your most-trusted colleague cross out?.

Two critiques from two angles catch twice the weak spots of one critique. You still only revise against the top 3 points across both, not all 10. Pick the three that cut the deepest.

The rule: never use the agent to evaluate its own revise. The revise output needs your eyes, not the agent's. LLM-grades-LLM breaks down on taste judgments, which is most of what matters in writing.

The three files that live on your laptop forever

After this module, you should have:

• ~/.bot/me.md with a solid voice section: three adjectives, five phrases you use, five phrases you don't.
• ~/.bot/brief-template.md, the eight-field template with your defaults filled in.
• ~/.bot/drafts/2026-04-18-piece/, your first real run through the loop, with all five files.

Keep those three things. Don't delete them when you move to Module 013. They become the seed of your writing practice. Every future piece you ship copies from them and adapts.