TL;DR
5C Prompt Contract is a way to structure prompts with 5 clear blocks: Character (the role), Cause (the task), Constraint (the limits), Contingency (the fallback plan), Calibration (the output format). Instead of complex XML tags or long instructions, you get a short scheme that covers every important aspect of working with an LLM.
Complex prompt structures (XML markup, multi-level templates) eat tokens and distract the model into following syntax instead of generating creatively. In the experiments, DSL prompts needed 6 times more input tokens (348 vs. 54) for the same result. That's not just pricier; it also cuts into the model's "creativity budget": it spends its horsepower parsing elaborate markup instead of on depth of content.
5C gives you a minimal but sufficient structure. Each of the 5 components is one block in the prompt. Character sets the role, Cause the goal, Constraint the boundaries, Contingency what to do if something is unclear (a fallback), Calibration the output format. The study found that a minimalist structure saves tokens AND keeps the output rich: 5C delivered as much creativity as a free-form prompt, with control on par with DSL.
Want this for your own case? Apply this study to your task: AI adapts its method to what you are working on and writes the prompt.
Method Blueprint
Character: [Who you are / what role]
Cause: [What the goal is / what needs to be done]
Constraint: [What the limits are / what to keep in mind]
Contingency: [What to do if something is unclear / the fallback plan]
Calibration: [Output format / how to structure the answer]
All 5 blocks in one prompt. One request.
Example in Action
Task: You're launching a new online course on AI for marketers. You need an Instagram post that lands with the audience: people aged 25-35 who work in marketing and want to use AI but don't know where to start.
Prompt:
Character: You're a seasoned marketer who went from "AI scares me"
to confidently using AI at work. You write simply, with real-life examples,
no hype and no technical jargon.
Cause: Write an Instagram post announcing the course "AI for Marketers in 2 Weeks".
The goal of the post is to hook people who keep putting off learning AI and show them it's
actually easy and pays off fast.
Constraint:
- No "revolution", "breakthrough", "buy before it's gone"
- No more than 1,200 characters
- No technical terms (prompt, tokens, models)
- One concrete example of using AI in marketing from your own experience
Contingency: If you're not sure which AI example to pick, go with something
related to a content calendar or audience analysis; every marketer gets those.
Calibration: Format: a short hook paragraph about the pain point, your AI example,
a call to action. Emojis only if they reinforce the meaning, not for decoration.
Result: The model will produce a post tailored exactly to your task: it opens with the pain point ("you keep putting off AI because it seems complicated"), shows a concrete example (say, how ChatGPT built a month-long content calendar in 5 minutes), and closes with a call to action, no hard sell. The length lands right inside the limit, and the style is lively with no hype clichés.
Why It Works
An LLM generates better when it has a clear structure but freedom inside it. Complex XML tags or long instructions overload the context: the model spends its "horsepower" parsing syntax instead of meaning. It's like giving someone a task and simultaneously making them count the words in every sentence: the result gets worse.
5C gives a structure of 5 simple blocks, so the model gets what you want right away, without extra words. Character tunes the tone and perspective, Cause sets a clear goal, Constraint creates boundaries (without smothering creativity), Contingency insures against "I didn't understand the task" (the model knows what to do if something is unclear), and Calibration sets the format without spelling out every element.
The key insight: minimalism = more room for creativity. When the prompt is short and clear, the model doesn't burn tokens parsing instructions. It channels its horsepower into generating content. In the study, 5C prompts produced output as rich as free-form prompts (777 output tokens vs. 833), but with the control and predictability of DSL, and with 6 times fewer input tokens.
Control levers: - Contingency: swap "if unclear, pick X" for "if unclear, ask me" → the model asks clarifying questions instead of deciding on its own - Calibration: drop the specific output format → the model picks a structure itself based on the task - Constraint: add more constraints → tighter control, less creativity; remove the extras → more freedom
Prompt Template
Character: {who does the task — role, perspective, style}
Cause: {what needs to be done — specific goal, for whom, why}
Constraint:
- {constraint 1 — what to avoid, limits, required elements}
- {constraint 2}
- {constraint 3}
Contingency: If {situation of uncertainty}, then {what to do — pick X,
ask, use approach Y}.
Calibration: {output format — structure, style, length, elements}
What to fill in:
- {who does the task}: a role with context: "seasoned editor at a tech publication," "HR pro with 5 years of hiring experience," "e-commerce analyst"
- {what needs to be done}: a specific task with context: not just "write some copy" but "write a job post for a mid-level Python developer at a startup that attracts people who value growth"
- {constraints}: a list of clear boundaries: length, style, what to include/exclude, required elements
- {situation of uncertainty}: what could go wrong: "if there isn't enough data," "if several approaches fit," "if the task allows different interpretations"
- {output format}: how to structure it: "a list with short explanations," "3 paragraphs: problem-solution-result," "a table with columns X, Y, Z"
🚀 Quick start: paste this into the chat:
Here's the 5C Prompt Contract template, a minimalist 5-block prompt structure.
Adapt it to my task: [your task].
Ask me questions to fill in all 5 components (Character, Cause, Constraint,
Contingency, Calibration).
[paste the template above]
The LLM will ask about the role (Character), the goal (Cause), the constraints (Constraint), the fallback plan if something is unclear (Contingency), and the output format (Calibration), because it needs to fill all 5 blocks of the structure. It will take the pattern from the template and adapt it to your task.
Limitations
⚠️ Creative tasks vs. analytics: The study was tested only on a creative task (writing a narrative). It's unclear how 5C performs on data extraction, pure analytics or code generation. Tasks that need a rigid output structure (JSON, for example) may call for a more detailed Calibration.
⚠️ Contingency can misfire: If the fallback plan is too generic ("if unclear, do whatever you think is best"), the model may interpret it its own way. You need a concrete fallback: not "do better" but "if unclear, use approach X" or "if unclear, ask me."
⚠️ Minimalism ≠ universality: For very complex tasks (multi-step reasoning, multi-stage code generation) it may not be detailed enough. 5C is about balancing simplicity and structure, not about maximum control.
How It Was Studied
The team tested 5C on 4 models (OpenAI GPT, Anthropic Claude, DeepSeek, Google Gemini) and 3 prompt styles. The task was the same for all: write a short cyberpunk detective story about a secret society manipulating politics. The detective had to have personal biases, and the text had to be a cinematic narrative.
The three styles:
1. 5C Prompt Contract: the 5-block structure (Character, Cause, Constraint, Contingency, Calibration)
2. DSL: XML markup with tags like <ROLE>, <GOAL>, <CONSTRAINT>
3. Unstructured: free form, no explicit structure
Each style was run several times on each model, counting tokens: input (how many went into the prompt), output (how many the model generated), and total (the sum).
Results: - 5C: the fewest input tokens (54.75 on average), rich output (777.58): the model generated detailed narratives with depth of scene and speculative detail - DSL: lots of input tokens (348.75, 6 times more!), shorter output (711.50): the model produced coherent but less developed texts - Unstructured: lots of input (346.25), large but unpredictable output (833.17): the model was creative but less focused on the task
Why they reached these conclusions: XML tags and complex markup distract the model into following syntax. It spends its "horsepower" not on content but on parsing structure. It's like asking a writer for a short story while making them count the words in every sentence: the result comes out thinner.
What was surprising: On Gemini, all three styles produced the same output (1795 tokens), but the input differed dramatically: 5C used 54 tokens, DSL 1212, Unstructured 1315. That showed the model compensates on its own for missing structure or prompt complexity at the output level, but the input-token savings are real.
Practical insight: Paying for input tokens? The minimalist 5C structure saves money several times over with no loss in quality. For SMEs and individual users on a tight budget, that's critical.
Resources
"5C Prompt Contracts: A Minimalist, Creative-Friendly, Token-Efficient Design Framework for Individual and SME LLM Usage" — Ugur Ari, AI Research Strategist and LLM Ecosystem Analyst, July 2025
References from the study: - Vaswani et al. (2017) "Attention is all you need" — on the transformer architecture - Brown et al. (2020) "Language models are few-shot learners" — the GPT-3 paper - Ouyang et al. (2022) "Training language models to follow instructions with human feedback" — on RLHF - Leike et al. (2018) "Scalable agent alignment via reward modeling" — on the alignment problem - Ganguli et al. (2022) "Predictability and surprise in large generative models" — balancing predictability and creativity