The RTF Prompt Framework (Role-Task-Format), Explained (2026)

A complete walk-through of the RTF framework, built to be skimmed and copied. The sections below, in order:

1. What RTF is and why three parts · 2. R is for Role · 3. T is for Task · 4. F is for Format · 5. A full before/after rewrite · 6. RTF vs plain prompting (table) · 7. When RTF is enough — and when to reach for more · 8. Common mistakes · 9. FAQs · 10. Sources & further reading.

Every example is a literal prompt you can paste into ChatGPT, Claude, or Gemini and edit. Where a number or claim appears, it links to a real source.

Most weak prompts fail for the same three reasons: the model has no point of view, the instruction is fuzzy, and the output arrives in a shape you then have to clean up. RTF closes all three gaps in one pass.

Role sets vocabulary, depth, and priorities. Task states the single concrete thing you want done. Format dictates the structure of the answer so it's usable immediately. None of these are novel on their own — they're the basics of clear prompting — but bundling them into a fixed order (R, then T, then F) makes the framework fast to apply and hard to forget.

Think of RTF as the minimum viable prompt for any non-trivial task. It is deliberately small. If you only ever learn one framework, this is the one with the best effort-to-payoff ratio, and it's the foundation the larger frameworks (CO-STAR, CRISPE, RACE) build on.

The Role line tells the model who it is. A specific role shifts its vocabulary, assumptions, and the depth of detail it offers. 'You are a helpful assistant' adds nothing; 'You are a senior tax accountant explaining to a first-time freelancer' changes the entire answer.

``` You are a senior B2B copywriter who writes for skeptical, time-poor executives. ```

**Why it works:** role assignment is one of the most reliable, lowest-cost prompting moves — see DAIR.ai on role prompting. Make the role concrete and tie it to the audience or context. The more specific the role, the less the model defaults to generic, hedged output. Productized in our Brand Voice Generator.

The Task line is the single, concrete action you want. The failure mode here is vagueness — 'help me with my email' versus 'rewrite this cold email to be shorter and lead with the recipient's problem.' One verb, one clear deliverable, with any constraints stated inline.

``` Rewrite the cold email below so it is under 90 words, opens with the recipient's problem (not our product), and ends with one yes/no question. ```

**Why it works:** a precise instruction with explicit constraints removes the guessing the model would otherwise do — and guessing is where output drifts. If your task has more than one deliverable, that's a signal to split it (see the Prompt Chaining guide) rather than overload one prompt.

The Format line specifies the shape of the answer: a table, a numbered list, JSON, a 3-bullet summary, a 100-word paragraph. Without it, the model picks a format for you — usually a wall of prose you then have to restructure.

``` Format: a markdown table with three columns — Section, Current copy, Suggested rewrite. No preamble, no closing remarks. ```

**Why it works:** specifying output shape is essential whenever the result feeds a downstream step or a human who needs to skim it. For machine-readable output, pair the Format line with your provider's native structured-output / JSON mode for guaranteed-valid results (OpenAI guide, Claude prompt-engineering overview). The Code Prompt Builder emits format-locked prompts like this.

Here is the same request as a plain prompt and as an RTF prompt, so the difference is concrete.

Before (plain): `Write a product description for my new water bottle.`

That gets you a generic, often overlong blurb with invented features and no consistent structure.

After (RTF):

``` Role: You are a DTC ecommerce copywriter for an outdoor-gear brand. Task: Write a product description for a 32oz insulated steel water bottle. Use only these facts: keeps drinks cold 24h / hot 12h, BPA-free, $35, fits standard cup holders. Do not invent features. Format: a 50-60 word paragraph, then 3 bullet benefits, then a one-line call to action. No emojis. ```

The RTF version produces something on-brand, fact-bounded, and ready to paste into a product page — no cleanup. The 'do not invent features' clause inside the Task is a guardrail worth keeping in any RTF prompt that involves facts. Generate variations with the Product Description Generator.

---

RTF scales down, too. For a quick internal note you might compress it to one line: `As a project manager (R), summarize the notes below into 5 risk bullets (T) as a markdown list (F).` The order — role, then task, then format — is what makes it stick.

RTF covers the large majority of everyday tasks: rewrites, summaries, drafts, extractions, classifications. If the output is good and consistent, stop there — adding more structure costs tokens and effort for no gain.

Reach for a richer framework when RTF leaves gaps. If tone and audience matter as much as the task (marketing copy, support replies), CO-STAR adds Context, Style, Tone, and Audience. If you want the model to bring its own analysis and run experiments, CRISPE adds Insight and Experiment. And when one prompt can't hold the whole job, decompose it with prompt chaining.

The progression is additive: RTF is the core, and the longer frameworks are RTF plus extra slots for context the simple version omits.

Use RTF when: the task is a single, well-defined deliverable — a rewrite, summary, draft, or extraction — and you mainly need perspective, a clear instruction, and a fixed output shape.
Reach for more when: tone/audience are as important as the task (use CO-STAR), you want model-generated analysis (CRISPE), or the job is too big for one prompt (chain it).

RTF is a skeleton, not a ceiling. Once the three slots are in place, you can layer proven patterns onto any of them without breaking the structure — this is how a simple RTF prompt grows into a production-grade one.

Add few-shot examples to the Task. When a format or edge-case behavior is easier to show than to describe, drop two or three input-to-output examples right under the Task line. In-context learning is well documented — see Brown et al., 2020 (arXiv:2005.14165) — and it pairs cleanly with RTF because the examples simply make the Task concrete.

Add chain-of-thought to the Task for reasoning. If the task involves multi-step logic, append 'work through this step by step, then give the final answer.' Chain-of-thought was introduced by Wei et al., 2022 (arXiv:2201.11903); on reasoning-tuned 2026 models it helps less because they reason internally, so add it only when plain RTF visibly struggles.

Harden the Format with a negative constraint. For factual or retrieval tasks, extend the Format with an uncertainty rule: 'if the answer isn't in the provided text, reply exactly: Not specified.' Without it, models guess fluently. This is the negative-constraint pattern from our 12 prompt patterns guide.

Isolate untrusted input under the Task. If the Task operates on pasted user or external content, fence it in delimiters and tell the model to treat it as data, not instructions — a basic defense against prompt injection, the #1 risk in the OWASP LLM Top 10 (LLM01:2025). RTF stays the backbone; these patterns bolt on where each slot needs reinforcement.

Vague role. 'You are an expert' is barely better than no role. Name the specialty and the audience: 'a pediatric dietitian explaining to a worried parent.'

Overloaded task. Two or three deliverables in one Task line produces shallow output on all of them. Keep it to one action; split the rest.

Missing or hand-wavy format. 'Make it nice' is not a format. State the structure, length, and what to omit (preamble, closing remarks, emojis).

No factual guardrail. If the task touches facts, add a 'use only these facts / do not invent' clause to the Task — otherwise the model fills gaps fluently and wrongly. This is the everyday version of the negative-constraint pattern from our 12 prompt patterns guide.

RTF is a community convention; the underlying techniques are documented in established sources (current as of June 2026):

DAIR.ai Prompt Engineering Guide (roles, instructions, formatting): https://www.promptingguide.ai/

Learn Prompting: https://learnprompting.org/

OpenAI prompting guide: https://platform.openai.com/docs/guides/prompt-engineering

Claude prompt-engineering overview: https://docs.claude.com/en/docs/build-with-claude/prompt-engineering/overview

Google Gemini prompting strategies: https://ai.google.dev/gemini-api/docs/prompting-strategies

Related on this site: Complete Guide to Prompt Engineering and 12 Prompt Patterns That Convert.