Chaining Prompt Frameworks: RTF, RACE, and CRAFT for Multi-Step Workflows

Single prompt frameworks work fine for quick tasks, but complex content such as blog posts or campaigns often falls flat when handled in one shot. The fix is not a bigger prompt but a pipeline.

By chaining frameworks together, each stage focuses on what it does best: RTF outlines, RACE drafts, and CRAFT polishes tone. Here is how to build this three stage chain, manage handoffs in ChatGPT or Claude, and use prebuilt templates for your workflow.

Why one framework isn't enough for complex work

Every prompt framework is optimized for a specific job.

RTF (Role, Task, Format) is lightweight and great at getting a model to think through an open-ended problem, like brainstorming angles or building a skeleton outline. It's not built to carry a lot of contextual nuance.
RACE (Role, Action, Context, Expectation) is heavier and better suited to producing a full draft, because it forces you to feed in context and set explicit expectations for depth, length, and structure.
CRAFT (Context, Role, Action, Format, Tone) adds an explicit tone dimension that RTF and RACE don't emphasize, which makes it the right tool for a final tone and voice pass.

If you try to force one framework to do all three jobs, you end up overloading a single prompt with too many instructions at once. The model has to juggle brainstorming, structuring, drafting, and tone matching simultaneously, and something usually gets diluted. Chaining lets each stage focus on one job, using the previous stage's output as grounded context instead of a blank page.

Note

Think of a prompt chain the same way you'd think of an editorial process: an editor sketches the outline, a writer drafts from that outline, and a copyeditor polishes voice and tone at the end. You wouldn't ask one person to do all three simultaneously in one sitting, so don't ask one prompt to either.

The three-stage chain, explained

Here's the logic behind the sequence, and why it runs in this specific order.

Stage 1: RTF for brainstorming and outlining

At the start of a project, you don't need depth, you need direction. RTF keeps the prompt simple: define the Role the model should adopt, state the Task clearly, and specify the Format of the output. For brainstorming, that format is usually a list of angles or a structured outline, not prose.

Because RTF is lightweight, it's fast to iterate on. You can generate three or four outline variations in the time it takes to write one heavy prompt, then pick the strongest structure before you invest in a full draft.

Stage 2: RACE for draft generation

Once you have an outline you like, you feed it into a RACE prompt as the Context. This is the stage where the real writing happens, so RACE's extra structure earns its keep. The Action tells the model exactly what to produce (a full draft, a specific section, a landing page), the Context carries forward the outline plus any research or product details, and the Expectation sets the bar for length, depth, and level of detail.

This is also where most of the factual and structural heavy lifting happens. If the draft is wrong at this stage, no amount of tone polishing later will save it, so it's worth spending real effort making sure the Context block is complete.

Stage 3: CRAFT for tone calibration

The last stage isn't about generating new content, it's about refining what already exists. CRAFT's explicit Tone parameter makes it the natural fit here. You feed in the RACE-generated draft as Context, define the Role as an editor rather than a writer, and specify exactly how the tone should shift, more conversational, more authoritative, more concise, whatever your brand voice calls for.

Tip

Treat the CRAFT stage as a rewrite pass, not a rewording pass. Ask the model to preserve the facts and structure from the draft while adjusting sentence rhythm, word choice, and level of formality. If you only ask it to "make it sound better," you'll get vague, inconsistent results.

Comparison: RTF vs RACE vs CRAFT

Framework	Best for	Components	Output style	Where it sits in the chain
RTF	Brainstorming, quick outlines	Role, Task, Format	Short, structured, list-like	Stage 1: Ideation
RACE	Full draft generation	Role, Action, Context, Expectation	Long-form, detailed prose	Stage 2: Drafting
CRAFT	Tone and voice polishing	Context, Role, Action, Format, Tone	Refined prose, same structure as input	Stage 3: Calibration

Notice the pattern: each framework picks up roughly where the last one left off, and each one adds a layer of specificity the previous stage didn't need. RTF doesn't need a Context field because there's nothing to reference yet. RACE needs Context because it's building on the outline. CRAFT needs Tone because everything else is already locked in.

Building the chain in ChatGPT or Claude

The mechanics of chaining are simple once you understand the principle: the output of one prompt becomes a labeled input in the next prompt. You're not relying on the model to remember earlier turns implicitly, you're explicitly pasting the previous output into the new prompt's Context or Format field. This matters because conversation memory can drift or get summarized oddly in long threads, but a pasted block of text is unambiguous.

Here's the workflow in practice:

Run the RTF prompt. Copy the outline it returns.
Paste that outline into the Context field of your RACE prompt. Run it. Copy the draft.
Paste that draft into the Context field of your CRAFT prompt. Run it. This is your near-final output.

You can do this manually across three separate messages in the same conversation, or you can build a single "chain prompt" that asks the model to run all three stages internally and only show you the final CRAFT output. Both approaches work, but manual chaining gives you more control, because you can review and adjust the outline before committing to a full draft, which saves you from discovering structural problems only after the draft is written.

Tip

If you're working in Claude, you can keep each stage as a separate Artifact. That way the outline, the draft, and the polished version all exist as distinct, editable documents you can compare side by side, rather than being buried in chat scrollback.

Prompt template: Stage 1 (RTF)

Prompt Template

Role: You are a {{role_description}}.
Task: Brainstorm {{number}} possible outlines for a {{content_type}} about {{topic}}, aimed at {{target_audience}}.
Format: For each outline, provide a title, 3-5 section headers, and a one-sentence summary of what each section covers.

Prompt example: Stage 1 (RTF)

Prompt Example

Role: You are a senior content strategist for a B2B SaaS company.
Task: Brainstorm 3 possible outlines for a blog post about reducing customer churn through onboarding, aimed at heads of customer success at mid-market SaaS companies.
Format: For each outline, provide a title, 3-5 section headers, and a one-sentence summary of what each section covers.

Prompt template: Stage 2 (RACE)

Prompt Template

Role: You are a {{role_description}}.
Action: Write a full {{content_type}} based on the outline provided below.
Context: {{paste_selected_outline_here}}
Additional context: {{product_or_research_details}}
Expectation: The final piece should be {{length}} words, written for {{target_audience}}, and should {{specific_requirements}}.

Prompt example: Stage 2 (RACE)

Prompt Example

Role: You are a senior content strategist for a B2B SaaS company.
Action: Write a full blog post based on the outline provided below.
Context: Title: "Why Onboarding Is Your Real Churn Lever." Sections: 1) The 90-day cliff, 2) What most onboarding gets wrong, 3) A framework for milestone-based onboarding, 4) Metrics to track, 5) Closing takeaway.
Additional context: Our product is a customer success platform. We have internal data showing customers who complete 3+ onboarding milestones in month one churn 40% less.
Expectation: The final piece should be around 1200 words, written for heads of customer success at mid-market SaaS companies, and should include the churn statistic as supporting evidence.

Prompt template: Stage 3 (CRAFT)

Prompt Template

Context: Below is a draft {{content_type}} that needs a tone pass. Preserve the structure and all facts.
{{paste_race_draft_here}}
Role: You are an editor specializing in {{brand_voice_style}}.
Action: Rewrite the draft to match the tone described below, without changing the facts, structure, or section order.
Format: Return the full rewritten piece in the same format as the original.
Tone: {{tone_description}}

Prompt example: Stage 3 (CRAFT)

Prompt Example

Context: Below is a draft blog post that needs a tone pass. Preserve the structure and all facts.
[full draft pasted here]
Role: You are an editor specializing in friendly, plain-spoken B2B writing.
Action: Rewrite the draft to match the tone described below, without changing the facts, structure, or section order.
Format: Return the full rewritten piece in the same format as the original.
Tone: Conversational but credible, short sentences, minimal jargon, second person where natural, no corporate buzzwords.

Managing brand voice consistency across the chain

The biggest risk in a multi-stage chain isn't factual drift, it's voice drift. Each stage is a separate model call, and without reinforcement, tone can subtly shift between the outline, the draft, and the final polish, especially over a long piece.

A few practical habits keep this in check:

Write a one-paragraph brand voice reference once, and reuse it everywhere. Instead of describing tone from memory at each stage, keep a saved snippet, three or four sentences describing your brand's voice, sentence length preferences, words to avoid, and a reference example. Paste this into the Context or Tone field of every stage, not just the final CRAFT pass. This way tone isn't something you bolt on at the end, it's a constraint the model is aware of from the outline stage onward.

Do the tone pass on the whole piece, not section by section. If you run CRAFT separately on each section of a long draft, you risk inconsistent phrasing choices between sections since each call is independent. Running one CRAFT pass over the complete draft gives the model the full context to keep word choice and rhythm consistent throughout.

Keep a small glossary of banned and preferred terms. If your brand never says "leverage" or "utilize," or always says "customers" instead of "users," put that in the Tone field explicitly. Models default to generic corporate phrasing unless told otherwise, and this is the fastest way to flatten that out.

Note

Voice consistency compounds. A single off-tone paragraph is a minor edit. An entire content pipeline that drifts slightly with every run becomes a noticeable brand inconsistency over a few months of published content. It's worth the extra thirty seconds per prompt to reinforce voice explicitly.

Common pitfalls when chaining frameworks

Skipping the review step between stages. It's tempting to run all three stages back to back without reading the intermediate output. But the entire value of chaining is that you can catch a bad outline before it becomes a bad 1500-word draft. Read the outline. Read the draft. Only the final CRAFT pass should feel like a light touch.

Pasting too much context into RACE. More context isn't always better. If you paste in ten pages of research alongside the outline, the model may struggle to prioritize what actually belongs in a 1200-word piece. Trim your context to what's directly relevant to the specific piece you're writing.

Treating CRAFT as a grammar check. CRAFT's job is tone, not proofreading. If your draft has factual errors or structural problems, fix those before the tone pass, not after. Asking the model to simultaneously fix facts and adjust tone tends to produce worse results on both fronts than handling them separately.

Not saving your framework templates. Once you've dialed in a chain that works for your team, save the three prompt templates somewhere reusable (a doc, a prompt library, a Claude Project). Rebuilding them from scratch every time you start a new piece defeats the purpose of having a repeatable pipeline.

When a shorter chain is enough

Not every piece of content needs all three stages. A quick internal Slack update or a one-off social caption doesn't need a formal outline stage. Reserve the full RTF to RACE to CRAFT chain for content where structure and tone both genuinely matter: blog posts, landing pages, email sequences, or anything that will represent your brand publicly and get reused as a template going forward. For quick, disposable content, a single RACE or CRAFT prompt is usually plenty.

The goal of chaining isn't to make every prompt more complicated. It's to match the right amount of structure to the size of the job, so you're not underpowering a big piece of content with a single quick prompt, and not overengineering a five-minute task with a three-stage pipeline it doesn't need.

Acluebox

Craft perfect AI prompts and build powerful, reusable systems. Your all-in-one workspace for prompt discovery, organization and management.

Start for Free

FAQs

Do I need to use ChatGPT and Claude together, or can I chain within one tool?

You can run the entire chain inside a single tool. Chaining refers to the sequence of prompts and how their outputs feed into each other, not to switching between different AI platforms. Some people do mix tools, using one model for brainstorming and another for drafting, but it's a preference, not a requirement.

What happens if the RACE draft doesn't match the RTF outline?

Compare the two before moving to the CRAFT stage. If the draft skipped a section or added unplanned content, it's faster to fix that at the draft stage by re-running RACE with clearer Expectations than to try to fix structural gaps during the tone pass.

Can I skip straight to CRAFT if I already have a rough draft written myself?

Yes. The chain is modular, so if you already have your own outline or draft, you can start at whichever stage matches what you already have and skip the earlier stages entirely.

How long should the brand voice reference snippet be?

Three to five sentences is usually enough. It should describe overall tone, sentence length preference, a few words to avoid, and ideally one short example sentence that represents the voice well. Longer references tend to get diluted rather than followed more closely.

Does this chaining approach work for non-writing tasks, like code or data analysis?

The same principle applies broadly: use a lightweight framework to plan, a heavier one to execute, and a final pass to refine. For code, that might look like an outline of the approach, then a full implementation, then a review pass for readability and style, following the same logic even though the frameworks themselves would look different.