RISEN (10–80–10)

A practical framework for using AI at work — safer, repeatable, and human-led outcomes.

Why AI Often Fails in Real Work

  • Outputs look impressive but aren’t usable in a process or workflow.
  • Results vary between users — hard to repeat, hard to standardise.
  • No clear audit trail: what was asked, what assumptions were made, what changed.
  • Too much trust placed in “the answer” instead of judgement and evidence.

The issue isn’t AI capability — it’s how we ask and how we apply.

Context: RISEN 10–80–10 (Live Example)

This is the supporting context page that demonstrates the framework in a working, shareable format. Use it during delivery, onboarding, or as a reference link in documentation.

⧉ Open in new tab

Tip: in a “Bring Your Own LLM” setup, you can keep prompts + examples here, and paste outputs back into tools or documents.

What is RISEN?

RISEN is a structured prompt framework that forces clarity before generation.

R — Role

Tell the AI who it is (expertise, perspective, domain).

I — Instructions

Define the task and what “done” looks like.

S — Steps

Provide the logic: sequence, decisions, transformations.

E — Example / End Goal

Show the shape of success (structure, style, output pattern).

N — Narrowing

Add guard rails: format (JSON/table/email), length, language, exclusions, tone, risk boundaries.

The 10–80–10 Model

Put human effort where it matters: design the thinking, let AI execute, then apply judgement.

10%

Setup

Define Role, Instructions, Steps, Example, and Narrowing.

80%

Execution

AI does the drafting, structuring, and heavy lifting.

10%

Review

Human judgement: validate, correct, and decide what to keep.

Shift: less typing and trial-and-error, more intent and reuse. The output becomes a repeatable artefact, not a one-off answer.

The First 10%: Role

Tell the AI who it is — expertise, viewpoint, and boundaries.

Examples

  • “You are a Senior Business Analyst working in UK public services.”
  • “You are a Finance Operations SME for accounts receivable and payments.”
  • “You are an NHS policy writer focused on clarity and compliance.”

Why it matters

  • Sets assumptions (UK context, service constraints, terminology).
  • Aligns tone (formal, plain English, instructional, empathetic).
  • Improves consistency between different users and teams.

The Core 80%: Instructions & Steps

Define the task and provide the logic. This is where most quality comes from.

Instructions

  • What to produce (checklist, email, risks, requirements, summary).
  • Audience (new starter, manager, supplier, public).
  • Success criteria (“usable in an SOP”, “actionable”, “no jargon”).

Steps

  • Ordered sequence (extract → normalise → generate → validate).
  • Decision points (if/else, thresholds, exceptions).
  • Transformations (turn text into JSON, process map, table).

Guard Rails: Example & Narrowing

Constraints don’t reduce quality — they increase it.

Example / End Goal

  • Shows the structure you want (headings, fields, sections).
  • Reduces ambiguity and “creative wandering”.
  • Helps teams produce consistent artefacts.

Narrowing

  • Output format: JSON only, table, email, bullets.
  • Style: UK English, plain language, no legal advice, no hype.
  • Limits: word count, sections, “do not include” exclusions.

The Final 10%: Human Review

AI accelerates. Humans decide.

Review checklist

  • Sense-check facts and policy alignment.
  • Validate assumptions and edge cases.
  • Remove anything risky, vague, or unverified.

Decision

  • Keep what’s useful and evidence-backed.
  • Rewrite the bits that need nuance.
  • Decide what not to use.

Treat AI as an assistant, not an authority.

RISEN in Practice

Without RISEN

Prompt: “Write me a checklist for payroll.”

  • Generic, inconsistent, missing controls.
  • Hard to reuse or audit.
  • Often unclear what assumptions were made.

With RISEN

  • Role: Payroll Ops Lead (UK).
  • Instructions: Compliance checklist for end-to-end payroll run.
  • Steps: Validate → Process → Reconcile → Sign-off.
  • Example: NHS-style stage checklist.
  • Narrowing: JSON only, UK terminology.

Outcome: reusable, shareable, and safer — ready for tools and automation.

Where RISEN Delivers the Most Value

Especially useful in teams where accuracy, consistency, and risk matter.

Finance

Payments, reconciliations, controls, evidence-led checklists.

HR & Payroll

Standard outputs, clear steps, compliance boundaries.

Policy & Legal

Controlled drafting with constraints and traceability.

Health & Care

Plain-English guidance, repeatability, safety checks.

Public Services

Consistent outputs across teams and services.

Digital & Delivery

Requirements, user journeys, acceptance criteria, SOP tooling.

RISEN + “Bring Your Own LLM”

A low-risk operating model: control the structure, not the vendor.

Security & Procurement Friendly

Tools don’t need LLM API keys. Users run prompts in their approved LLM accounts.

Vendor Neutral

The “contract” is the schema (JSON/table), not the model. Swap providers without redesign.

Reusable Assets

RISEN prompts and examples become shared team assets: versioned, reviewed, improved.

Path to Production

Once the shape is trusted, replace copy/paste with workflows (Power Automate, n8n, APIs).

From Prompts to Products

RISEN scales beyond chat into real tools.

Checklists

Execution support with evidence capture and sign-off.

Process Maps

Mermaid / PlantUML from SOPs and workflow descriptions.

Structured Data

Turn messy text into JSON/CSV ready for reporting.

Training

Quizzes, flashcards, onboarding guides from SOPs.

Requirements

User stories, acceptance criteria, MoSCoW, controls.

Automation

Trigger workflows and approvals using predictable outputs.

What “Good” Looks Like

A good RISEN prompt…

  • Can be reused by someone else without extra explanation.
  • Produces similar outputs across different users and models.
  • Captures assumptions and constraints clearly.
  • Creates artefacts that fit a workflow (not just “nice text”).

A good output…

  • Is structured (JSON/table) and easy to check.
  • Is actionable (clear steps, decisions, ownership).
  • Has obvious gaps flagged, not hidden.
  • Is safe to share internally without rework.

If it can’t be reused, it’s not a framework yet — it’s just a one-off.

Getting Started (Today)

1

Pick one real task

Something you genuinely do at work, not a demo.

2

Write the RISEN prompt

Spend 10 minutes on structure before asking.

3

Let AI execute

Generate the draft, structure, or schema.

4

Review and reuse

Improve once, then share as a team asset.

Tip: keep prompts in a shared library (SharePoint/Wiki), with examples and “known good” outputs. That’s how you scale safely.

Closing Thought

AI doesn’t replace thinking — it rewards those who structure it well.

RISEN (10–80–10) is a simple habit: design the ask, let AI do the work, then apply judgement. Repeat, refine, and share.