The RTF Prompt Framework: Role, Task, Format

A recruiting coordinator at a 200-person tech company once spent an entire afternoon regenerating a single job posting eleven times, each version worse than she expected, before realizing her prompt was missing the one thing the rtf prompt framework exists to fix.

The Problem Priya Faced

Priya handles job postings for a growing tech company, and she'd started using AI to speed up first drafts. The problem: her postings kept coming back either painfully generic ("we're looking for a rockstar developer") or wildly off-format, sometimes as a single dense paragraph, sometimes as a bulleted list she hadn't asked for. Nothing was consistent enough to just copy and post as-is.

She didn't have a structural problem with her AI tool. She had a structural problem with her prompts — specifically, she was missing role, task, and format instructions, the three pillars the rtf prompt framework is built around.

⚡ Pro tip: If your AI output format keeps changing unpredictably between requests, that's almost always a missing format instruction, not a random quirk of the model itself.

The Wrong Approach

Priya's original prompt:

Write a job posting for a mid-level backend engineer.

What this does: gives the model a topic with no defined voice, no specific requirements list, and no structural format, so results varied wildly between attempts — sometimes formal, sometimes casual, sometimes missing sections a real posting needs like requirements or benefits.

⚠️ Common mistake: Assuming "write a job posting" is specific enough because job postings are a common, well-understood document type. The model still needs your specific role, your specific format preferences, and your specific task details spelled out clearly.

It's a mistake that's easy to make precisely because job postings feel so standard — surely, the thinking goes, the AI has seen thousands of these and knows the format. It has, which is exactly the problem: it's seen thousands of different formats, from dozens of different company styles, and without your specific instructions it has no way to know which one you want this time. Priya's eleven regenerations weren't eleven random failures — they were eleven different reasonable interpretations of an under-specified request, none of which happened to match what she actually needed.

The Correct Prompt

Here's what Priya's prompt looked like after applying the rtf prompt framework — role, task, format, each stated explicitly:

Role: You are an experienced technical recruiter who writes clear, inclusive job postings 
that avoid buzzwords like "rockstar" or "ninja."
Task: Write a job posting for a mid-level backend engineer role, requiring 3-5 years of 
experience with Python and distributed systems, at a Series B startup.
Format: Use these exact sections with headers - Overview, Responsibilities (5 bullet points), 
Requirements (5 bullet points), Nice to Have (3 bullet points), and Benefits (3 bullet points).

What this does: assigns a specific professional identity with an explicit style constraint against buzzwords, states the exact task details needed to make the posting accurate, and locks the format down to a specific section structure, removing every source of the inconsistency Priya was seeing before.

⚡ Pro tip: When format matters as much as content — job postings, proposals, structured reports — specify exact section names and bullet counts, not just "use a clear format." Vague format instructions produce vague format results every time.

Results and What Changed

Priya's postings became consistent from the first attempt onward. She still edits details specific to each role, but the structural back-and-forth disappeared completely, cutting her average posting time from around 35 minutes down to roughly 10.

A different HR coordinator at a manufacturing company applied the identical rtf prompt framework to internal policy summaries, which had suffered from the same format inconsistency problem — some summaries were bulleted, some were narrative paragraphs, none matched the company's internal style guide. Locking the format field to match her style guide's exact section headers fixed it in one attempt, something she hadn't expected after months of assuming the inconsistency was just an unavoidable quirk of using AI for this kind of writing.

⚠️ Common mistake: Defining role and task carefully but leaving format vague, assuming the model will "figure out" a reasonable structure. It often does something reasonable — just not the same reasonable structure twice in a row, which defeats the purpose for recurring documents.

This is arguably the most common half-finished version of the rtf prompt framework — people nail role and task because those feel like the "content" parts of the prompt, and treat format as an afterthought because it feels like a minor styling detail. In practice, format inconsistency is often the single biggest source of wasted editing time on recurring documents, precisely because it's invisible until you're staring at your third differently-structured draft in a row.

How to Apply This to Your Situation

Any recurring document type — job postings, proposals, reports, email templates — benefits from the rtf prompt framework specifically because consistency matters more for recurring documents than for one-off requests. The clearer your format field, the less time you'll spend reformatting AI output to match what you actually needed in the first place.

A freelance consultant applies the same framework to weekly client status updates, which need to look identical week over week so clients can scan for changes quickly rather than re-reading a differently structured document every time. Her format field spells out the exact section order and even specifies that updates should always open with a one-line summary before any detail — a level of specificity that would feel excessive for a one-off email but pays for itself across fifty-plus weekly updates a year.

⚡ Pro tip: Write your format field by describing your ideal final output as if you were handing formatting instructions to a very literal-minded assistant — exact section names, exact counts, exact order, nothing left to interpretation.

This literal-minded framing is worth taking seriously rather than treating as a throwaway tip. Most people write format instructions the way they'd explain a document to a colleague who already knows the general shape they're going for — "use headers, make it skimmable, standard job posting stuff." A model doesn't share that unstated shared context, so instructions that feel obvious to you can leave real room for a different, equally reasonable interpretation. Spelling out the literal structure removes that gap entirely.

Next Steps

Take one document type you create repeatedly, and write out role, task, and format as three separate explicit statements, even if it feels redundant at first.

⚡ Pro tip: Test your RTF prompt against your messiest, least standard past request first, not your easiest one. If it holds up on the hard case, it'll hold up on everything simpler. Test it against your last few real requests to see if the format finally holds steady across attempts.

It's worth writing these three fields out even for documents you think you already do well with AI. Priya assumed her job postings were the only format-inconsistency problem in her workflow, until she applied the same three-field breakdown to interview feedback summaries and discovered the exact same pattern had been quietly costing her time there too — she just hadn't noticed because the postings problem was more visible day to day.

Once you've got an RTF prompt that reliably produces the structure you need, save it in PromptABCD rather than reconstructing the same role-task-format breakdown from memory every time you need a new job posting or report.

Priya's finished template now gets reused by two other people on her recruiting team, each swapping in their own role details and requirements while keeping the same locked format. That's really the end state worth aiming for with any framework like this: not a prompt you personally remember well, but a structure reliable enough that anyone on your team can pick it up and get the same consistent result you did.

It's worth adding one caveat here: the rtf prompt framework doesn't eliminate editing entirely, and it shouldn't be expected to. Priya still reads every posting before it goes live, checking facts and tone. What changed wasn't the need for a final review — it was what that review looked like. Before, she was rebuilding structure and rewriting generic phrases from scratch each time. After, she's checking accuracy on a document that already has the right shape, which is a fundamentally faster kind of editing — closer to proofreading than drafting, and considerably less mentally exhausting across a busy hiring season with a dozen open roles at once, at which point the old process used to feel most overwhelming, precisely because inconsistent formatting compounds when you're moving fast across multiple roles at once and don't have time to rebuild structure from scratch for each one, especially during the busiest weeks of a hiring cycle, when there's no spare time to reinvent structure from scratch on top of everything else already on her plate that particular week, when every hour saved genuinely mattered, and when the last thing she needed was one more inconsistent document to clean up before it could go out the door to a candidate waiting on an answer about whether they'd made it to the next round.