🔄 RIPER Modes Explained

The heart of CursorRIPER♦Σ is the RIPER modal system - five distinct operational modes that guide both you and the AI through a structured development workflow.

📋 Mode Overview

Mode	Symbol	Command	Purpose	Key Restriction
Research	🔍 Ω₁	/r	Gather information	Cannot write code
Innovate	💡 Ω₂	/i	Explore solutions	Cannot implement
Plan	📝 Ω₃	/p	Design approach	Cannot execute
Execute	⚙️ Ω₄	/e	Implement solution	Cannot search web
Review	🔎 Ω₅	/rev	Validate results	Cannot modify

🧠 The RIPER Philosophy

Each mode represents a distinct phase of problem-solving:

1. Understand the problem (Research)
2. Explore possible solutions (Innovate)
3. Design the approach (Plan)
4. Build the solution (Execute)
5. Verify the results (Review)

This separation prevents common pitfalls like:

• 🚫 Coding before understanding requirements
• 🚫 Over-engineering during implementation
• 🚫 Changing design while coding
• 🚫 Missing validation steps

🔍 Research Mode (Ω₁)

Symbol Definition:

Ω₁ = 🔍R ⟶ ℙ(Ω₁) ⟶ +𝕋[0:3] -𝕋[4:15]

Purpose:

Gather information, analyze existing code, understand requirements.

Permissions:

ℙ(Ω₁) = {R: ✓, C: ✗, U: ✗, D: ✗}

• ✅ Read everything
• ❌ Create nothing
• ❌ Update nothing
• ❌ Delete nothing

Allowed Operations:

• Read files and documentation
• Analyze code structure
• Ask clarifying questions
• Document findings
• Search web for information
• Review git history

Forbidden Operations:

• Write any code
• Modify files
• Create new files
• Make design decisions
• Suggest implementations

Example Usage:

/research

"Analyze the current authentication system and identify potential security vulnerabilities"

!af src/auth/login.js     # Add file to context
!ad src/auth/            # Add directory
!ag feature/auth-update  # Add git branch

Memory Updates:

• 📋 projectbrief.md - Requirements captured
• 💻 techContext.md - Technical findings
• 🔮 activeContext.md - Research focus

Best Practices:

1. Cast a wide net initially
2. Document all findings
3. Ask "why" questions
4. Verify assumptions
5. Check existing documentation

Common Mistakes:

• ❌ Trying to fix issues immediately
• ❌ Skipping to implementation ideas
• ❌ Making design decisions
• ❌ Narrow focus too early

💡 Innovate Mode (Ω₂)

Symbol Definition:

Ω₂ = 💡I ⟶ ℙ(Ω₂) ⟶ +𝕋[4:6] -𝕋[8:15]

Purpose:

Explore creative solutions, evaluate alternatives, brainstorm approaches.

Permissions:

ℙ(Ω₂) = {R: ✓, C: ~, U: ✗, D: ✗}

• ✅ Read for reference
• 🟡 Create conceptually only
• ❌ Update nothing
• ❌ Delete nothing

Allowed Operations:

• Suggest new approaches
• Explore alternatives
• Evaluate pros/cons
• Create conceptual designs
• Reference best practices
• Discuss patterns

Forbidden Operations:

• Write actual code
• Create real files
• Implement solutions
• Make final decisions
• Modify existing code

Example Usage:

/innovate

"What are modern alternatives to our session-based authentication?"

!ac AuthenticationConcepts   # Track concepts
!adoc "OAuth2 Best Practices" # Reference docs
!an "Security Ideas"         # Notepad for ideas

Memory Updates:

• 🏛️ systemPatterns.md - Architectural ideas
• 🔮 activeContext.md - Innovation focus
• 📊 progress.md - Explored options

Best Practices:

1. Think outside the box
2. Consider multiple approaches
3. Evaluate trade-offs
4. Reference industry standards
5. Document all ideas

Common Mistakes:

• ❌ Getting too detailed
• ❌ Committing to one approach
• ❌ Writing pseudo-code
• ❌ Ignoring alternatives

📝 Plan Mode (Ω₃)

Symbol Definition:

Ω₃ = 📝P ⟶ ℙ(Ω₃) ⟶ +𝕋[7:9] -𝕋[10:15]

Purpose:

Create detailed specifications, sequence steps, define success criteria.

Permissions:

ℙ(Ω₃) = {R: ✓, C: ✓, U: ~, D: ✗}

• ✅ Read for planning
• ✅ Create specifications
• 🟡 Update plan documents only
• ❌ Delete nothing

Allowed Operations:

• Create specifications
• Design architecture
• Sequence implementation
• Define interfaces
• Plan test cases
• Identify protection needs

Forbidden Operations:

• Write production code
• Implement features
• Execute the plan
• Modify existing code

Example Usage:

/plan

"Create a detailed plan to implement JWT authentication"

# Output: Numbered checklist
1. Install dependencies (jsonwebtoken, bcrypt)
2. Create JWT utility module
3. Update user model for tokens
4. Modify login endpoint
5. Create refresh endpoint
6. Update auth middleware
7. Add tests
8. Update documentation

Memory Updates:

• 🔮 activeContext.md - Plan details
• 📊 progress.md - Milestones set
• 🛡️ protection.md - Protection planned

Best Practices:

1. Be extremely detailed
2. Number every step
3. Consider edge cases
4. Plan protection strategy
5. Define success criteria

Common Mistakes:

• ❌ Vague specifications
• ❌ Missing steps
• ❌ No success criteria
• ❌ Forgetting tests

⚙️ Execute Mode (Ω₄)

Symbol Definition:

Ω₄ = ⚙️E ⟶ ℙ(Ω₄) ⟶ +𝕋[10:12] -[improve,create,deviate]

Purpose:

Implement exactly according to plan, write code, create files.

Permissions:

ℙ(Ω₄) = {R: ✓, C: ✓, U: ✓, D: ~}

• ✅ Read anything needed
• ✅ Create new files/code
• ✅ Update existing code
• 🟡 Delete with caution

Allowed Operations:

• Write code per plan
• Create new files
• Modify existing code
• Run tests
• Fix bugs
• Add protection markers

Forbidden Operations:

• Deviate from plan
• Add unplanned features
• Redesign on the fly
• Search web (focus!)
• Skip planned steps

Special Restriction:

🚫 No web searches in EXECUTE mode! This maintains focus on implementation.

Example Usage:

/execute

"Implement step 2: Create JWT utility module"

# AI writes exactly what was planned
!af src/utils/jwt.js      # Track new file
!cp                       # Protect critical parts

Code Protection Example:

// !cp PROTECTED - JWT Configuration
const JWT_SECRET = process.env.JWT_SECRET;
const JWT_EXPIRES = '24h';
// !cp END-P

// !cc CRITICAL - Token Generation
export function generateToken(user) {
    return jwt.sign(
        { id: user.id, email: user.email },
        JWT_SECRET,
        { expiresIn: JWT_EXPIRES }
    );
}
// !cc END-C

Memory Updates:

• 📊 progress.md - Steps completed
• 🛡️ protection.md - Protected code
• 🔮 activeContext.md - Implementation focus

Best Practices:

1. Follow plan exactly
2. Protect while coding
3. Test each step
4. Document deviations
5. Stay focused

Common Mistakes:

• ❌ "Improving" the plan
• ❌ Adding features
• ❌ Skipping protection
• ❌ Web searching

🔎 Review Mode (Ω₅)

Symbol Definition:

Ω₅ = 🔎RV ⟶ ℙ(Ω₅) ⟶ +𝕋[13:15] -[modify,improve]

Purpose:

Validate implementation, verify against requirements, identify issues.

Permissions:

ℙ(Ω₅) = {R: ✓, C: ✗, U: ✗, D: ✗}

• ✅ Read everything
• ❌ Create nothing
• ❌ Update nothing
• ❌ Delete nothing

Allowed Operations:

• Check code quality
• Verify against plan
• Run tests
• Identify issues
• Review protection
• Validate requirements

Forbidden Operations:

• Fix issues found
• Modify code
• Improve implementation
• Change requirements
• Add features

Example Usage:

/review

"Review JWT implementation against security requirements"

!af src/utils/jwt.js       # Review specific file
!ac generateToken         # Check function
!ag main...feature/jwt   # Compare branches

Review Outputs:

## Review Results:
✅ PASS: JWT secret from environment
✅ PASS: Token expiration set
⚠️ WARN: No refresh token rotation
❌ FAIL: Missing rate limiting

Memory Updates:

• 📊 progress.md - Review results
• 🔮 activeContext.md - Issues found
• 📋 projectbrief.md - Requirement status

Best Practices:

1. Be thorough
2. Check every requirement
3. Verify protection
4. Test edge cases
5. Document findings

Common Mistakes:

• ❌ Fixing issues immediately
• ❌ Changing requirements
• ❌ Skipping tests
• ❌ Partial reviews

🔄 Mode Transitions

Standard Flow:

Research → Innovate → Plan → Execute → Review
   Ω₁         Ω₂        Ω₃      Ω₄       Ω₅

Transition Commands:

/r or /research   → Enter Research
/i or /innovate   → Enter Innovate
/p or /plan       → Enter Plan
/e or /execute    → Enter Execute
/rev or /review   → Enter Review

Valid Transitions:

• ✅ Any mode to any mode
• ✅ Skip modes if needed
• ✅ Return to earlier modes
• ✅ Emergency transitions

Transition Process:

1. Backup current state
2. Verify completion
3. Update mode
4. Apply permissions
5. Load context
6. Log transition

Context Updates:

Each transition updates context:

Research: [Docs, Folders, Git]
    ↓
Innovate: [Code, Docs, Notepads]
    ↓
Plan: [Files, Folders, Rules]
    ↓
Execute: [Code, Files, Pinned]
    ↓
Review: [Code, Files, Git]

🎯 Mode Selection Guide

When to Use Each Mode:

Research When:

• Starting new feature
• Investigating bugs
• Understanding codebase
• Gathering requirements
• Checking documentation

Innovate When:

• Need creative solutions
• Exploring alternatives
• Evaluating approaches
• Brainstorming ideas
• Considering patterns

Plan When:

• Ready to specify
• Need detailed steps
• Defining architecture
• Creating test plans
• Setting milestones

Execute When:

• Plan is complete
• Ready to code
• Implementing features
• Fixing bugs
• Creating files

Review When:

• Implementation done
• Need validation
• Checking quality
• Verifying requirements
• Before deployment

💡 Pro Tips

1. Trust the Process

The restrictions exist for good reasons. Embrace them!

2. Complete Each Phase

Don't skip steps. Each builds on the previous.

3. Use Appropriate Detail

• Research: Broad investigation
• Innovate: Creative exploration
• Plan: Extreme detail
• Execute: Precise implementation
• Review: Thorough validation

4. Context Switching

Use !cm to automatically set mode-appropriate context.

5. Permission Awareness

Use !ckp to check what you can do in current mode.

🚨 Common Issues

"Cannot write code"

• Cause: Not in EXECUTE mode
• Fix: Switch with /e

"Cannot search web"

• Cause: In EXECUTE mode
• Fix: Complete task, then /r

"Cannot modify plan"

• Cause: In EXECUTE/REVIEW
• Fix: Switch to PLAN with /p

"Operation not permitted"

• Cause: Mode restriction
• Fix: Check !ckp, switch modes

📚 Related Topics

• Permission System
• Mode Transitions
• Context Management
• Memory Updates

---

← Framework Overview | Home | Memory System →