Tutorials
How to Scale Creative Work With AI: A 7-Step Playbook
A practical tutorial on building an AI pipeline that preserves intent, protects quality, and keeps your artistic voice intact as output volume grows.
October 7, 2026
Most AI content pipelines fail for the same boring reason. Volume goes up, taste goes down. The output starts sounding like a dentist's waiting room playlist, and nobody can quite say when it happened.
A recent talk, scaling intent, quality, and artistry with AI, making the rounds on Hacker News — the core argument being that quality degrades not because models got worse, but because operators stopped encoding what they actually wanted. This tutorial takes that idea and turns it into something you can actually build this week.
And no, you don't need a 50-person team or a $200K vendor contract. You need a workflow.
What You'll Build
Pay attention here — by the end of this guide, you'll have:
- A written intent spec that captures voice, taste, and non-negotiables
- A multi-model pipeline for drafting, refining, and critiquing output
- A quality gate that catches generic AI slop before it ships
- A reusable prompt library you can hand to new teammates
This works for writing, image generation, video, music, or code. The principles don't care about the medium.
Prerequisites
Before you start:
- Access to at least two different frontier models (Claude Opus 4.6 and GPT-5 are a solid pair, or any combo you prefer)
- A folder-based workspace (Notion, Obsidian, or just a GitHub repo)
- Honest answers to the question: what makes my work recognizable as mine?
That last one is the real prerequisite. If you can't articulate your taste, you can't scale it. More on that in step one.
Step 1: Write Your Intent Spec
This is the single most important artifact in the whole system. An intent spec is a document that captures what you want, what you don't want, and why.
Photo by Van Tay Media on Unsplash
Most people skip this and jump straight to prompting. Big mistake. A good intent spec is 500 to 1,500 words and covers:
- Voice: Three to five adjectives, plus two or three samples of writing you consider "on brand"
- Anti-patterns: Specific phrasings, structures, or clichés that make you cringe
- Audience assumptions: What does the reader already know? What are they allowed to not know?
- Taste anchors: Three creators, outlets, or works you want to be measured against
- Non-negotiables: Things that are never acceptable (e.g., "never fabricate statistics", "never use the word 'reliable'")
Store this as INTENT.md or similar. Every prompt you write will reference it.
And yes, writing this takes a few hours. That's the point. The hours you spend here save you fifty hours of editing slop later.
Step 2: Pick Your Model Roles
Different models have different personalities. Treating them as interchangeable is a mistake you only make once. According to LMArena (formerly LMSYS Chatbot Arena), Claude Opus 4.6 currently sits near the top of blind human preference tests, ahead of GPT-4o-class peers. But Elo isn't the whole story — what matters is which model is good at your kind of work.
A pattern worth stealing: assign roles.
| Role | Model Suggestion | Why |
|---|---|---|
| First drafter | Claude Opus 4.6 or GPT-5 | Strong prose instincts, follows long specs |
| Critic | Different model from drafter | Independent eyes catch what the drafter missed |
| Fact checker | Perplexity or Grok | Real-time retrieval, cited answers |
| Image/video | Midjourney, Flux, Runway | Specialized visual models beat generalists |
The critic role is where most people go wrong. If you draft with Claude and critique with Claude, you get sycophancy. Draft with one, critique with another. The disagreement is the gold.
Step 3: Build a Prompt Chain, Not a Prompt
Single prompts are for toys. Real work needs a chain.
A minimum viable chain for writing looks like this:
- Outline pass: Model reads INTENT.md plus the brief, produces a structured outline
- Draft pass: Different session, model expands outline into prose, still referencing INTENT.md
- Critique pass: Second model reads the draft and INTENT.md, flags anti-pattern violations and weak sections
- Revision pass: First model takes the critique and rewrites, forbidden from defending its original choices
- Human taste pass: You, with coffee, read it like a reader
That fifth step is non-negotiable. You're not the editor of last resort. You're the editor, period. The models are the junior staff.
# Example critique prompt template
You are reviewing a draft against the intent spec below.
For each paragraph, flag:
1. Anti-pattern violations (list the specific phrase)
2. Sentences that could appear in any article (generic voice)
3. Claims that need a source
4. Opportunities to be more specific
Do not rewrite. Only critique.
<intent_spec>
{paste INTENT.md}
</intent_spec>
<draft>
{paste draft}
</draft>
Step 4: Install a Quality Gate
A quality gate is a checklist that output must pass before it ships. This is where you encode your non-negotiables as something testable, not just felt.
Mine looks roughly like:
- No banned words (I keep a list of 30 or so)
- At least one specific number, name, or date per 300 words
- No paragraph longer than five sentences
- At least one opinion a reasonable person could disagree with
- Opening paragraph isn't a definition
You can automate most of this with a simple script, or just paste the checklist into a final "audit" prompt and let a model run it. Either way, the gate must be stricter than your taste on a tired day. Future-you will thank you.
Step 5: Scale by Templating, Not Copying
Once the chain works for one piece, the temptation is to just copy and tweak. Resist. Templates are better than copies because templates get improved. Copies just get stale.
A good template includes:
- The INTENT.md reference block
- Variable slots for topic, audience, length, and format
- The exact prompt chain, step by step
- The quality gate at the end
Store templates in a /templates folder. Version them. When you find a prompt that beats the previous version by a wide margin, bump it to v2 and keep the old one around for comparison.
This is the "artistry" part of the equation. Your templates are the physical form of your taste. The more you refine them, the more the output feels like you even when you're not in the room.
Step 6: Add Humans at the Right Points
AI-first doesn't mean AI-only. The question is where human judgment is most valuable.
From what practitioners report in public writeups (Simon Willison's blog has good ones), the highest-leverage human touchpoints are:
- Framing: Deciding what to make and why. Models are bad at this.
- Final taste: The last read before publishing. Models can't feel embarrassment.
- Edge-case judgment: When the output is technically correct but strategically wrong.
Everything in the middle (drafting, formatting, variations, image generation, light editing) can be AI-led. The savings are real, but only if you don't let the humans drift into the middle layers out of habit.
Step 7: Measure What Matters
You can't scale what you don't measure. But picking the wrong metric is worse than picking none, because it drags your pipeline toward whatever the metric rewards.
Some metrics worth tracking:
- Shipped-to-drafted ratio: Of pieces drafted, what percent actually ship? Low ratio means your intent spec is weak.
- Edit distance: How much do you change after the AI's final pass? High number means the chain isn't converging on your taste.
- Reader signal: Comments, replies, time on page. Noisy but ultimately the one that matters.
Avoid metrics like word count per day or pieces per week in isolation. Those are inputs dressed up as outputs.
Common Pitfalls
Pitfall 1: Confusing fluency for quality. Modern models write fluently by default. Fluent and generic aren't the same as good. If a sentence could appear in any article on this topic, cut it.
Pitfall 2: Trusting the first model you tried. Different models have genuinely different taste. Reported HumanEval scores vary by model — OpenAI's GPT-4o self-reports around 90% pass@1, while Anthropic's Claude Sonnet family reports in the mid-90s on the same benchmark — but single-benchmark numbers don't predict how a model handles your prose. Try at least three serious contenders before committing.
Pitfall 3: Ignoring the critic step. Skipping critique saves 30 seconds and costs you an hour of editing. Always run it.
Pitfall 4: Over-engineering the pipeline. If your workflow has twelve steps and six models, you've built a hobby, not a system. Three to five steps, two models, one quality gate. That's enough for most teams.
Testing the Pipeline
Before you commit to the workflow, run a bake-off. Pick three recent pieces of work you're proud of, and three you're not. Feed the briefs through your pipeline and compare.
If the pipeline consistently matches your proud pieces, you're done. If it matches your meh pieces, your intent spec is missing something. The gap is almost always in the anti-patterns list — the things you don't want but never bothered to write down.
Iterate on the spec, not the prompts. Prompts fix symptoms. Specs fix causes.
Next Steps
Once the basic pipeline is humming, there are a few natural extensions:
- Add retrieval: Hook your pipeline up to your own writing archive so models can quote your past work for voice consistency
- Add style transfer tests: Periodically ask a cold model to identify who wrote a piece. If it can't tell you from a generic AI, your voice is leaking
- Train a critic: Fine-tune or heavily prompt a dedicated critic model on your past rejections
And one more thing. Revisit your intent spec every quarter. Taste evolves. Specs that were right in April aren't necessarily right in October. The pipeline is a tool. You're still the artist.
