1. Cheap to start, expensive to finish
A content pipeline is any system where models research a topic, draft something, and check the draft before a person sees it: reports, documentation, training material, product copy, scripts. The first version is easy to build. One model writes, a stronger model reviews, and the loop repeats until the review comes back clean.
The cost of that design is not set by the model that writes. It is set by how the review decides it is finished. If that rule is wrong, every other saving is swallowed by rounds of review.
This masterclass is built on a real run. In November 2026 we produced scripts for 102 podcast episodes across five shows. In 22 hours the pipeline made 2,740 model calls (1,568 of them to the strongest reasoning model we had, Claude Opus) and used about half of a weekly subscription allowance. When we stopped it, 52 episodes were finished. Everything below comes from that run's own ledgers, review files and logs, and from the controlled pilot we ran afterwards.
2. The first design, and why it looked right
The first design was the one most teams would draw:
- Research. A fast, cheaper model searched primary sources and copied verbatim quotes into a claims file.
- Verify. Code fetched every page and checked that each quote was on it.
- Draft. The cheaper model wrote the script from those claims.
- Two reviews. The strongest model read the draft twice: once for facts, once for how it sounds to a listener.
- Revise. The cheaper model fixed what the reviews flagged, and the reviews ran again, up to six rounds, until both found zero problems.
It looks disciplined. A cheap model does the bulk of the work, the expensive model only judges, and nothing ships until it is clean. Three things went wrong, and none of them was the writer.
3. Failure one: a review with no finish line
The listening review asked the strongest model to flag anything that would mislead or lose a demanding listener. Ask a capable reasoning model what is wrong with a 3,000-word script and it will always find something. It is good at exactly that.
Across 76 first drafts, the listening review found problems in every one of them: 6.9 on average. Not a single draft passed its first review. The loop only accepted an item when a review found zero problems. So items averaged 5.5 rounds of revision, and 54 of 76 ran to the six-round cap. Fresh full reads of scripts that had already been improved kept finding about six new things: the count stayed flat because the question had no end, not because the scripts were not getting better.
The fix is not a stricter or a gentler reviewer. It is a review that can end:
- A fixed checklist. Ten named items (is the idea named early, is the mechanism explained, are both sides argued, and so on), each pass or fail, with the failing line quoted.
- Severity on every failure. A blocker misleads or loses the reader, or breaks a hard rule. A minor item is a real but small improvement. Only blockers and factual errors fail an item.
- One revision, then a final read. If the final read still fails, the item goes to a person with the exact lines. There is no seventh round.
4. Failure two: accepting work nobody re-read
Full reviews are expensive, so after the first round the loop reviewed only the lines that changed. When those changed lines came back clean, the item was marked accepted. Nothing had read the whole final text.
When a fresh full read finally ran at the end of each show, it reopened 44 episodes, 54 times in all. Most had one revision left, so they parked. Every show then needed a second programme of work, trimming facts, an independent read, an editing pass and re-checks, which cost about 340 more calls to the strongest model. Those independent reads also caught real errors the loop had passed: a case used to argue the opposite of what it shows, an opening claim contradicted by the episode's own sources, and cases that belonged to another show.
The rule that replaces it is simple: an item is accepted only after a full read of its final text. Record what was accepted: a hash of the text, a hash of the evidence it was checked against, and the version of the checklist used. Any later edit, by a model or a person, clears acceptance until a final read passes again.
5. Failure three: two reviewers pulling against each other
The fact review flagged any sentence it could not trace to a source. The writer learned the lesson and attached a citation to almost everything. The listening review then flagged that same habit as robotic. In one show the year "twenty twenty-six" was spoken 49 times, nearly always as part of "the company's twenty twenty-six documentation says".
Each fix for one reviewer created work for the other, round after round. Some of the problems the reviewers found had been created by our own rules.
- Write one fact rule for everyone. Specific facts (numbers, dates, names, quotes, findings, what a particular product or law does) need a verified source. Plain reasoning and a correct one-line definition do not.
- Give the writer the reviewer's checklist. The writer checks its own draft against the same items before it finishes. The review then confirms; it does not discover.
6. Put the strongest model where reasoning pays
In the first design the strongest model never wrote a word. Its reasoning reached the page second-hand, as notes to another model, one round at a time. What the writer did not fix came back the next round; one line was flagged five times.
Halfway through one show the writer changed from Grok to Claude Sonnet, which gave us a rough natural experiment. A blind reviewer, not told who wrote which episode, said the later episodes sounded like someone teaching and the earlier ones read like a list of citations. Sonnet's first drafts had fewer problems and took about 15 minutes of writing time per episode against about 129. Yet both groups took 6.5 revision rounds and about 22 calls to the strongest model per episode. A better writer did not lower the cost, because the review rule set the cost. This was not a controlled comparison, so we ran one.
The controlled pilot. Three episodes were researched once, with every quote checked exactly. Each was then written twice, once by Claude Opus and once by Claude Sonnet, from identical sources and instructions, and each version went through the same single review, at most one revision and the same final read. Two blind readers, Opus and Fable, scored each pair labelled only A and B.
| Measure (three episodes) | Strongest model writes (Opus) | Regular model writes (Sonnet) |
|---|---|---|
| Accepted after at most one revision | 2 of 3 | 1 of 3 |
| Blind score, first reader (1 to 5) | 4, 4, 4 | 4, 3, 3 |
| Blind score, second reader (1 to 5) | 4, 4, 5 | 4, 4, 4 |
| Version both readers preferred | 3 of 3 | 0 of 3 |
| Estimated cost per attempt | about twice Sonnet's | about half Opus's |
| Estimated cost per accepted episode | about the same | about the same |
The cheaper writer was not cheaper per usable episode. It cost about half as much per attempt, but fewer of its attempts passed, so the cost per accepted episode came out level, and the stronger model's episodes were better. Three episodes are enough to validate a process. They are not enough to choose a writer for every project, and both readers were Claude models. Run the same comparison on your own content before you decide.
7. The hidden costs
Three costs never showed up in the design review. Each one only became visible because we were reading the usage numbers.
Parallelism multiplies the burn rate
Raising concurrency from one call to three per show moved usage from about 2.5 to about 15 points of the weekly allowance per hour. The total work did not change; the rate did, and it left far less time to react. Change one thing that affects the burn rate at a time, and watch it for an hour.
Every agent call carried the whole account
Command-line agents load whatever the account has connected: mail, drive, calendar and document connectors, plus skills and every tool. A one-word reply carried about 56,000 tokens of fixed context before doing any work, and the writers had tools no writer should have.
Running each call with an empty MCP config, no skills and only the tools that step needs brought the fixed context down to about 2,900 tokens and halved the cost of a trivial call. It is a cost fix and a security fix at once.
Failures that look like content problems
When one provider's credit ran out, every writer call failed with a payment error. The loop read each failure as "the writer needs more evidence" and spent research allowances accordingly: 12 items lost them in 17 minutes. Treat quota, credit and rate-limit errors as a pause. Only an explicit "I changed nothing because no source covers this" should count as missing evidence.
8. Verification means exact
Our quote checker accepted close matches, to tolerate formatting differences. An external review showed what that allows: a long quote with "Google" replaced by "Microsoft" still passed. Thirty-six quotes in finished work had been verified that way.
- Exact means one continuous passage on the page, after narrow normalisation only: typography, case, whitespace. Names, numbers, tense and word order must match.
- Existence and support are two checks. Code confirms the quote is on the page. The review confirms the quote supports the sentence that uses it, with the same attribution, qualifications and scope.
- Reviewers are wrong too. One independent review said an episode never told the listener a source was satire. The text it read said "an overview that linked a satirical page". Check every finding against the text before it becomes an edit.
- Calibrate, then freeze. Before using a checklist, run it on work you know is good and work with known faults. Our first version failed two good scripts on minor points and false positives. Adding severity fixed that without missing any known fault. Then freeze the checklist so results stay comparable.
9. The pipeline that replaced it
- Research once. A capable, fast model gathers verbatim quotes, each with the condition behind any number.
- Exact check. Code, not a model, confirms every quote is on its page. A rejected quote can be re-copied once.
- Write once. The strongest model writes, with the brief, the verified claims, the standard and the reviewer's checklist in front of it.
- Code checks, after every edit. Unknown source ids, banned phrases and research narration are hard failures. Dense numbers and repeated phrases are flags for the reviewer to judge.
- One review. The ten checklist items with severity, plus a fact table. Nothing outside those can fail the item.
- Revise at most once, only if the review failed it.
- Final read in a fresh call, same checklist. Pass: accepted, with hashes recorded. Fail: a person decides, with the exact lines quoted.
| Measure | First design | Replacement (pilot) |
|---|---|---|
| Calls to the strongest model per item | about 20 per reviewed item | 4 when it writes, 2 when it only reviews |
| Revision rounds | 5.5 on average, 54 of 76 at the cap | 0 or 1, then a final read |
| Time per item | hours | 3 to 7 minutes after research |
| Weekly allowance used | about half, for 52 items | under 1 point, for 9 versions |
| Quote check | close matches accepted | exact; 90 of 93 passed first time |
| What a person receives | items parked after six rounds | two or three quoted, small fixes |
At full scale. After the pilot we ran a whole 46-episode season through the replacement pipeline, with the strongest model writing. Twenty of the episodes reused drafts from the first design, with every quote re-checked exactly. The run took about 6 points of the weekly allowance, against about half the allowance for 52 items before, and averaged about four calls to the strongest model per episode.
| 46-episode season | Episodes | Accepted after a final read | Handed to a person |
|---|---|---|---|
| Written new under the replacement pipeline | 23 | 18 | 5 |
| Reused drafts from the first design | 20 | 12 | 8 |
| Pilot episodes | 3 | 2 | 1 |
Every episode handed to a person arrived with one to three quoted lines to fix, usually a dropped qualification or a sentence that said slightly more than its source. Drafts written under the new rules from the start were accepted more often than old drafts that were only reviewed. Fresh reads of the old drafts still found one to three new small fact points each time: the same drift as the first design, at a much smaller scale, and the reason the pipeline stops after one revision and hands the last decision to a person.
10. Running it without surprises
- Pilot first. Run three items end to end and read the ledger before you run the rest. Project the full cost from what you measured.
- Measure every call. Record tokens (input, output, cache read, cache write), the estimated cost and the allowance used, separately. Usage fields can mislead: one research call that fetched nine pages reported zero web requests, because only server-side tools were counted.
- Enforce a budget. A run-wide allowance, a spending cap on each call, at most one retry, and one model call at a time until the burn rate is known.
- Keep the old work. Earlier drafts usually need a review, not a rewrite. Re-check their evidence with the new rules, then review and revise only what fails.
- Leave a person on the last decision. The pipeline's job is to hand a person a short, exact list, not to keep going until something gives way.
A checklist for your own pipeline
- Every review has a stopping rule it can actually meet.
- Nothing is accepted until something has read the final version in full.
- The writer's rules and the reviewer's rules are the same document.
- The strongest model writes where reasoning shapes the output.
- Code checks everything code can check, and "verified" means exact.
- Every agent call is isolated: no connectors, no skills, only the tools the step needs.
- Quota and credit errors pause the run; they never count as content failures.
- Models are compared by cost per accepted item, not cost per call.
11. Executive FAQ
Should we always use the most capable model?
Use it where its reasoning shapes the result, usually the writing and the final judgement. Use cheaper models for gathering and for checks that have a clear answer. In our pilot the stronger writer cost about twice as much per attempt and the same per accepted item.
Why did a quality loop cost so much?
Because it could not finish. A review that looks for "anything" always finds something, so the loop ran until its cap. The cost came from the stopping rule, not from the models.
How do we know the output is good, not just accepted?
Accept only after a full read of the final text, against a checklist calibrated on examples you trust, and have a person blind-read a sample. Track how much a person still has to fix.
What still needs a person?
The last decision on anything that failed the final read, the judgement calls a checklist cannot make, and the choice of which model to trust with the writing. The pipeline should make those decisions small and specific.
What does Cloudadorn do here?
We build and run these pipelines with your team: the checklist, the verification, the budget controls and the measurement, so you can see what each accepted item costs before you scale it.