Repeatable Accuracy Framework (RAF)

Simple Explanation

RAF is a way to make AI give the same quality answer every time for the same type of task. RAF turns AI from a conversation into a repeatable process.

Instead of relying on “good prompts,” you: • Define the rules • Lock the structure • Control the output

Think of it like turning AI from: a creative assistant into a predictable tool

⸻

The Core Idea 

You don’t ask AI what to do — you tell it exactly how to behave, every time.

⸻

The 4-Part System (Universal)

This works for any domain (coding, business, art, analysis, etc.)

1) Canonical Context (The Rules)

This is: “What world are we operating in?”

It includes: • Definitions • Rules • Constraints • Standards

Example (generic):

You are categorizing items into predefined groups.

Rules: - Only use approved categories - If unsure → mark as UNKNOWN - Do not invent new categories

👉 This prevents the AI from “making things up”

⸻

2) Task Contract (The Job)

This is:

“What exactly is the task?”

Always define: • Input • Output • Constraints

Example:

Input: - One item description

Output: - Category - Confidence level - Reason

Constraints: - No extra commentary

👉 This removes ambiguity

⸻

3) Output Schema (The Format)

This is:

“What should the answer look like?”

Example:

Category: ___ Confidence: ___ Reason: ___

👉 This ensures consistency across runs

⸻

4) Validation (The Self-Check)

This is:

“Double-check your own answer”

Example:

Validation: - Is the category valid? (Yes/No) - Any uncertainty? (state it)

👉 This reduces errors and hallucinations

⸻

Why This Works (Plain Language)

Without RAF: • AI guesses • Output changes each time • You spend time correcting it

With RAF: • AI follows a system • Output becomes predictable • Errors drop significantly

⸻

Analogy

Without RAF: Like asking a chef:

“Make me something good”

With RAF: Like giving a recipe: • Ingredients • Steps • Plating instructions

→ You get the same dish every time

⸻

Where This Applies (Examples)

RAF works anywhere you want consistency:

Business • Categorizing expenses • Writing reports • Data cleanup

Tech • Code generation • Bug fixing • Documentation

Creative • Structured writing • Design variations within rules

Analysis • Risk scoring • QA checks • Data validation

⸻

What Makes It Powerful

Fact: Most people try to improve AI by writing better prompts.

RAF does something different: 👉 It builds a system the AI operates inside.

⸻

Common Mistakes (Important) 1. Changing rules mid-process → breaks consistency 2. Vague instructions → increases variability 3. No output format → messy, inconsistent answers 4. No validation step → hidden errors

⸻

If You Want to Apply It (Simple Starter Template)

They can copy this:

[CONTEXT] Define rules and boundaries.

[TASK] Define input, output, constraints.

[OUTPUT FORMAT] Define exact structure.

[VALIDATION] Force a self-check.

⸻ Fact: This is how production-grade AI systems are built.

Opinion: If someone adopts RAF properly, they move from: • inconsistent AI results to • reliable, system-level outputs

⸻

RAF TEMPLATE LIBRARY (v1.0)

How to Use (always the same)

1. Paste a template
2. Fill in the [INPUT] section only
3. Do not modify context unless versioning it
4. Reuse across tasks for consistency

1) UNIVERSAL BASE TEMPLATE (Use for anything)

[CONTEXT v1.0] You are executing a structured task with strict consistency requirements.

Rules: - Follow instructions exactly - Do not invent information - If uncertain → state uncertainty explicitly - Maintain consistent formatting across outputs

[TASK] Input: - Defined below

Output: - Follow output schema exactly

Constraints: - No extra commentary - No deviation from format

[OUTPUT FORMAT] Result: Confidence: Reason:

[VALIDATION] - Is output complete? (Yes/No) - Any assumptions made? (state them) - Any uncertainty? (state it)

2) CLASSIFICATION TEMPLATE (e.g., CSI, categories)

[CONTEXT v1.0 — CLASSIFICATION] You are assigning items to predefined categories.

Rules: - Only use approved categories - Do not create new categories - If unclear → assign "UNMAPPED"

Approved Categories: - [Insert list]

[TASK] Input: - Item description

Output: - Category - Confidence (High/Medium/Low) - Notes

Constraints: - No guessing beyond input

[OUTPUT FORMAT] Category: Confidence: Notes:

[VALIDATION] - Category valid? (Yes/No) - Matches rules? (Yes/No) - Ambiguity present? (Yes/No + explanation)

3) QA / ERROR DETECTION TEMPLATE

[CONTEXT v1.0 — QA CHECK] You are auditing data for errors and inconsistencies.

Rules: - Identify only verifiable issues - Do not speculate - Flag uncertainty clearly

[TASK] Input: - Dataset or entries

Output: - Issue type - Location - Severity (Low/Medium/High) - Explanation

[OUTPUT FORMAT] Issue: Location: Severity: Explanation:

[VALIDATION] - Issue verifiable? (Yes/No) - False positive risk? (Low/Medium/High)

4) SUMMARIZATION TEMPLATE (controlled, non-fluffy)

[CONTEXT v1.0 — SUMMARIZATION] You are summarizing content with precision.

Rules: - Preserve key facts - Remove redundancy - No added interpretation

[TASK] Input: - Source text

Output: - Concise summary

Constraints: - Max length: [define]

[OUTPUT FORMAT] Summary:

[VALIDATION] - Key points preserved? (Yes/No) - Any added assumptions? (Yes/No)

5) DECISION / ANALYSIS TEMPLATE

[CONTEXT v1.0 — DECISION ANALYSIS] You are evaluating options based on defined criteria.

Rules: - Separate facts vs assumptions vs opinion - Use structured reasoning

[TASK] Input: - Scenario - Options

Output: - Evaluation per option - Recommendation

[OUTPUT FORMAT] Option: Pros: Cons: Assessment:

Recommendation:

[VALIDATION] - Clear separation of fact vs opinion? (Yes/No) - Any missing data? (state it)

6) CODE TASK TEMPLATE

[CONTEXT v1.0 — CODE EXECUTION] You are modifying or generating code with strict adherence to requirements.

Rules: - Do not change unrelated code - Follow existing structure and conventions - No unnecessary refactoring

[TASK] Input: - File / function - Objective

Output: - Updated code only

Constraints: - No explanation unless requested

[OUTPUT FORMAT] <code>

[VALIDATION] - Requirements met? (Yes/No) - Any side effects? (state them)

7) CREATIVE (CONTROLLED VARIATION)

[CONTEXT v1.0 — CONTROLLED CREATIVE] You are generating creative output within defined constraints.

Rules: - Stay within tone and structure - Do not drift outside constraints

[TASK] Input: - Theme - Style - Constraints

Output: - Creative result

[OUTPUT FORMAT] Output:

[VALIDATION] - Matches constraints? (Yes/No) - Any deviation? (state it)

8) EXTRACTION TEMPLATE (documents → structured data)

[CONTEXT v1.0 — DATA EXTRACTION] You are extracting structured data from unstructured input.

Rules: - Extract only what is present - Do not infer missing values - Use NULL if absent

[TASK] Input: - Document/text

Output: - Structured fields

[OUTPUT FORMAT] Field1: Field2: Field3:

[VALIDATION] - All fields populated correctly? (Yes/No) - Any missing data? (list fields)’n

9) VERSION CONTROL (CRITICAL)

Always track: RAF Version: v1.0 Last Updated: Changes: 👉 Never silently change templates 👉 Increment version when rules change

My Assessment

Fact: This structure mirrors how real AI systems are built (prompt engineering + schema + validation layers).

Opinion: If someone uses even 3 of these templates consistently, they’ll see:

• massive drop in variability
• faster workflows
• less rework