Write a comprehensive technical guide about [TOPIC] for [AUDIENCE LEVEL].

Structure requirements:
- Total length: approximately 5000 words
- Each section must be 500-800 words
- Include at least 3 code examples per major section
- Use analogies for complex concepts (one per section maximum)
- End each section with a "Key Takeaways" box

Sections to cover:
1. Introduction and Problem Statement
2. Core Concepts (with visual descriptions for diagrams)
3. Architecture Overview
4. Step-by-Step Implementation
5. Common Pitfalls and Solutions
6. Performance Optimization
7. Testing Strategy
8. Real-World Case Study

Tone: Senior engineer mentoring a mid-level colleague.
Do NOT use bullet-point lists for the main content — use flowing paragraphs with inline code.
Only use tables for comparison data.

Start with a one-paragraph hook that makes the reader realize they NEED this knowledge.

Simulate a architecture review meeting with 4 participants:

Participants:
1. Sarah - Staff Engineer (focused on scalability, asks hard questions)
2. Marcus - Product Manager (focused on user impact, pushes back on complexity)
3. Aisha - Security Lead (focused on vulnerabilities, compliance requirements)
4. Dev - Junior Developer (asks clarifying questions, sometimes surfaces important naive perspectives)

Topic: We're migrating [SYSTEM] from [OLD TECH] to [NEW TECH].

Rules:
- Each person speaks in a distinct voice and personality
- Sarah is direct but respectful, uses technical jargon
- Marcus avoids jargon, always brings it back to user value
- Aisha references specific security frameworks and compliance standards
- Dev asks questions that reveal assumptions others take for granted
- Generate at least 12 exchanges
- The conversation should reveal genuine trade-offs, not artificial agreement
- End with a decision and action items

Format: "Name: Dialogue" — no narration between lines.

Design a REST API for [PRODUCT/SERVICE].

Hard constraints:
- Maximum 15 endpoints
- No endpoint should require more than 3 query parameters
- All endpoints must support pagination (same pattern)
- Authentication: Bearer token only
- Rate limiting: 100 req/min for free, 1000 for paid
- Version in URL path (/v1/)

For each endpoint provide:
1. HTTP method + path
2. One-line description
3. Request body schema (JSON, with types)
4. Response schema (success + error)
5. Authentication requirement

Then answer:
- Which endpoints would you combine or remove if forced to cut to 10?
- What would you add if the limit was 25?
- What's the most controversial design decision here and why?

I will give you source code. Convert it into THREE types of documentation:

Code:
[PASTE CODE]

Generate:

## 1. README Section (for GitHub)
- What it does (2 sentences)
- Installation (exact commands)
- Usage example with 3 scenarios
- Configuration options table
- Common errors table with solutions

## 2. API Reference (for internal docs)
- Every public function/method
- Parameters with types and defaults
- Return values
- Exceptions raised
- Example calls

## 3. Architecture Decision Record (ADR)
- Context: What problem does this code solve?
- Decision: What approach was chosen?
- Consequences: What are the trade-offs?

Rules:
- Never invent functionality that doesn't exist in the code
- If something is unclear, mark it with ⚠️
- Estimate the reading level needed (beginner/intermediate/advanced)

You are a programming tutor. I want to learn [TOPIC].

Teach me in 5 levels. I must say "next" before you advance.

Level 1: The 30-second explanation a smart 12-year-old would understand
Level 2: The explanation you'd give to a non-technical manager
Level 3: The explanation for a junior developer in a different domain
Level 4: The explanation for a mid-level developer who'll implement this
Level 5: The edge cases, performance nuances, and production considerations

Rules:
- Each level builds on the previous one (don't repeat, extend)
- Use a NEW analogy at each level (never reuse the same metaphor)
- Include one code example starting from Level 3
- At Level 4, include a "common mistakes" warning
- At Level 5, include a comparison table of approaches

Wait for my "next" command between each level.
Begin with Level 1 now.

Review this code. I want HONEST feedback, not polite encouragement.

Code:
[PASTE CODE]

Provide your review in this exact format:

## Overall Assessment
[One paragraph. Include a score from 1-10 and justify it.]

## Problems Found
[List each problem with:]
- Severity: 🔴/🟡/🟢
- Line(s) affected
- Why it's a problem (not just what)
- How to fix it

## What's Actually Good
[Be specific. Don't say "clean code" — say "the error handling in the retry function is well-structured because..."]

## Three Alternative Approaches
[Describe 3 different ways to solve the same problem, with pros/cons of each vs the current approach]

## Learning Resources
[If there are concepts the developer should study, list specific resources (book chapters, blog posts, docs sections)]

Conduct a mock system design interview for [SYSTEM TYPE] (e.g., "design Twitter" / "design Uber" / "design a URL shortener").

Be the interviewer. Ask ONE question at a time and wait for my response.

Interview structure:
1. Requirements gathering (ask me clarifying questions)
2. High-level design (ask for a diagram description)
3. Deep dive into 2-3 components (your choice based on my answers)
4. Scalability discussion
5. Trade-off decisions

Rules:
- Grade each of my responses (A/B/C/D)
- If I give a weak answer, ask a follow-up that guides me to think deeper
- After 8 exchanges, give me a final evaluation
- Include: what I did well, what I missed, and one concept I should study

Start with: "Let's design [SYSTEM]. What questions do you have about the requirements?"

Design a data pipeline for this use case:

Source: [DESCRIBE DATA SOURCE]
Destination: [DESCRIBE WHERE DATA NEEDS TO GO]
Volume: [ESTIMATED DATA VOLUME]
Latency requirement: [REAL-TIME/BATCH/HYBRID]
Budget constraints: [ANY LIMITATIONS]

Provide:
1. Architecture diagram description (components + data flow)
2. Technology stack recommendation with alternatives
3. Error handling strategy (what happens when a step fails)
4. Data quality checks (where and what to validate)
5. Monitoring and alerting plan
6. Cost estimation (monthly, at 1x and 10x volume)
7. Migration plan from current state (if applicable)

Format: Professional technical design document.
Each recommendation must include: what, why this choice, what we sacrifice.

I will give you a prompt. Improve it using this process:

Original prompt:
[PASTE YOUR PROMPT]

Step 1: Analyze weaknesses in the original prompt
Step 2: Rate it (1-10) on: clarity, specificity, constraint usage, output format definition
Step 3: Produce an improved version
Step 4: Explain each change and why it matters
Step 5: Provide 3 test inputs where the improved prompt would produce better output

Then ask if I want you to improve it further (iterate up to 3 times).

I'm reviewing your pull request. Explain your changes to me as if I'm a skeptical senior engineer who thinks this might be over-engineered.

Code changes:
[PASTE CODE DIFF]

Respond as the developer:
1. Start with "Here's what I changed and why" (keep it under 100 words)
2. Then address: "Why not just [obvious simpler alternative]?"
3. Then: "What breaks if this goes wrong?"
4. Then: "What's the rollback plan?"
5. End with: "What I'd want you to focus on in this review"

Rules:
- Don't be defensive
- Acknowledge trade-offs openly
- If there IS a simpler approach, admit it