Recap — The Two-Mode Workflow

# The Two-Mode Workflow Pair programming with AI is different from pair programming with a person. The dynamics are: you talk, AI types (or vice versa). Switching modes consciously is the skill. ## Mode 1: Drive You write code; AI assists with completions and answers. What you're doing: - Thinking through novel design. - Implementing complex logic. - Learning a new domain. - Working on the critical path. What AI does: - Inline completions (line/function). - Quick chat for "how do I X in Y library". - Refactoring suggestions when you ask. Pace: your pace. AI matches. ## Mode 2: Review AI writes code; you verify, refine, correct. What you're doing: - Specifying what you want. - Reviewing AI output. - Catching bugs and style issues. - Iterating on the prompt. What AI does: - Generates substantial code (functions, classes, modules). - Edits multi-file via agent mode. - Runs tests; iterates. Pace: AI's pace (faster). You review afterward. ## When to drive - **Novel work**: nobody's done this before; AI guesses generic patterns. - **Algorithmic / mathy**: subtle bugs in AI output here. - **Domain expertise required**: AI doesn't know your business rules. - **Learning**: you grow by writing; pure review = passive. - **High-stakes code**: security, payments — write carefully. ## When to review - **Boilerplate**: CRUD, scaffolding, config — AI nails this. - **Translation**: language A → B; framework X → Y. - **Test writing**: AI generates good tests from a clear description. - **Refactoring**: with explicit constraints. - **Documentation**: AI's strength. - **Repetitive work**: dozens of similar files; agent mode shines. ## The rhythm A typical session shifts: ``` 9:00 - Drive: think about the new feature's design 9:15 - Review: scaffold endpoints + models with AI 9:30 - Drive: write the complex business logic 9:45 - Review: have AI write tests 10:00 - Drive: investigate a tricky bug 10:15 - Review: AI suggests fix; you verify ``` Conscious switching. Each block ~15-30 min. ## Anti-pattern: 100% drive Type everything yourself, ignore AI. Lose the productivity gains. You're paying for tools (or your company is) that you're not using. The boilerplate that AI could handle in 30 seconds takes you 10 minutes. ## Anti-pattern: 100% review Let AI do everything, accept whatever it generates. Problems: - You don't understand the code (can't debug later). - Bugs slip through. - You stop growing as an engineer. - AI hallucinations cause real outages. The balance is the skill. ## Switching cues When to switch from drive → review: - "This is going to be 200 lines of CRUD." - "I've done this pattern before; I just need it written." - "I want to try multiple approaches quickly." - "Tests for this code." When to switch from review → drive: - "AI is giving me generic output that doesn't fit." - "I'm rejecting most suggestions." - "I don't understand what AI is producing." - "The problem requires careful thought." If you notice you're stuck in one mode: switch deliberately. ## The "AI suggests, you verify" loop The core pattern when in Review mode: ``` 1. You: prompt with spec 2. AI: generates code 3. You: read carefully 4. You: spot issue → refine prompt OR fix manually 5. AI: regenerates 6. Loop until correct ``` Don't paste-and-commit. Read, verify, iterate. ## Effective prompts mid-session You already have context (files in editor, prior chat). Don't repeat: Bad: > "I'm working on a FastAPI app. I have models for User and Post. I want to add..." Good (when you've discussed it): > "Add a tags table; many-to-many with posts. Follow the existing model style." AI sees the conversation. Be brief. ## Knowing when to commit After each meaningful unit of work: - AI generated; you reviewed; tests pass. - Commit it. Move on. Don't accumulate many AI changes without commits. Smaller commits = easier review later AND ability to roll back. ## Reading vs skimming Active reading of AI code: - Does this function actually do what I asked? - Are the names right? - Are the imports correct? - Are edge cases handled? - Does it match my codebase's style? Passive skimming: - "Looks roughly right." The first catches bugs. The second misses them. Slow down for review especially when stakes are high. ## Conversation hygiene For chat-based interactions: ### Start fresh for new tasks Old context confuses AI. New task = new chat (or `/clear` in Claude Code). ### Summarize at key junctures "OK, so we've decided to use X with Y configuration. Now let's implement the Z module." ### Course-correct early If AI is going wrong, redirect immediately: > "Stop. The approach is wrong. We need X, not Y. Start over." Better than letting it produce 200 lines of incorrect work. ## When AI gets stuck If AI keeps producing wrong output: 1. **Provide more context**: maybe it's missing info. 2. **Try a different angle**: rephrase the problem. 3. **Switch to drive**: take over; AI joins when you have specifics. 4. **Try a d