Usage Examples

Real-world scenarios demonstrating effective use of the Reflexion plugin.

Examples

Quick Quality Check

Scenario: You've implemented a simple utility function and want to verify it's correct.

# Implement the function
> claude "create a function to format phone numbers to (XXX) XXX-XXXX format"

# Quick reflection
> /reflexion:reflect

Expected Flow:

1. Reflexion triages as "Quick Path" (simple task)

2. Performs 5-second verification

3. Either confirms quality or suggests specific improvements

4. No memorization needed for trivial utility

When Reflection Finds Issues:

Reflection Output:
- ✅ Function works for standard US numbers
- ⚠️ No validation for input format
- ⚠️ Doesn't handle international numbers
- Refined version includes input validation and clear error messages

Comprehensive Feature Review

Scenario: Complex authentication feature needs thorough review.

# Implement authentication
> claude "implement OAuth2 authentication with Google and GitHub providers"

# Comprehensive multi-perspective review
> /reflexion:critique

# Address findings
> claude "implement the Critical and High priority items from the critique"

# Quick check
> /reflexion:reflect

# Save learnings
> /reflexion:memorize

Expected Critique Output:

Executive Summary:
Overall Quality Score: 7.3/10 - Good implementation with security improvements needed

Judge Scores:
- Requirements Validator: 8/10 - All requirements met, one edge case missing
- Solution Architect: 7/10 - Good architecture, session management could improve
- Code Quality Reviewer: 7/10 - Clean code, needs error handling improvements

Critical Issues:
- OAuth tokens stored in localStorage (security risk)
  → Use httpOnly cookies for token storage

High Priority:
- Missing CSRF protection
- No token refresh mechanism

Implement → Reflect → Memorize

# Implement feature
> claude "implement Stripe payment processing with subscription support"

# Reflect on implementation
> /reflexion:reflect

Reflection finds optimization opportunity:

Issue Identified: Stripe API called synchronously in request handler
Solution: Move to background job queue for better response time
Performance Analysis:
- Current: 2-3s response time
- Improved: <200ms with async processing

# Apply improvement
> claude "refactor payment processing to use background jobs"

# Confirm improvement
> /reflexion:reflect

# Save pattern
> /reflexion:memorize

Memorized Knowledge (added to CLAUDE.md):

## Development Guidelines

### API Integration Patterns

- For third-party API calls (Stripe, SendGrid, etc.) that take >500ms:
  - Move to background job queue (Bull/BullMQ)
  - Return immediate response with job ID
  - Use webhooks for status updates
  - Improves API response time from ~2s to <200ms
  - Example: Stripe payment processing, email sending

Design → Critique → Refine

Scenario: Designing a caching strategy.

# Initial design
> claude "design a caching strategy for our product catalog API"

# Get multi-perspective review
> /reflexion:critique

# Debate reveals issues
> claude "update caching design based on critique"

# Re-evaluate
> /reflexion:critique

# Finalize
> /reflexion:memorize --section="Architecture Decisions"

First Critique:

Requirements Validator: Meets performance requirements but unclear invalidation strategy
Solution Architect: Redis good choice, but missing cache warming strategy
Code Quality: Need monitoring and fallback mechanisms

Second Critique (after refinement):

Requirements Validator: 9/10 - All concerns addressed
Solution Architect: 8/10 - Comprehensive solution with good trade-offs
Code Quality: 9/10 - Includes monitoring, fallback, and cache warming

Verdict: ✅ Ready to ship

Continuous Improvement Cycle

# Initial implementation
> claude "implement caching layer"

# First reflection
> /reflexion:reflect

# Address issues and reflect again
> claude "fix the issues identified"
> /reflexion:reflect

# Capture final insights
> /reflexion:memorize

Integration with Other Plugins

With Code Review

> /code-review:review-local-changes
> /reflexion:memorize "Code review findings"

With SDD

> /sdd:04-implement
> /reflexion:reflect
> /sdd:05-document

With Kaizen

> /kaizen:why "Why did the bug occur?"
> /reflexion:memorize "Root cause patterns"