Pair Programmer

Prevent skill atrophy while coding with AI through structured collaboration.

The Problem

AI code generation creates deceptive productivity. You ship features faster while your problem-solving muscles atrophy. As MIT professor Roberto Rigobon warns about AI dependency: "When we stop using our brains... we forget."

"Vibe coding" - passively accepting AI-generated code - feels productive but degrades the skills that make you valuable: debugging, architecture decisions, performance intuition, and deep understanding of your codebase.

The Solution

A graduated assistance framework that maintains cognitive load while leveraging AI as a force multiplier. Think of it as weight training: you need resistance to build strength.

Four Levels of Assistance

Level 1: Pure Architecture

AI advises, you code everything.

Use when learning new patterns or maintaining sharp skills.

You: "Should I use event delegation for these dynamic elements?"
AI: "Event delegation works well here because..."
You: [writes all the code]
AI: [reviews and suggests improvements]

Best for:

• Learning new technologies
• Critical algorithm implementation
• Maintaining coding skills
• Deep architectural decisions

Level 2: Scaffolding

AI provides structure, you implement logic.

AI creates interfaces, type definitions, file structure. You write the actual logic and business rules.

AI: [generates class skeleton with method signatures]
You: [implements method bodies]

Best for:

• New feature development
• Refactoring with clear requirements
• Projects with well-defined interfaces
• When you want structure but need to understand implementation

Level 3: Pair Programming

Collaborative alternation with mandatory engagement.

Alternate function-by-function. You must modify or improve AI code before moving on - no passive copying.

You: [writes authentication function]
AI: [writes validation function]
You: [modifies AI code, then writes next function]

Best for:

• Large feature development
• Balanced learning and velocity
• Complex implementations requiring back-and-forth
• When you want to see alternative approaches

Level 4: Full Generation

AI writes complete implementations. Use sparingly.

Reserve for boilerplate, well-solved problems, or time-critical situations. Mandatory explain-back: you must explain every line before using it.

You: "Generate OAuth2 boilerplate for GitHub login"
AI: [provides complete implementation]
You: [explains back how every part works]

Best for:

• Standard boilerplate (config files, build scripts)
• Well-solved problems (date formatting, common algorithms)
• Time-critical production issues
• Code you've written 100 times before

Warning Signs of Dependency

The Agent will stop and reassess if it notices that you:

• Can't explain how AI-generated code works
• Copying code without modification
• Uncomfortable coding without AI available
• Reaching for AI before attempting yourself
• Debugging by asking AI instead of using tools
• Can't remember how to solve problems you "solved" yesterday

Active Learning Techniques

1. Explain-Back Protocol

After AI provides anything, explain it back in your own words. If you can't, you don't understand it.

2. Modification Requirement

Change something in AI code before using it - variable names, structure, approach. Forces active engagement.

3. Implementation Comparison

Code it yourself first, then compare with AI approach. Learn from differences.

4. Constraint Exercises

"Help me solve X but don't write code, only describe the approach." Forces you to do the implementation.

Session Declaration Pattern

When you launch with --agent pair-programmer:coach, the agent greets you automatically and asks for your name and assistance level. Just respond to the prompt.

If you prefer to declare upfront, or if the agent is invoked mid-session, use this pattern: