What are the 7 things of a prompt?

Why Most Prompts Fail: The 'Build a House' Problem

You typed a perfectly reasonable request into an AI tool, and what came back was somehow both too long and completely wrong for your needs. That frustration usually has one root cause: the prompt contained only the task — "write this," "summarize that" — and left everything else for the model to guess.

According to one framework comparison, the average prompt is exactly this: a bare instruction with no context, constraints, audience, or success criteria — the information that separates a useful output from a generic one. The analogy that sticks: it's like handing a contractor a blueprint that says "build a house" with no dimensions. You'll get a house. It just won't be the one you wanted.

Anthropic frames the problem well in its official prompting guidance: think of the model as a brilliant but brand-new employee who lacks all context on your norms and workflows. The more precisely you explain what you want, the better the result. A new hire with talent but zero context produces exactly what vague prompts produce — plausible work that misses the mark.

The failure pattern is predictable:

• The output is generic because no audience, tone, or format was specified.
• The output is wrong because constraints and edge cases were never stated.
• The output fails review because success criteria existed only in your head.

That last point is the one businesses feel most. Generation Digital's prompt engineering guide names it as a core anti-pattern: expectations not stated in the prompt inevitably fail QA. You cannot hold an AI — or a new employee — to standards you never communicated. AWS's own agent guidance reinforces this, recommending 3–5 specific, observable success criteria per prompt so outcomes are verifiable rather than vibes-based.

This is why component-based prompting exists. Frameworks like CO-STAR, RISEN, and R-TCC-COE disagree on exact counts — component counts range from four to seven — but they all converge on the same fix: stop treating a prompt as a sentence and start treating it as a specification.

The same logic applies beyond prompts. When you equip an agent with skills and tools, unstated boundaries cause the same failures — which is why SkillzBench is building a free directory and MCP connector that lets you verify, benchmark, and control exactly what each agent sees. Explicit specification beats implied intent, every time.

The 7 Components: Role, Task, Context, Examples, Constraints, Output Format, Evaluation

Here's an honest caveat before the list: no canonical industry standard exists. Component counts range from 4 (STCO) to 6 (CO-STAR) to 7, and benchmark data shows no single framework wins universally. What follows is a synthesis of Generation Digital's R-TCC-COE framework, Anthropic's official best practices, and AWS's six-section agent structure.

1. Role. Tell the model who it is. Anthropic recommends thinking of Claude as "a brilliant but new employee who lacks context on your norms" — a role assignment anchors tone and expertise. AWS's agent structure starts with Identity for the same reason.

2. Task. State the objective plainly. Promplify compares the average prompt — task only — to "handing a contractor a blueprint that says 'build a house' with no dimensions." Say it once, clearly; AWS warns redundancy dilutes instructions.

3. Context. Supply the background the model would otherwise guess: audience, source material, motivation. For long documents of 20k+ tokens, Anthropic advises placing them at the top of the prompt, above instructions.

4. Examples. The highest-leverage component. Research consistently shows few-shot prompting outperforms instruction alone, and Anthropic calls examples "one of the most reliable ways to steer output format, tone, and structure." Generation Digital recommends 1–3 concise, diverse examples covering edge cases — Inflectra frames them as behavioral specification, including messy inputs and refusals.

5. Constraints. Define boundaries: length, scope, what's out of bounds. AWS cautions that "if everything is capitalized, nothing is prioritized" — reserve MUST/MUST NOT for genuinely high-stakes rules, and avoid contradictions, which cause unpredictable behavior.

6. Output Format. Specify structure — bullets, tables, JSON, or XML tags. AWS documentation notes that LLMs parse structured content with headers and bullets more reliably than prose, and structured outputs are easier to validate downstream.

7. Evaluation. Define what success looks like before you run the prompt. AWS recommends 3–5 specific, observable success and failure criteria verifiable from a transcript — success criteria pull the agent toward target outcomes, failure conditions push it away from unacceptable states. Generation Digital's BPQR rubric (7 criteria, target ≥8/10) offers a scoring template.

For agent builders, these components increasingly live in reusable instruction packages rather than one-off prompts — and prompting shifts from copywriting toward systems design, where retrieval, tools, and permissions matter as much as wording. SkillzBench is building a free directory and MCP connector for exactly that workflow: discover, verify, and benchmark agent skills before loading them.

How to Write a 7-Part Prompt in Practice

Theory is cheap — the seven components only matter when you can see them turn a lazy one-liner into a prompt that produces the same quality output every time. So let's rebuild a genuinely weak prompt for a real business task, component by component.

Start with the weak version: "Write a summary of this customer complaint." Per framework research, the average prompt contains only the task — like "handing a contractor a blueprint that says 'build a house' with no dimensions." Here's the same request with all seven parts in place:

• Role: "You are a customer support quality analyst at a B2B SaaS company."
• Task: "Summarize the attached complaint into a 100-word brief for our product team."
• Context: "The customer is on our enterprise tier; the complaint involves a billing discrepancy from a recent plan change."
• Examples: One or two short sample summaries showing your preferred tone and structure — guides recommend 1–3 concise examples, and examples are consistently the highest-leverage component.
• Constraints, Output, Evaluation: "Do not speculate about fault (constraint). Return a markdown table with columns for Issue, Impact, Urgency (output). Flag any missing information rather than inventing it (evaluation)."

Now apply the two quality checks that separate a good prompt from a fragile one. First, Anthropic's golden rule: show your prompt to a colleague with minimal context and ask them to follow it — if they'd be confused, the model will be too. Second, AWS guidance says to state each rule once, clearly, because redundancy dilutes important instructions — and to reserve capitalized MUST and NEVER only for high-stakes rules, since "if everything is capitalized, nothing is prioritized."

Before you ship the prompt, score it against the Business Prompt Quality Rubric: seven criteria scored 0–2 each, with a target of at least 8/10. If your prompt scores below that, the weak spot is almost always a missing example or vague success criteria.

Once a prompt like this works, the natural next step is automating the surrounding workflow — summarizing, routing, escalating — with agent skills. SkillzBench is building a free directory and MCP connector for exactly that: vetted, benchmarked skills you can test per agent, with a waitlist open now.

From Prompts to Agent Systems: Where the 7 Parts Get Harder

The seven components work beautifully when you're prompting a chatbot. The moment you bolt on tools, retrieval, and external data, prompting stops being copywriting and becomes something closer to systems design — a shift practitioners describe explicitly in agent prompt engineering guidance, where production failures tend to emerge not inside any single component but at the seams between them: instructions meeting retrieved context, context meeting tools, tools meeting permissions.

The first hard rule: separate instructions from untrusted data. When your agent ingests emails, web pages, or documents, that content can carry instructions of its own. OWASP's Prompt Injection Prevention guidance, cited in the same analysis, warns that prompt loopholes can cause safety bypasses, unauthorized actions, data exfiltration, and system prompt leakage. Anthropic's best practices recommend the same discipline at the template level — using XML tags to keep instructions, context, examples, and variable inputs cleanly partitioned, per the company's official prompting documentation.

The second shift: stop asking the model to compute. AWS's agent guidance is blunt that LLMs "generate tokens probabilistically rather than computing deterministically," so precise calculations, date arithmetic, and fact verification should be delegated to MCP tool calls instead of prompt instructions. Your prompt's Constraints and Evaluation components don't disappear — they move into the plumbing.

For agent builders, the practical checklist looks like this:

• Treat every external input as untrusted, and never let it share a namespace with your instructions.
• Delegate deterministic work — math, dates, fact checks — to tool calls, not prompt text.
• Grant minimum tool access; an agent that can't touch a capability can't be tricked into abusing it.
• Define 3–5 observable success and failure criteria, per AWS's recommendation, so you can verify behavior from transcripts.

That last point matters more than it sounds. Tool access is attack surface — every connection you hand an agent widens what a successful injection can reach. This is why the industry is moving toward scoped, per-agent loadouts rather than kitchen-sink toolboxes: SkillzBench, for instance, is building exactly this model, where each agent only sees the skills and tools explicitly toggled for it, alongside security scanning of the skills themselves — a sensible precaution given published research finding roughly 26% of agent skills carry at least one vulnerability.

The seven components still apply. Role, Task, Context, Examples, Constraints, Output, Evaluation — but in an agent system, the prompt becomes operational policy rather than a request. If you're assembling this kind of setup, SkillzBench's free skills directory and the free MCP connector it's building are one way to source, scan, and wire up vetted skills without giving every agent the keys to everything.