The Research → Outline → Draft Pipeline

TL;DR: This is the content pipeline AI-assisted writing actually needs: research, outline, and draft run as three separate passes, not one prompt. Verification sits between the first two as a mandatory gate, not a courtesy check at the end, because a model will produce a citation, a quote, or a statistic that reads exactly like a real one and isn't.

What Is a Research → Outline → Draft Pipeline?

It is three separate AI passes, run in order, where nothing from the second pass gets used until the first pass has been checked against real sources, and nothing from the third pass gets written until the second pass has a locked structure. Research produces a list of claims and the sources behind them. A verification gate checks every claim on that list. Outline turns only the claims that survived the check into a section-by-section structure. Draft writes prose against that structure, one section at a time, using only the claims assigned to it.

The name matters less than the boundary between the stages. A single prompt that asks a model to research a topic and write a finished, 2,000-word article in one pass gives you no point at which a human looks at the raw research before it gets built into a paragraph. Three passes, with a check between the first two, gives you exactly one.

You don't need special tooling to run this. It works as three separate chat turns, three separate saved prompts, or three separate MCP calls from whatever editor you already write in. The pipeline is a discipline about when each job happens, not a piece of software you're missing.

Why Does One Prompt Rarely Survive a Real Article?

It fails for a structural reason, not a taste reason. Asked to research and write in one pass, a model is holding four jobs open at once: deciding what's true, deciding what's worth including, deciding what order things go in, and deciding how to phrase each sentence, and it resolves all four under pressure to just finish the response. Somewhere in that process, a specific number, a named source, or a direct quote appears that sounds exactly like something a real source would say. Often it isn't. The model isn't lying so much as filling a gap the same way it fills every other gap in a response: with the most plausible-sounding continuation of the text so far.

Splitting the passes doesn't change what the model is capable of getting wrong. It changes when you find out. A one-shot draft buries a fabricated statistic inside finished, polished prose, where it reads exactly as confident as everything true around it. A three-stage pipeline puts that same fabrication inside a bare list of claims and sources, before a single sentence of the actual article has been written, where it is far easier to catch and far cheaper to fix. Say the model claims a tool supports a specific setting and cites a page for it; in one-shot mode that claim is now a sentence in your draft. In the pipeline, it's still just a row on a list, waiting to be checked against the page it names.

There's a second, quieter failure that splitting the passes also fixes: a one-shot draft locks in whatever structure the model reached for first, because the same generation that's deciding the argument is also writing the sentences that carry it. Rearranging a section after the fact means rewriting every transition around it. An outline you can see and edit before any prose exists costs nothing to reorder.

Stage One: Research — What You're Actually Building

The research pass should not produce prose. It should produce a working document: a list of claims, each attached to a source URL, plus the exact sentence or fact taken from that source, not a paraphrase of it. If the model can't find a source for a claim, that claim gets labeled unverified rather than dropped silently or stated as fact anyway. This is the deliverable everything downstream depends on, so it's worth being explicit about what you're asking for rather than trusting a vague instruction to look into this first.

A workable research prompt looks like this:

Research [topic]. For every factual claim, statistic, or named source you
include, attach the source URL and the exact sentence you took it from.
If you cannot find a primary source for a claim, label it UNVERIFIED
instead of stating it as fact. Do not paraphrase quotes; copy them
exactly, including punctuation. List contradictions between sources
instead of silently picking one.

Read the output before it goes anywhere near an outline. Open every source URL the model claims to have used. If a citation resolves to nothing, or to a page that doesn't say what the model claims it says, that isn't a formatting problem. It's the single most common failure mode in AI-assisted writing, and it survives a spell-check, a plagiarism scanner, and a careful read, because the sentence around it is fluent and the citation looks exactly like a real one.

Why Is the Verification Gate Non-Negotiable?

Because it's the one point in the pipeline where a fabricated fact looks identical to a real one on both sides of the check, until someone opens the source. A citation to a real, reputable domain, formatted correctly, sitting next to three other citations that check out, is not more trustworthy than one that doesn't. It just looks that way until the link gets opened. This is the specific mechanism covered in Why Does ChatGPT Make Things Up?: a model has no built-in signal that distinguishes a fact it retrieved from a fact it generated to fill a gap in its own response, so both come out sounding equally certain.

Treat verification as a gate, not a caveat you add at the end of the pipeline: nothing from research passes into the outline stage until each claim clears three checks.

1. Does the source URL resolve? Not to a homepage, to the specific page the model cited.
2. Is the quoted fragment an exact, checkable substring of that source? Not a paraphrase wearing quotation marks, and not the same quote with a comma moved or an apostrophe swapped.
3. Does the source actually support the claim attached to it? Sharing a topic isn't the same as backing a specific number or statement.

A claim that fails any of the three gets relabeled unverified or dropped, not softened into a hedge word and carried forward anyway. This is also where a pre-send checklist earns its keep, and where the discipline behind summarizing papers without losing citations generalizes past academic work: give the model explicit permission to say it couldn't verify something, because without that permission a confident guess is the cheapest way to fill the gap instead.

Stage Two: Outline — Structure Comes Only From What Passed Verification

The outline pass takes the checked claims, not the raw research, as its only input. Paste in the verified list rather than asking the model to remember it from a few turns back; a fact that already fell out of the context window gets reconstructed from memory, which reintroduces exactly the fabrication risk the gate just closed. Ask for section headings, the one or two claims each section will use, and the order that best supports the argument, not finished sentences.

Using only the claims below marked VERIFIED, build a section-by-section
outline for an article on [topic]. For each section, list the section
heading, the specific claims it will use (by number), and one sentence
on what that section needs to establish before the next one starts.
Do not introduce any claim that isn't in the list below.

[paste verified claims here]

This is also the point to catch a structural problem while it's still cheap: two sections competing for the same claim, a claim that doesn't fit anywhere, an argument that only holds together if a fact you couldn't verify turns out to be true. Fixing that in an outline costs a few lines of edits. Fixing it in a finished draft costs a rewrite.

One-Shot Prompt vs. the Three-Stage Pipeline

The difference isn't really about output quality on a good day. It's about where a bad day surfaces, and how much it costs once it does.

Stage Three: Draft — Writing Against a Locked Outline

By the time you reach this pass, the model isn't deciding what's true or how the piece is structured anymore. It's writing sentences against constraints you've already settled. Feed it one section at a time: the locked outline, the specific verified claims that section is allowed to use, and nothing else. A model that can only reach for the claims you handed it has far less room to reach for one you didn't.

Write the "[section heading]" section of this article. Use only these
verified claims: [paste the 2-3 claims assigned to this section].
Do not introduce any statistic, quote, or named source that isn't in
that list. If the section needs more support than these claims provide,
say so instead of adding one.

Draft section by section rather than all at once, even though it's slower. A section-by-section pass gives you a second chance to catch a claim that snuck back in during drafting, and a model writing 300 words against three fixed claims drifts far less from what's actually verified than one writing 2,000 words against a whole topic.

Does Every Piece Need All Three Stages?

No, and pretending otherwise is how the pipeline gets abandoned after two weeks. A 200-word product update, an internal status note, or a social caption doesn't carry enough factual weight to justify a separate verification pass; write those in one shot and move on. Run the full three-stage version on anything a reader might cite, share, act on, or make a decision from: a comparison, a how-to with numbers in it, anything naming a competitor, a price, or a study. The test isn't length. It's whether being wrong costs the reader something.

How Does This Change Once You're Running a Whole Content Calendar?

The three prompts above are worth keeping, not rewriting from scratch on the next article. Save the research prompt, the outline prompt, and the draft prompt as templates with the topic and the verified claims as the only variables that change, the same way you'd version a piece of code rather than retype it from memory every time. That's the difference between running this once as a technique and running it as a system you can hand to whoever writes next week's piece, rather than something only you remember how to do.

A personal prompt library is where those three templates actually live, tagged by pipeline stage, so the research prompt is a lookup rather than a memory. Keep a running note of which claims turned out to be unverifiable on a given topic, and why. That note gets more useful every month; it's the record of exactly where this subject's easy, plausible-sounding facts tend to be wrong.

What Actually Goes Wrong When Teams Skip the Verification Stage?

The failures that reach publication share a shape. A real, credible-looking source cited for a sentence it never contained. A statistic attributed to a study that exists but doesn't say that number. A quote rendered close enough to real that it reads fine and is still wrong. None of these get caught by a spell-check, a plagiarism scanner, or a careful skim, because the sentence around the fabrication is fluent and the citation is formatted correctly. Running the ten-check pass on the finished draft won't catch it either; hygiene checks look for ambiguity and missing constraints, not for whether a citation two paragraphs up actually says what it claims. They get caught exactly one way: someone opens the source and reads it.

That's expensive to do after a piece is finished, and it's close to free to do before an outline exists, which is the entire argument for putting the gate where it is. Skipping the stage doesn't save the work. It just moves the cost from a five-minute check on a bare claims list to a correction, a retraction, or a reader who stops trusting the next thing you publish.