L2 → L3: Conversationalist to Delegator

Time to level up: 2-3 weeks

---

Where You Are Now (L2: Conversationalist)

Current Behavior

• Good context in your prompts
• Multi-turn conversations that build on each other
• Interactive steering throughout—you guide every step
• Manual oversight of each output
• React to problems as they appear

What It Looks Like

User: [Good context + request]
AI: *starts implementing*
User: "Wait, also consider X"
AI: *adjusts*
User: "That looks wrong, try Y instead"
AI: *adjusts*
User: "Better. Now the next part..."
AI: *continues*
User: "Hmm, tests are failing"
AI: "Let me check..."
...continues with constant steering...

Why This Is Inefficient

• You're the bottleneck—AI waits for your approval at every step
• 5-10 turns is better than 15, but still high
• Constant context switching between thinking and reviewing
• No structured approach to complex work
• 30-40% rework rate from mid-course corrections

---

Where You're Going (L3: Delegator)

Target Behavior

• Create a plan first, before any implementation
• Approve the plan, then let AI execute
• Review at checkpoints, not every turn
• Trust AI to handle implementation details
• Intervene only when actually needed

What It Looks Like

User: "Add email validation to user registration. 
       Use brainstorming to explore options first."
AI: *invokes brainstorming*
    "Here are 3 approaches with trade-offs..."
User: "Option 2 sounds best"
AI: *invokes writing-plans*
    "Here's the implementation plan with 4 phases..."
User: "Approved"
AI: *invokes executing-plans*
    *implements phase 1*
    *checkpoint: tests pass*
    *implements phase 2*
    *checkpoint: integration works*
    *invokes verification-before-completion*
    "Done. All tests pass, linting clean, changes verified."

---

Key Skills to Learn

1. brainstorming

Use before any creative work—creating features, building components, adding functionality.

Explores user intent, requirements, and design before implementation.

"Use brainstorming before implementing this feature"

2. writing-plans

Use when you have requirements for multi-step work.

Creates structured implementation plans with phases, dependencies, and checkpoints.

"Use writing-plans to create an implementation plan"

3. executing-plans

Use when you have a written plan to execute.

Runs the plan with review checkpoints so you can monitor without micromanaging.

"Use executing-plans to implement this plan"

4. verification-before-completion

Use before claiming work is done.

Runs verification commands (tests, linting, builds) before making success claims.

"Use verification-before-completion before finishing"

---

Practice Exercises

Exercise 1: The Brainstorm-First Rule (Week 1)

For your next 5 feature tasks, ALWAYS start with brainstorming.

Not:

"Add caching to the user lookup function"

Instead:

"I need to add caching to user lookup. Use brainstorming 
to explore options—Redis vs in-memory, cache invalidation 
strategies, what to cache vs not."

What to notice:

• Did brainstorming surface options you hadn't considered?
• Did it catch potential issues early?
• Did the final implementation change based on brainstorming?

Exercise 2: Plan Before Code (Week 1-2)

For your next 5 multi-step tasks, create a written plan before any code.

Workflow:

1. Provide context and requirements
2. Ask for brainstorming if unsure of approach
3. Request a plan with writing-plans
4. Review the plan carefully
5. Only then approve implementation

The rule: No code until you've seen and approved a plan.

Example:

"I need to add rate limiting to our API endpoints.
Use writing-plans to create an implementation plan. 
Don't implement anything yet—just the plan."

Review the plan. Ask questions. Adjust if needed. THEN approve.

Exercise 3: Hands-Off Execution (Week 2-3)

For your next 5 planned tasks, resist the urge to interrupt.

After approving a plan:

1. Let AI start with executing-plans
2. Do not intervene until a checkpoint
3. Only provide feedback at checkpoints
4. Trust the process

The challenge: Your instinct is to steer. Fight it.

Example:

User: "Plan approved. Use executing-plans to implement."
AI: *phase 1 complete, checkpoint*
    "Phase 1 done. Tests pass. Continue to phase 2?"
User: "Continue" (NOT "Wait, also add X" or "Actually, change Y")
AI: *phase 2 complete, checkpoint*
...

Exercise 4: The Full Workflow (Week 2-3)

Complete 3 tasks using the full L3 workflow:

1. Context + Requirements
2. brainstorming (if creative work)
3. writing-plans
4. Review and approve plan
5. executing-plans
6. verification-before-completion
7. Done

Track your turns. Goal: 3-5 turns total.

---

Success Criteria

You've reached L3 when:

The clearest sign: You naturally reach for brainstorming and writing-plans before starting any complex work.

---

Common Mistakes

Mistake 1: Skipping the Plan

❌ "Just implement it, it's simple" ✅ "Use writing-plans first—even simple tasks benefit from structure"

Even "simple" tasks often have hidden complexity. The plan reveals it.

Mistake 2: Micromanaging Execution

❌ "Wait, before you continue, also add logging... and error handling... and..." ✅ Let execution continue to checkpoints, then provide batch feedback

If you find yourself interrupting constantly, your plan wasn't detailed enough.

Mistake 3: Never Using Brainstorming

❌ "I know exactly what I want, just build it" ✅ "Use brainstorming to explore—I might be missing something"

Brainstorming often surfaces options you hadn't considered. It takes 2 minutes and saves hours.

Mistake 4: Approving Bad Plans

❌ Glances at plan "Looks good, go" ✅ Reads plan carefully "Phase 2 seems risky. Can you add a rollback step?"

The plan is your chance to catch issues. Use it.

---

The L3 Workflow Cheatsheet

┌─────────────────────────────────────────────────────────┐
│ 1. CONTEXT + REQUIREMENTS                              │
│    "I need to [what] for [why]. Tech: [stack]."        │
├─────────────────────────────────────────────────────────┤
│ 2. BRAINSTORM (if creative work)                       │
│    "Use brainstorming to explore options"              │
├─────────────────────────────────────────────────────────┤
│ 3. PLAN                                                │
│    "Use writing-plans to create implementation plan"   │
├─────────────────────────────────────────────────────────┤
│ 4. REVIEW + APPROVE                                    │
│    Read plan. Ask questions. Adjust. "Approved."       │
├─────────────────────────────────────────────────────────┤
│ 5. EXECUTE                                             │
│    "Use executing-plans" → wait for checkpoints        │
├─────────────────────────────────────────────────────────┤
│ 6. VERIFY                                              │
│    "Use verification-before-completion"                │
└─────────────────────────────────────────────────────────┘

---

Skill Quick Reference

---

What's Next

Once you consistently:

• Use planning skills for 80%+ of multi-step tasks
• Complete tasks in 3-5 turns
• Review at checkpoints, not every turn

You're ready for L3-to-L4: Delegator to Orchestrator.

The next level introduces parallel agents—running multiple tasks simultaneously for dramatic efficiency gains.

---

Remember: L2 → L3 is where the biggest efficiency gains happen. The shift from steering to delegating cuts your turns in half and your rework rate by 50%.