Pair Programming With an AI Assistant
TL;DR — AI pairing is good for typing speed, idiom recall, repetitive scaffolding. Bad for design discussions, code review, debugging strategy. Solo + Copilot ≠ pair programming with a human; it’s solo + better autocomplete. ChatGPT (released Nov 30, 2022) starts to bridge the gap; still not a peer.
After reviewing AI code, the workflow question. “Pair programming with AI” is a phrase people use; the reality is more nuanced.
What pair programming with a human looks like
Traditional pairing:
- Driver: types the code
- Navigator: thinks about design, catches bugs, suggests alternatives
- Roles rotate
Value:
- Two brains on one problem
- Real-time bug catching
- Knowledge transfer
- Better designs through discussion
- Less yak-shaving (someone else maintains focus)
What “pairing” with Copilot is
The driver-navigator metaphor maps poorly. With Copilot:
- You: driver, navigator, and reviewer
- Copilot: predictive autocomplete
Copilot doesn’t suggest alternatives. Doesn’t catch logical bugs. Doesn’t argue. Doesn’t ask “wait, why are we doing it this way?” It autocompletes the next likely tokens.
So “AI pair programming” is overselling. It’s solo work with a smart text expander.
That’s not bad. It’s just different from human pairing.
What changed with ChatGPT (late Nov 2022)
ChatGPT public release on Nov 30, 2022 changes the conversation. Suddenly the AI can:
- Discuss approaches in natural language
- Explain code in plain English
- Suggest alternative designs
- Be argued with
This is more like pairing. Still not a peer (no memory across sessions, no understanding of your codebase, can hallucinate confidently), but qualitatively new.
December 2022 is the inflection point. Workflow comparisons here:
| Activity | Copilot (autocomplete) | ChatGPT (chat) | Human pair |
|---|---|---|---|
| Type code faster | yes | no | no |
| Design discussion | no | yes (limited) | yes |
| Catch logical bugs | no | sometimes | yes |
| Knowledge transfer | limited | yes (limited) | yes |
| Debate alternatives | no | yes | yes |
| Real-time review | no | no | yes |
Combine: Copilot in editor + ChatGPT in another window = better than either alone.
Patterns I use in late 2022
Solo coding flow:
- Plan in head / on paper
- Open editor; write skeleton + Copilot completes
- Open ChatGPT tab when stuck or want to discuss approach
- Switch back; implement; iterate
For non-trivial design:
- Write the problem statement in ChatGPT
- Get a couple of approaches
- Decide manually (ChatGPT’s confidence ≠ correctness)
- Code with Copilot
For debugging:
- State the symptoms in ChatGPT
- Ask for possible causes
- Verify each manually
- AI sometimes suggests something I missed; usually not
For code review:
- Paste the diff in ChatGPT, ask “review this for bugs”
- Some hits; some noise
- Combine with self-review
These are workflow tweaks, not paradigm shifts. The day-to-day still requires my judgment.
Where human pairing still wins
For:
- High-stakes architecture decisions. AI suggests safe defaults; human pair can challenge assumptions.
- Debugging gnarly production issues. AI doesn’t know your infra.
- Pair learning. Someone learning Rust ownership benefits from a human explaining their actual confusion, not generic explanations.
- Codebase navigation. AI doesn’t know which files matter.
- Decision-making under pressure. “Should we ship now or block on this issue?” AI can’t make that call.
Human pairing isn’t dead. It’s complementary.
Where AI pairing wins
For:
- Solo work that would be lonely. “Rubber duck” with a slightly more useful duck.
- Mid-skill grunt work. Most refactors, most CRUD.
- Off-hours work when no humans available.
- Mass operations. “Rename this across 50 files.”
- Knowledge of arcane APIs. Half the time, faster than docs.
The “blank page” advantage
The most underrated win: starting from blank. Type a function signature; Copilot generates a draft; I edit. Blank-page anxiety reduced to near-zero.
A surprising effect: I write more often because the cost of starting is lower. Net more code shipped per week than pre-Copilot.
The honest worry
A year in, three worries:
- Skill atrophy. Am I losing the ability to write certain things from scratch? Maybe. Less obvious in production code; possibly an issue if I needed to interview elsewhere.
- Outsourced thinking. When I accept a suggestion without deep thought, I don’t internalize the pattern. Tradeoff: speed up vs deep learning.
- Codebase quality drift. If everyone on the team uses AI, code converges on AI’s preferred patterns. Some are good; some are mediocre. Cultural artifact.
None of these are reasons to stop. They’re reasons to be intentional.
What I’d tell a 2021-me
If I could send the previous-year version of myself one piece of advice about Copilot:
Don’t fight it. Don’t worship it. Use it for boilerplate; turn it off for sensitive code; review every line. Your overall throughput goes up ~25%; you have to actively maintain the parts that don’t get easier.
Common Pitfalls
Treating Copilot as a peer. It’s autocomplete++.
Skipping discussion of design just because AI hasn’t suggested an alternative. It won’t. You have to think.
Acceptance fatigue. 100 Tab presses today; mental energy depletes. Take breaks.
Pairing with both Copilot AND a human. Awkward; the human is faster than Copilot at most things in this mode.
Believing it makes you a better engineer. It doesn’t. Makes you a faster one.
Wrapping Up
AI “pair programming” is solo + good autocomplete (Copilot) + chat alternatives (ChatGPT, late 2022). Useful, not transformative on its own. Wednesday: Copilot for tests.
