RISEN Framework Guide: Write Better AI Prompts in 5 Steps

Most AI prompts are a single sentence. "Write a marketing plan." "Review this code." "Analyze this dataset." The AI produces something — but it's generic, unfocused, and missing the specifics that would make it actually useful.

The RISEN framework fixes this by breaking your prompt into five components that force you to include the information AI models need to produce targeted, high-quality output. Role, Instructions, Steps, End Goal, Narrowing — each one fills a gap that the AI would otherwise fill with guesses.

This guide covers what RISEN is, how each component works with real examples, copy-paste templates for five common use cases, and when to choose RISEN over other prompt engineering frameworks.

What Is the RISEN Framework?

RISEN is a structured prompting method created by Kyle Balmer that organizes AI prompts into five distinct components. Each component answers a specific question the AI would otherwise have to infer — and inference means guesswork.

The framework works because it maps directly to how humans delegate complex tasks. When you hand off a project to a colleague, you tell them what hat to wear (Role), what needs to be done (Instructions), the process to follow (Steps), what the outcome should look like (End Goal), and what to avoid or stay within (Narrowing).

Most prompts skip four of these five components. The result: the AI defaults to generic assumptions for context, process, success criteria, and constraints. RISEN eliminates those defaults.

If you're new to structured prompting, start with our what is prompt engineering guide for foundational concepts.

The Five Components, In Depth

R -- Role

The Role component tells the AI what expertise and perspective to bring. It shapes vocabulary, depth of analysis, and the type of reasoning the model applies.

What to include:

• Professional title and seniority level
• Domain of expertise
• Relevant experience or specialization
• The perspective you need (advisor, critic, implementer, reviewer)

Weak role: "You are a helpful assistant."

Strong role:

Role: You are a senior backend engineer with 12 years of experience
in distributed systems. You specialize in microservices architecture,
event-driven design, and performance optimization at scale (10M+
requests/day). You are pragmatic — you favor proven patterns over
trendy ones and always consider operational complexity in your
recommendations.

The specificity matters. "Senior backend engineer" produces different output than "software developer." Adding the specialization and philosophy pushes the AI further from generic advice toward the specific perspective you need.

One caution: some models over-index on Role, producing artificially formal or jargon-heavy output. If this happens, add a note in your Instructions like "use a conversational tone despite the expert role."

I -- Instructions

Instructions define the core task — what the AI should actually produce. This is the component most people already include, but RISEN asks you to be significantly more specific than "write X about Y."

A weak instruction: "Write a blog post about API security."

A RISEN instruction:

Instructions: Write a 1,500-word technical guide on API authentication
best practices for a developer audience. Focus on three methods:
API keys, OAuth 2.0, and JWT tokens. For each method, explain when
to use it, common implementation mistakes, and one code example
in Python. The guide should be practical — readers should be able
to implement each method after reading the relevant section.

The difference: the weak instruction leaves format, scope, depth, angle, and audience entirely up to the AI. The RISEN instruction locks those down.

Instructions should specify:

• The exact deliverable (report, email, analysis, code, plan)
• Length or scope constraints
• The specific angle or focus area
• Format requirements (prose, bullet points, table, code)

S -- Steps

Steps define the sequence the AI should follow. This is RISEN's most distinctive component — and the one that produces the biggest quality improvement on complex tasks.

Without explicit steps, the AI chooses its own path through the problem. Sometimes that path is fine. Often, it skips important intermediate analysis, reorders steps in ways that lose information, or jumps straight to conclusions without showing how it got there.

Example — without Steps:

Analyze our customer churn data and recommend retention strategies.

Example — with Steps:

Steps:
1. Segment churned customers by plan tier, tenure, and last feature used
2. Identify the top 3 behavioral patterns that precede churn
   (e.g., declining login frequency, support ticket spike, feature drop-off)
3. For each pattern, calculate the median time between pattern onset
   and actual churn
4. Map each pattern to a potential intervention point
5. Recommend 3 retention strategies, one for each pattern, with
   estimated implementation effort and expected impact

The Steps component is conceptually related to chain of thought prompting — you are externalizing the reasoning sequence rather than letting the model decide what to think about and in what order.

When Steps matter most:

• Tasks with a natural sequence of operations
• Analysis that requires intermediate conclusions before a final recommendation
• Multi-part deliverables where order affects quality
• Tasks where you have domain knowledge about the best process

When to keep Steps light:

• Creative tasks where rigid sequence constrains the output
• Simple one-shot tasks (single-step instructions are just Instructions)
• Exploratory brainstorming where you want the AI to find its own path

E -- End Goal (and Why "Expectations" Works Too)

The End Goal defines what success looks like. It is not a restatement of the Instructions — it is a description of what the output should achieve in the real world.

Instructions vs. End Goal:

• Instructions: "Write a competitive analysis of three CRM platforms"
• End Goal: "The analysis should give our VP of Sales enough information to make a vendor selection decision in one meeting, without needing additional research"

This distinction matters because the same instructions with different end goals produce very different outputs:

End Goal A: Help a startup founder choose a CRM for a 5-person sales team
--> Focus on price, ease of setup, and time-to-value

End Goal B: Help an enterprise CTO justify a CRM migration to the board
--> Focus on ROI projections, integration costs, risk mitigation, and vendor stability

End Goal C: Help a consultant build a CRM selection framework for clients
--> Focus on evaluation criteria, scoring methodology, and reusable templates

Same competitive analysis. Three completely different outputs driven by the End Goal.

You will sometimes see RISEN written as RISE-N where E stands for "Expectations" instead of "End Goal." The intent is the same — define what the output needs to accomplish, not just what it needs to contain. Use whichever term helps you think about it more concretely.

N -- Narrowing (and When to Use "Novelty" Instead)

Narrowing sets the boundaries. It tells the AI what to exclude, what constraints to respect, and where the guardrails are. Think of it as the "do not" and "stay within" component.

Types of Narrowing:

• Scope limits — "Focus only on the North American market"
• Exclusions — "Do not include pricing comparisons; we'll handle that separately"
• Format constraints — "Output as a markdown table with exactly four columns"
• Quality gates — "Every recommendation must include a specific metric or data point"
• Audience calibration — "Assume the reader has no technical background"

Example:

Narrowing:
- Maximum 800 words
- Do not reference competitors by name — use "legacy solutions"
  and "open-source alternatives"
- All statistics must include their source or be clearly marked
  as estimates
- Format as a structured brief with headers, not a narrative essay
- Exclude anything related to GDPR — that's covered in a separate document

Narrowing is where you prevent the most common AI failure mode: producing technically correct output that is wrong for your specific context. Without Narrowing, the AI defaults to maximum scope, generic formatting, and no constraints — which is rarely what you actually need.

Some RISEN variants use "Novelty" instead of "Narrowing" — the idea being that this component should push the AI beyond generic responses toward original or creative angles. In practice, Narrowing is more broadly useful. Reserve the Novelty interpretation for creative tasks where you explicitly want the AI to avoid cliched or predictable approaches.

RISEN Framework Templates (Copy-Paste Ready)

Template 1: Content Writing

Role: You are a senior content strategist with 8 years of experience
writing for B2B SaaS audiences. You write in a style that is technical
but accessible — clear, direct, no filler.

Instructions: Write a 1,200-word blog post about [TOPIC]. The post
should argue [SPECIFIC ANGLE/THESIS]. Structure it with an engaging
hook, 3-4 supporting sections with subheadings, and a practical
takeaway the reader can implement immediately.

Steps:
1. Open with a specific scenario or data point that illustrates the problem
2. State the thesis clearly within the first 150 words
3. Build each supporting section around one concrete example or case study
4. Address the strongest counterargument in one paragraph
5. Close with a specific, actionable next step — not a vague "in conclusion"

End Goal: A reader should finish the post with a clear understanding
of [THESIS] and one specific action they can take within 24 hours.
The post should rank for "[TARGET KEYWORD]" and earn social shares
from practitioners, not just marketers.

Narrowing:
- No generic advice ("communicate clearly," "set goals," "be strategic")
- Every claim must be supported by a specific example, metric, or reference
- No more than 3 sentences per paragraph
- Do not use these phrases: "game-changer," "in today's world,"
  "it's no secret that," "at the end of the day"

Template 2: Code Review

Role: You are a principal software engineer conducting a code review.
You have deep experience with [LANGUAGE/FRAMEWORK] and strong opinions
about code quality, maintainability, and performance. You review code
the way you'd want your own code reviewed — direct, specific, actionable.

Instructions: Review the following code for bugs, performance issues,
security vulnerabilities, and maintainability concerns. Provide specific
feedback on each issue found, with a suggested fix.

Steps:
1. Read the code and identify its purpose and architecture
2. Check for correctness — logic errors, edge cases, off-by-one errors
3. Check for security — injection risks, authentication gaps, data exposure
4. Check for performance — unnecessary allocations, N+1 queries,
   unoptimized loops
5. Check for maintainability — naming, complexity, test coverage gaps
6. Prioritize findings by severity (critical, high, medium, low)

End Goal: The developer receiving this review should be able to address
all critical and high issues within one work session. Each piece of
feedback should include the what, the why, and the how-to-fix.

Narrowing:
- Do not comment on style/formatting unless it affects readability
- Focus on logic and architecture, not linting rules
- If the code is fundamentally well-structured, say so — don't
  manufacture issues
- Format output as: [Severity] File:Line — Description — Suggested Fix

Template 3: Market Research

Role: You are a market research analyst specializing in [INDUSTRY].
You combine quantitative data analysis with qualitative market
intelligence. You present findings with clear implications, not
just data dumps.

Instructions: Conduct a market analysis of [MARKET/SEGMENT]. Cover
market size, growth trajectory, key players, emerging trends, and
opportunities for a [COMPANY TYPE] entering this space.

Steps:
1. Define the market boundaries and segmentation criteria
2. Estimate current market size and 3-year growth projection
3. Map the competitive landscape — top 5 players by market share,
   their positioning, and their weaknesses
4. Identify 3 emerging trends that will reshape the market in 2-3 years
5. Analyze barriers to entry and switching costs for customers
6. Recommend a market entry strategy with specific positioning

End Goal: A startup founder should be able to use this analysis to
decide whether to enter this market, how to position against incumbents,
and where to focus their first 12 months. The analysis should be
specific enough to inform a pitch deck and investor conversations.

Narrowing:
- Use publicly available data — cite sources where possible
- Clearly distinguish between confirmed data and estimates
- Do not include markets or segments outside [GEOGRAPHIC SCOPE]
- Format as an executive brief with sections, not a narrative essay
- Maximum 2,000 words

Template 4: Data Analysis

Role: You are a senior data analyst with expertise in [DOMAIN].
You are skilled at finding patterns in data and translating them
into business recommendations. You prioritize insight over
comprehensiveness — better to surface 3 actionable findings than
10 interesting observations.

Instructions: Analyze the following dataset and provide insights
on [SPECIFIC QUESTION/METRIC]. Focus on patterns, anomalies, and
actionable recommendations.

Steps:
1. Describe the dataset structure, completeness, and any quality issues
2. Calculate key summary statistics relevant to [QUESTION]
3. Identify the top 3 patterns or trends in the data
4. Flag any anomalies or outliers that warrant investigation
5. For each finding, explain the business implication
6. Recommend 2-3 specific actions based on the analysis

End Goal: A non-technical stakeholder should be able to read this
analysis and make a data-informed decision about [DECISION] without
needing to look at the raw data themselves.

Narrowing:
- Do not include charts or visualizations — describe findings in text
- Round numbers to meaningful precision (not 47.2834%, use 47%)
- Every recommendation must tie directly to a finding in the data
- Distinguish between correlation and causation explicitly
- If the data is insufficient to draw a conclusion, say so

Template 5: Email / Communication

Role: You are a communications specialist who writes clear, concise
business emails. You understand that every email competes with 100
others in the recipient's inbox — yours needs to earn its read time.

Instructions: Write an email to [RECIPIENT/AUDIENCE] about [TOPIC].
The email should [DESIRED ACTION — inform, persuade, request, update].

Steps:
1. Write a subject line that is specific and action-oriented (under 50 chars)
2. Open with the single most important piece of information
3. Provide supporting context in 2-3 short paragraphs
4. Include a clear, specific call to action with a deadline
5. Close with next steps or what to expect

End Goal: The recipient should understand the key message from
the subject line alone, get full context from the first two sentences,
and know exactly what action to take by the end. The email should
require zero follow-up clarification.

Narrowing:
- Maximum 200 words for the body
- No jargon or acronyms the recipient would not immediately recognize
- One CTA only — if there are multiple actions, prioritize the most urgent
- No pleasantries that add words without meaning
  ("I hope this finds you well" — cut it)
- Professional but not corporate — write like a human, not a template

Before and After: RISEN vs. Unstructured Prompts

Example 1: Technical Documentation

Unstructured prompt:

Write documentation for our authentication API endpoint.

RISEN prompt:

Role: You are a senior technical writer who specializes in API
documentation for developer audiences. You've written docs for
products like Stripe, Twilio, and Auth0.

Instructions: Write reference documentation for our OAuth 2.0
token endpoint. Cover the request format, response format,
error codes, and rate limits.

Steps:
1. Start with a one-paragraph overview of what the endpoint does
2. Show the full request format with all parameters (required
   and optional) in a table
3. Show a complete cURL example with a successful response
4. Document all error responses (400, 401, 403, 429) with
   example response bodies
5. Add a "Common Mistakes" section with the top 3 integration errors

End Goal: A developer should be able to integrate this endpoint
successfully using only this documentation, without contacting
support or reading source code.

Narrowing:
- Code examples in cURL and Python (requests library) only
- Do not explain OAuth 2.0 concepts — link to an external
  reference instead
- Keep the overview under 50 words
- Use our API base URL: https://api.example.com/v2

What improved: The unstructured prompt produces generic API docs that explain what OAuth is (unnecessary), use random example URLs, skip error documentation, and lack code examples. The RISEN version produces docs that match the audience's expertise level, follow a proven structure, include error handling, and are specific to the product. The Steps component is the biggest driver — it ensures error documentation and common mistakes are not skipped, which are the sections developers need most but AI omits by default.

Example 2: Strategic Recommendation

Unstructured prompt:

Should we build or buy a customer data platform?

RISEN prompt:

Role: You are a CTO advisor who has guided 20+ mid-market companies
through build-vs-buy technology decisions. You evaluate decisions
based on total cost of ownership, time to value, and organizational
capability — not just feature comparisons.

Instructions: Analyze the build-vs-buy decision for a customer data
platform for a Series B e-commerce company with 500K customers, a
12-person engineering team, and $2M annual infrastructure budget.

Steps:
1. Define what "customer data platform" means in this context —
   the specific capabilities needed (identity resolution, event
   tracking, audience segmentation, activation)
2. Estimate build cost: engineering time, infrastructure, maintenance,
   opportunity cost of not building product features
3. Evaluate buy options: compare Segment, mParticle, and RudderStack
   on price, capabilities, and integration effort
4. Assess organizational fit: does the team have CDP expertise?
   Is data infrastructure a core competency or a support function?
5. Provide a recommendation with a 3-year TCO comparison

End Goal: The CEO and CTO should be able to make a decision based
on this analysis and defend it to their board with specific numbers.

Narrowing:
- Assume the company uses AWS, PostgreSQL, and a React frontend
- Assume engineering cost at $180K/year fully loaded per engineer
- Do not include enterprise-only CDPs (Tealium, Adobe) — out of budget
- Present TCO as a table with Year 1, Year 2, Year 3 columns
- Clearly state assumptions separately from conclusions

What improved: The unstructured prompt gets a balanced "it depends" answer with generic pros and cons. The RISEN version gets a specific recommendation backed by numbers, scoped to the company's actual situation, with a format the leadership team can use in board discussions. The Narrowing component is critical here — it prevents the AI from analyzing irrelevant enterprise solutions and forces it to state assumptions explicitly.

When to Use RISEN (And When Not To)

RISEN is strongest when your task has a natural sequence and clear boundaries. Here is how it compares to other frameworks.

Use RISEN when:

• The task has a clear sequence of operations (analysis, review, research, planning)
• You need the AI to follow a specific process, not just produce an output
• The deliverable has multiple parts that build on each other
• You want to prevent the AI from skipping intermediate steps
• Output boundaries matter (word count, scope, format, exclusions)

Use something else when:

• Tone and audience are the primary quality drivers (use CO-STAR)
• You need to inject specialized domain knowledge (use STOKE)
• The task is simple enough for four components (use RACE)
• You want few-shot examples to control output quality (use CREATE or STOKE)
• You are brainstorming or exploring ideas (use APE or freeform)

For a full side-by-side comparison of all six major frameworks applied to the same task, see our prompt engineering frameworks compared guide.

Common RISEN Framework Mistakes

1. Making the Role too vague

Mistake: "You are an expert in marketing."

Fix: "You are a performance marketing manager with 7 years of experience running paid acquisition for B2B SaaS products with $50K-$200K monthly ad budgets. You optimize for pipeline generated, not just leads."

The Role shapes every decision the AI makes downstream. A vague role produces vague output. Specify seniority, domain, and perspective.

2. Writing Steps that are just a reformatted Instruction

Mistake:

Instructions: Write a competitive analysis.
Steps:
1. Analyze competitors
2. Write the analysis
3. Add recommendations

Fix:

Instructions: Write a competitive analysis of three project management
tools for a mid-market engineering team evaluation.
Steps:
1. Define evaluation criteria: pricing, integrations, learning curve,
   customization, and support quality
2. Research each tool (Linear, Jira, Shortcut) against these criteria
3. Create a scoring matrix — 1-5 scale per criterion with justification
4. Identify the single biggest strength and weakness of each tool
5. Recommend one tool with a clear rationale tied to the scoring

Steps should add procedural detail the Instructions do not contain. If your Steps just rephrase the Instruction in numbered form, they are adding structure without adding information.

3. Skipping the End Goal

Without an End Goal, the AI optimizes for completeness — it tries to include everything. An explicit End Goal tells it what to optimize for instead.

Without End Goal: The AI writes a thorough analysis that covers everything but takes 20 minutes to read and does not lead to a clear decision.

With End Goal: "The VP of Engineering should be able to choose a tool and justify the decision to their team in a 15-minute meeting."

Now the AI optimizes for decisiveness, clarity, and brevity — not comprehensiveness.

4. Using Narrowing only for word count

Narrowing is the most underused component. Most people write "keep it under 500 words" and stop. But Narrowing can also control:

• Scope: "Focus only on the US market"
• Exclusions: "Do not discuss pricing — that is handled separately"
• Assumptions: "Assume the reader has used at least one CRM before"
• Format: "Output as a table, not prose"
• Quality gates: "Every recommendation must include an estimated impact and effort level"

The more specific your Narrowing, the less you need to edit the output.

5. Overcomplicating simple tasks

RISEN is a five-component framework. Not every prompt needs all five components. If you are asking the AI to convert JSON to YAML, you do not need a Role, Steps, End Goal, and Narrowing. You need an Instruction.

Rule of thumb: If the task is one step with no ambiguity, skip the framework. If the task has multiple steps, requires a specific perspective, or needs clear boundaries, use RISEN. If you need something in between, check our prompt engineering cheat sheet for quick-reference patterns.

RISEN Framework Across Different AI Models

Frameworks are model-agnostic by design, but models respond to RISEN's components differently in practice. Here is what to expect across GPT-4o, Claude, and Gemini.

GPT-4o follows Steps faithfully. It respects the numbered sequence and typically produces output that maps one-to-one to each step. It can over-index on the Role component — if you assign an academic expert role, expect more formal language than you probably want. Add explicit tone guidance in the Instructions or Narrowing to compensate.

Claude is strong with nuanced Roles and End Goals. It tends to synthesize steps rather than executing them mechanically, which produces more natural-sounding analysis. Claude also handles contradictions well — if your Narrowing conflicts slightly with your Instructions, Claude will flag it rather than silently choosing one.

Gemini benefits most from specific Narrowing. Without explicit constraints, Gemini tends toward verbose output. It handles long, detailed Steps well and often adds useful structure (tables, headers) to its output even when not asked. If you want concise output from Gemini, make word count and format constraints explicit in Narrowing.

Across all models, the Steps and Narrowing components produce the most consistent improvement. Steps prevent the model from skipping important analysis. Narrowing prevents the model from defaulting to maximum scope. If you are adapting a freeform prompt to RISEN, start with these two components — they deliver the highest impact per minute of prompt-writing effort.

For more on how to write better AI prompts across different models, see our practical guide.

---

Frequently Asked Questions

What does RISEN stand for?

RISEN stands for Role, Instructions, Steps, End Goal, and Narrowing. These five components structure an AI prompt so the model receives clear context about who to be, what to do, what process to follow, what success looks like, and what constraints to respect.

Is RISEN better than CO-STAR?

They serve different purposes. RISEN excels at multi-step analytical tasks where the process matters as much as the output — code reviews, research, planning, technical analysis. CO-STAR is better for content creation where tone, audience, and style are the primary quality drivers. If your task has a clear sequence of operations, use RISEN. If your task needs to sound a specific way for a specific audience, use CO-STAR. See our framework comparison for a detailed side-by-side analysis.

Does the RISEN framework work with Claude and Gemini?

Yes. RISEN works with all major LLMs including GPT-4o, Claude, Gemini, and DeepSeek. Each model handles the components slightly differently — GPT-4o follows Steps most literally, Claude excels at nuanced Roles, and Gemini benefits most from explicit Narrowing — but the framework structure improves output quality across all models.

What is the difference between RISE and RISEN?

RISE drops the Narrowing component, leaving four elements: Role, Instructions, Steps, End Goal. RISEN adds Narrowing — the constraints and boundaries that keep output focused. In practice, the Narrowing component reduces hallucination, prevents scope creep, and produces output that requires less editing. Unless your task is simple enough to need no constraints, use the full RISEN framework.

Can I combine RISEN with other frameworks?

Yes. Frameworks are mental models, not rigid templates. Common effective combinations include RISEN plus STOKE's Knowledge component (for domain-expert tasks that also need a clear process), and RISEN's Steps inside a CO-STAR prompt (for content tasks that follow a specific sequence). The goal is information completeness — give the AI everything it needs, borrowing from whichever framework has the right component.

---

Ready to Try RISEN?

Promplify applies the RISEN framework automatically. Paste your prompt, select RISEN, and get a structured version in seconds. The optimizer detects what your prompt is missing — Role, Steps, End Goal, Narrowing — and fills in each component based on your task type and target model.

Try RISEN in Promplify