The RTFC Prompt Framework: Role, Task, Format, Constraint (1-Page Manual)

Updated October 22, 2026 — now includes our work-prompt and before/after sheets

Vague prompt in, vague answer out. Most weak AI answers trace back to a prompt that skipped one of four things: who the AI should act as, exactly what to do, what shape the answer should take, and where the boundaries are. That’s the RTFC framework. Fill four slots and the output stops being generic.

Cheat Sheet at a Glance

The Prompts

The fill-in template

Use it for: Start every non-trivial prompt from this.

Act as [role]. [Task, stated with a precise verb]. Output as [format]. Constraints: [length], [tone], [must include], [must avoid].

Why it works: Four labeled slots make it obvious when one is empty.

Example: reviewing copy

Use it for: Checking a product page before it goes live.

Act as a skeptical technical reviewer. Review this product description for unsupported claims. Output as a bullet list, one issue per line. Constraints: under 150 words, quote the specific sentence for each issue: [paste description]

Example: planning

Use it for: Breaking a fuzzy goal into work.

Act as a project manager who has shipped this kind of project before. Break [goal] into milestones. Output as a table with columns Milestone, Owner, Done-when. Constraints: 5 milestones max, each with a testable done-when.

Example: learning

Use it for: Getting up to speed on an unfamiliar topic.

Act as a patient tutor. Explain [topic] to someone who knows [related thing] but not this. Output as 3 short sections: the idea, a concrete example, a common misconception. Constraints: under 250 words, no unexplained acronyms.

Worked Example: One Prompt, Four Passes

The fastest way to see why each slot matters is to build one prompt a slot at a time and watch what the answer does. The job: get feedback on a README before a small open-source release.

Nothing about the model changed between pass one and pass four. The only difference is that the last prompt tells it what a good answer looks like. When an answer disappoints, don’t reword the whole thing. Find the empty slot and fill it.

Reuse RTFC Outside the Chat Window

Once a prompt works, stop retyping it. Where you save it depends on where you use it.

In ChatGPT or Claude Projects

Put the Role and the standing Constraints in the Project’s instructions, and keep only the Task and the pasted material in each message. Every chat in that Project then starts with half the prompt already filled.

As a Claude Code Skill

If you work in Claude Code, a filled-in RTFC prompt is almost a Skill already. Save this as .claude/skills/review-readme/SKILL.md in your repo and run it with /review-readme:

---
name: review-readme
description: Review a README the way a first-time user would. Use when asked to check docs before a release.
---

Act as a developer seeing this project for the first time.
Review README.md for anything that would block a first install or first run.
Output as a numbered list, one problem per line, most blocking first.
Constraints: max 7 items, quote the exact line for each, skip style nitpicks.

The description line is what Claude matches against your request, so write it the way you’d ask for the task. Our Skill setup guide covers scopes and testing.

In an API call

The slots map cleanly onto a request: the Role goes in the system prompt, and the Task, Format, and Constraints go in the user message with the material. Keeping the role in the system prompt means you can reuse it across calls and vary only the task.

from anthropic import Anthropic

client = Anthropic()
readme = open("README.md").read()
reply = client.messages.create(
    model="claude-sonnet-5",
    max_tokens=1024,
    system="You are a developer seeing this project for the first time.",
    messages=[{"role": "user", "content": (
        "Review this README for anything that blocks a first install. "
        "Numbered list, most blocking first, max 7 items, quote the line.\n\n" + readme
    )}],
)
print(reply.content[0].text)

Everyday Work Prompts, Already in RTFC Shape

These used to sit on two separate cheat sheets. Each one already fills the slots above, so you can see the framework do its job on tasks that come up every week. Where you see a sample run, that is the answer Claude gave us when we ran the prompt in October 2026, with the input we used.

Turn messy meeting notes into action items

Use it for: Right after a meeting, before the notes go stale.

Here are my raw meeting notes: [paste notes]. Turn these into a clean list of action items, grouped by owner, with any deadlines called out separately. If an item has no clear owner, list it under "Unassigned".

Why it works: The “Unassigned” rule surfaces the tasks that usually fall through the cracks.

Summarize a long document into 5 bullets

Use it for: Reports, policies, and long threads you need the gist of.

Summarize the following into exactly 5 bullet points, ordered by importance. Each bullet under 20 words. End with one line naming anything that needs a decision from me: [paste text]

Why it works: A fixed count and word cap force prioritizing instead of paraphrasing everything.

Draft a difficult message

Use it for: Pushback, bad news, or a boundary you’ve been putting off.

Help me draft a message to [person/role] about [situation]. Be direct but not confrontational, state what I need in the first two sentences, and keep it under 100 words.

Why it works: Putting the ask up front keeps the message from turning into a long apology.

Compare two options side by side

Use it for: Tools, vendors, job offers, or approaches.

Compare [option A] and [option B] in a table across these criteria: cost, time to set up, risk, and long-term impact. Below the table, give your recommendation in one sentence and the one factor that would change it.

Find the gaps in a plan

Use it for: Before you share a plan and someone else finds the holes.

Here's my plan: [paste plan]. List what's missing and what could go wrong that I haven't accounted for. Rank the risks from most to least likely, and suggest one fix for each.

Why it works: Ranking by likelihood stops the answer from being a flat list of every possible risk.

Get a straight recommendation, not a list

Use it for: Any decision where you want an opinion.

Give me your single best recommendation for [decision], not a list of options. Then tell me the one factor that would change your answer.

Why it works: Asking for the deciding factor gives you a way to check the recommendation against your situation.

Make Claude show its assumptions

Use it for: Advice questions with missing detail.

Before answering, list the 3 assumptions you're making about my situation. Then answer based on those assumptions, and flag where I should correct you.

Worked Example: Chaining Three of These

The prompts are useful alone, but they get sharper when you run them in sequence on one real question. Say you’re choosing a database for a small internal tool.

Step 1, assumptions first. Ask the question with the assumptions prompt attached:

Should I use SQLite or Postgres for an internal inventory tool? Before answering, list the 3 assumptions you're making about my situation. Then answer based on those assumptions, and flag where I should correct you.

Claude will typically assume things like the number of concurrent writers, whether you already run a database server, and how the tool is deployed. Correct the ones that are wrong in one reply. That correction is worth more than any amount of rewording.

Step 2, force a recommendation. Now that the assumptions are right, use the straight recommendation prompt. You’ll get one answer plus the single factor that would flip it (for example, “if more than a handful of people write at the same time, switch to Postgres”).

Step 3, attack it. Paste the recommendation back into the devil’s advocate prompt. If the strongest objection is something you can live with, you’ve made the decision. If it isn’t, you found out before building anything.

Before and After: Five Fixes That Save a Round Trip

Most follow-up messages come from the same five gaps, and each one is an empty RTFC slot: a missing Constraint, a Format named too late, context the Role needed but never got.

1. Break the big ask into stages

Use it for: Anything with more than one deliverable.

We're building a marketing plan in 4 stages. Stage 1 only: define the target audience for [product] in 5 bullets, including the problem they're trying to solve. Stop after stage 1 so I can review it.

Why it works: Each stage gets a sharper answer because the model isn’t guessing at everything at once.

2. Say what to leave out

Use it for: Any writing request.

Write a 3-paragraph product update about [feature]. No introduction, no closing summary, no "we're excited to announce".

Why it works: Negative constraints remove the parts you’d otherwise delete by hand.

3. Give numbers, not adjectives

Use it for: Anything with a length or quantity.

Explain [topic] in under 80 words, as 3 bullet points.

Why it works: “Short” means something different every time. “Under 80 words” doesn’t.

4. Front-load context once

Use it for: Any conversation longer than one question.

Context for this whole conversation: I'm a [role] at a [company type]. My audience is [audience]. Constraints: [budget / tone / deadline]. Don't ask me to repeat this. First question: [question]

5. Name the format in the first message

Use it for: Comparisons, lists, data.

Compare [A], [B], and [C]. Output as a table with columns: Option, Cost, Setup time, Biggest risk. No prose before the table.

Why it works: Asking for a table after three paragraphs of prose means the whole answer gets redone.

A Real Round-Trip Audit

Here’s a conversation most people have had, with each follow-up labeled by the mistake that caused it:

Five messages, and each rewrite risked changing parts you already liked. The same result in one message:

Write a launch email to existing customers about our new CSV and JSON export feature. Under 120 words. Open with what they can now do, not with excitement. Include a 3-bullet list of what's new, then one line on where to find it. No "we're thrilled", no closing summary.

The 20-Second Pre-Send Check

Before you hit enter on anything longer than a quick question, run through these five checks. Each “no” is a follow-up message you’re about to send later.

• Stages: Is there more than one deliverable here? If so, ask for the first one only.
• Leave-outs: Is there anything I always delete from answers like this? Say so now.
• Numbers: Did I write “short”, “a few”, or “brief”? Replace it with a number.
• Context: Would a smart stranger know who this is for and why? If not, add one line.
• Format: Do I want a table, list, or draft? Name it.

The Same Mistakes in Coding Assistants

These habits cost more in tools like Claude Code, where a vague request doesn’t just produce a weak answer, it produces edits to real files you then have to review and undo.

The underlying rule doesn’t change between a chat window and a terminal: every piece of information you hold back is a guess the model has to make, and every wrong guess costs a round trip.

Common Mistakes to Avoid

• Using a role as the whole prompt. “Act as a marketing expert” with no task just gets you generic expert-sounding prose.
• Vague verbs. “Help with”, “look at”, and “improve” don’t say what done looks like. Use shorten, rank, rewrite, extract, compare.
• Adding constraints after the fact. Asking for “shorter” in a follow-up costs a round trip. Put the limit in the first message.

Q&A

Related Guides

• 6 prompts to stop AI writing sounding robotic
• What still runs out on ChatGPT in 2026
• Turn a prompt into a Claude Code Skill
• Midjourney prompt cheat sheet