RTF Framework for Prompts: Role, Task, Format with Real Examples

Most bad prompts fail for one reason: the model has to guess what you want. You know the answer in your head — tone, shape, audience — but you typed "write something about X" and hoped.

RTF fixes that with three labels. Role: who the model should write as. Task: what to do. Format: how the output should look. That's it. No acronym soup, no 12-step workshop.

It's not magic. It's a checklist so you stop omitting the part that mattered. In 2026 it's still one of the best starting frameworks for chat UI work — especially before you escalate to few-shot examples or API structured output.

What RTF stands for

Role — perspective, audience, or voice. Not necessarily "expert." Often better as "write for a busy PM" or "respond as a patient support agent."

Task — the action. Verb-first, specific. "Summarize," "compare," "draft," "extract," "critique."

Format — output structure. Bullets, table, JSON, word count, sections, email template, markdown headings.

Template:

You are a [Role]. Your task is to [Task]. Format your response as [Format].

One sentence can work if each piece is concrete:

As a B2B email copywriter, rewrite this subject line to improve open rate. Output: 5 options, each under 50 characters, in a numbered list.

Why RTF works (and what it doesn't do)

RTF separates three decisions people usually merge into a vague paragraph. Models parse structured intent well — role sets register, task sets objective, format reduces reformatting work on your side.

What RTF doesn't provide:

• Source material (paste context separately or use R-T-F-C below)
• Hard constraints (legal limits, banned phrases, citation rules)
• Quality guarantees on facts (role doesn't add knowledge)
• API-level schema enforcement (use structured output for that)

Think of RTF as the minimum viable spec for a chat prompt. Good first draft. Upgrade when evals show gaps.

RTF vs cargo-cult roles

The Role slot is where people break RTF. "You are a world-class genius" fills the field without constraining anything.

Better roles from our role prompting guide:

• Audience: "Write for a non-technical CFO approving budget"
• Behavior: "Respond as a security reviewer who flags only high-confidence issues"
• Genre: "Write as a concise internal Slack update, not a blog post"

If swapping the role word doesn't change the expected output, rewrite the role.

RTFC: when to add Context

Production prompts almost always need a fourth block — Context (data, background, source text). Call it RTFC: Role, Task, Format, Context.

Structure:

Role: ...

Task: ...

Format: ...

Context: [paste document, specs, prior message, constraints]

Put long context after the RTF header so the model sees instructions first, data second. For very long docs, summarize or chunk — see lost-in-the-middle.

Optional fifth block: Constraints — "Do not invent pricing. If unknown, write NEEDS INPUT."

Example 1: Marketing — ad copy variants

Role: Direct-response copywriter for D2C skincare, skeptical of hype claims.

Task: Write 3 Meta ad primary text variants for a vitamin C serum launch. Angle: visible results in 4 weeks without medical claims.

Format: Markdown table with columns Hook | Body (max 90 words) | CTA.

Context: Product: 15% L-ascorbic acid, $38, target 28–45, main objection is "serums don't work."

Why it works: Role sets compliance tone, task defines angle and count, format is paste-ready for a spreadsheet.

Example 2: Engineering — PR review comment

Role: Senior backend engineer reviewing a teammate's PR. Direct but not harsh.

Task: Review the diff for error handling gaps and missing edge cases in the payment retry logic.

Format: Markdown with sections Must fix | Should fix | Nit (optional). Bullet points only, max 2 sentences each.

Context: [paste diff or describe file paths and relevant functions]

Skip "you are a 10x engineer." The role is review style + scope.

Example 3: Customer support — reply draft

Role: Support agent for a SaaS billing product. Empathetic, policy-aware.

Task: Draft a reply to a customer charged twice who wants immediate refund and explanation.

Format: Email template — Subject line, then body under 150 words, sign-off "— Support Team."

Context: Policy: duplicate charges refunded within 3 business days; include last 4 digits if provided; never promise legal outcomes.

Constraints: Do not admit fault without confirmation. Offer escalation path.

Example 4: Education — explain a concept

Role: Physics tutor explaining to a high school student who knows algebra but not calculus.

Task: Explain why satellites don't fall to Earth even though gravity pulls them.

Format: 3 short paragraphs, then 3 bullet takeaways, then 1 check-your-understanding question.

No credentials in the role. Audience level is the constraint that matters.

Example 5: Research — competitive summary

Role: Strategy analyst writing for executives with 2 minutes to read.

Task: Compare Notion, Coda, and Airtable for a 50-person ops team's workflow hub. Focus on permissions and automation.

Format: One-page brief — TL;DR (3 bullets), comparison table (5 rows max), recommendation paragraph.

Context: Team uses Slack, Google Workspace, no dedicated IT. Budget sensitive.

Constraints: Flag anything you're uncertain about as UNVERIFIED. No invented pricing.

Example 6: Content — blog outline

Role: SEO editor for a developer tools blog. Practical tone, no fluff.

Task: Create an outline for an article on structured JSON output from LLM APIs.

Format: H2/H3 markdown outline with 1-sentence description per section. Include FAQ section with 4 questions.

Context: Target keyword "structured output prompting." Audience: backend devs using OpenAI or Claude.

Example 7: HR — job description

Role: In-house recruiter at a mid-size fintech. Inclusive language.

Task: Draft a job description for a Senior Product Designer (B2B payments).

Format: Sections — About us (50 words) | Role summary | Responsibilities (6 bullets) | Requirements (must/nice) | Benefits placeholder.

Constraints: Avoid gendered language. No "rockstar" or "ninja."

Example 8: Data — extract to table

Role: Data extraction assistant. Use only provided text.

Task: Extract all meeting action items with owner and due date.

Format: Markdown table | Action | Owner | Due |

Context: [paste transcript]

Constraints: If owner or date missing, write TBD. Do not infer names not in transcript.

For production pipelines, pair this with structured output API — RTF for chat, schema for code.

Example 9: Creative — short fiction

Role: Speculative fiction writer in the style of tight, image-driven prose (not purple).

Task: Write a 300-word scene — character discovers an obsolete AI still running in a basement server room.

Format: Single scene, present tense, no dialogue tags beyond "said." End on a concrete sensory detail.

Creative tasks benefit from format constraints as much as analytical ones.

Example 10: Personal — decision framework

Role: Neutral decision coach. No cheerleading.

Task: Help me choose between two job offers using my stated priorities.

Format: Decision matrix table (criteria × options, score 1–5), then 5-sentence recommendation with explicit tradeoffs.

Context: Offer A: higher salary, hybrid. Offer B: lower salary, fully remote, more interesting stack. Priorities: remote > salary > title.

One-line RTF prompts that work

Not every prompt needs headers. These pack RTF into one line:

• As a concise tech interviewer, generate 5 behavioral questions for a Staff Engineer hire. Numbered list, one line each.
• As a recipe developer for busy parents, suggest a 20-minute dinner using chicken thighs and pantry staples. Format: ingredients list + 4 numbered steps.
• As a LinkedIn post editor, shorten this draft to under 1,300 characters while keeping the hook. Output: revised post only, no commentary.

Use labeled RTF blocks when tasks get long or multiple people edit the prompt template.

RTF vs other frameworks (quick map)

RTF — simplest; daily chat tasks.

RTFC — add context for anything grounded in documents.

CRISPE (Capacity/Role, Insight, Statement, Personality, Experiment) — heavier; good for reusable system prompts.

TAG (Task, Action, Goal) — task-forward; skip role when it doesn't help.

RISEN (Role, Instructions, Steps, End goal, Narrowing) — multi-step workflows.

Don't collect frameworks. Pick RTF as default, add letters when you notice recurring missing pieces.

Common RTF mistakes

Vague task: "Help with marketing" → "Write 5 tweet threads announcing a feature launch, each under 280 chars."

Missing format: Model returns essay when you needed bullets. Always specify format.

Role overload: Three paragraphs of fictional biography. One line of audience/behavior is enough.

Format without limits: "Write a summary" → "Summary, max 100 words, 3 bullets."

Task + format contradiction: "Be exhaustive" + "max 50 words." Resolve before prompting.

No context on grounded tasks: Asking for analysis of "the report" without attaching it.

When to go beyond RTF

Escalation path:

1. RTF or RTFC — first attempt
2. Add constraints and negative space (what not to do)
3. One-shot example if format still drifts
4. Few-shot if classification boundaries are fuzzy
5. Structured output in API if machines consume the result

PromptMake /text helps at steps 1–3: paste a rough ask, get an RTF-structured prompt with tighter task and format lines. Guest: 3 optimizations/day; registered: 5/day.

RTF in system vs user messages

Reusable products (Custom GPT, Claude Project, app system prompt):

• System: stable Role + default Format preferences + global constraints
• User: Task + Context per request

Ad-hoc ChatGPT/Claude chat: single message with full RTFC is fine.

Checklist before you send

• Role defines audience or behavior, not empty expertise
• Task has verb, scope, and count/scope boundary
• Format is copy-paste ready for your next step
• Context attached if task depends on specific data
• Constraints for uncertainty, compliance, or banned outputs

Frequently asked questions

Is RTF enough for production AI apps?

For chat UX, often yes as the user-facing layer. Backend calls should add schema validation and retrieval — RTF alone isn't a pipeline.

Role or Task first?

Either order works in prose. Put Task first if Role is minimal ("Summarize this as bullet points for executives").

Can I omit Role?

Yes. TF (Task + Format) beats a fake Role. TAG-style prompts skip persona when tone doesn't matter.

Best Format specs?

Be mechanical: word counts, column names, heading levels, "output only, no preamble," JSON keys if not using API schema.

RTF for image prompts?

Different domain. Image models use subject, style, lighting, composition — not RTF. PromptMake /image converts photos to structured image prompts separately.

How is RTF different from "act as"?

Same idea, explicit buckets. RTF forces you to name Format separately — where "act as" prompts usually forget structure.

Related articles

Role prompting 2026 — write roles that constrain, not cosplay.

Structured output — when Format means JSON Schema in the API.

Few-shot vs zero-shot — after RTF fails format consistency.

Positive framing — phrase Role and Task as desired behavior.

Bottom line

RTF is a three-field form: who (or for whom), what, how it looks. It won't fix missing context or factual gaps — add C for context and constraints when needed.

Use the template until it's habit. Then delete the labels in your head but keep the three answers. Most prompt quality gains come from a specific Task and a mechanical Format, not a fancier Role.