AI as a Pair Programmer

What Is Pair Programming?

Traditional pair programming involves two developers working at one machine. One plays the Driver — hands on keyboard, writing code. The other plays the Navigator — thinking strategically, spotting issues, and guiding direction. They swap roles regularly.

When you program with AI, the dynamic is similar but the roles shift:

The key insight is that AI doesn't write all the code for you. It means you collaborate — you think, AI generates, you evaluate, AI refines. The quality of output depends directly on the quality of your guidance.

Three Effective Working Modes

Skilled developers don't use AI the same way every time. They switch between distinct modes depending on what the task demands. Mastering these three modes gives you a flexible toolkit for any situation.

Give me three different approaches to implement
real-time activity syncing in a React family planner.

For each approach, describe:
- How it works
- Pros and cons
- When you'd choose it

Implement approach #2 — WebSocket-based syncing.

Use TypeScript and React hooks.
Create a custom useActivitySync hook that:
- Connects to ws://localhost:3001
- Handles reconnection on disconnect
- Returns { activities, isConnected, error }

Review this code as a senior React developer.

Focus on:
- Performance issues (unnecessary re-renders)
- Error handling gaps
- TypeScript type safety
- Edge cases I might have missed

Be critical. I want honest feedback, not validation.

The Iterative Loop

The core rhythm of AI pair programming isn't "ask once, get answer." It's a continuous loop of generation, testing, and refinement. This loop is the single most important pattern to internalize.

A typical feature might go through three to five iterations before it's production-ready. The first generation establishes the structure, subsequent iterations fix bugs, add edge cases, improve types, and refine the architecture. Each cycle is fast — often just a minute or two.

Work in Small Steps

This is perhaps the most common mistake beginners make with AI pair programming — and the fix is simple.

Build me a complete family
planner app with authentication,
database, real-time sync, and
a calendar view.

AI generates its best output when focused on a single, well-defined task. When you ask for too much at once, the context becomes muddled and the AI has to make assumptions about dozens of interconnected decisions simultaneously. Small steps eliminate this problem entirely.

Ask AI to Think Out Loud

One of the most underused pair programming techniques is asking AI to explain its reasoning before writing code. This serves two purposes: it helps you catch bad design decisions before they become code, and it helps you learn.

Before writing any code, describe your plan:

- What components will you create?
- How will state flow between them?
- What are the potential edge cases?
- Are there any trade-offs in your approach?

Then implement the plan.

When AI explains its reasoning, you can evaluate the approach before evaluating the code. If the plan has a flaw, you can redirect before a single line is written. This saves enormous amounts of time compared to debugging a flawed implementation.

When AI Gets It Wrong

AI will get things wrong. This isn't occasional — it's regular. Skilled pair programmers expect this and have strategies ready. The most common AI errors in code generation:

• Wrong imports — referencing packages or modules that don't exist in your project
• Incorrect API calls — using methods or parameters that don't match the actual API
• Outdated syntax — using patterns from older versions of frameworks
• Hallucinated functions — inventing methods that look plausible but don't exist
• Subtly wrong logic — code that looks correct but has off-by-one errors or wrong comparisons

AI as Instant Documentation

One of the most productive uses of AI as a pair programmer is replacing context-switching to documentation sites. Instead of leaving your editor, opening a browser, searching, finding the right page, and reading through examples — just ask.

Explain the difference between useMemo and useCallback
in React.

When should I use each one?
Give me a concrete example where using the wrong one
would cause a performance problem.

This isn't just faster than searching documentation — it's often better, because you can ask follow-up questions tailored to your specific situation. "Would useMemo help in my case where I'm filtering a list of 500 activities?" gets you a more useful answer than any generic docs page.

AI as Debug Companion

When you hit an error, AI excels at rapid diagnosis — especially when you give it proper context. Here's the pattern:

Here is my code:

[paste the relevant function or component]

Error message:
TypeError: Cannot read properties of undefined (reading 'map')
  at ActivityList (ActivityList.tsx:23:18)

What I'm trying to do:
Render a list of activities passed as props.

What happens instead:
Crashes on initial render before data loads.

What's the most likely cause?

Notice the structure: code, exact error message, intent, and observed behavior. This gives AI everything it needs for accurate diagnosis. We'll go much deeper into debugging strategies in Chapter 5.

Real-World Conversation Flow

To make this concrete, here's what an actual pair programming session looks like in practice. Notice how the developer stays in control while leveraging AI's speed.

Effective Communication Patterns

Over time, certain communication patterns consistently produce better results when pair programming with AI. These are worth making habitual:

• Always share code context — Don't describe your code verbally when you can paste it. AI interprets actual code far more accurately than descriptions of code.
• Include error messages verbatim — Copy the full error, including stack traces. Don't paraphrase or summarize errors.
• State your intent explicitly — "I'm trying to make this component re-render only when the activity list changes" is far more useful than "this re-renders too much."
• Ask for alternatives — When you're unsure about an approach, ask for two or three options with trade-offs rather than a single solution.
• Give feedback on outputs — "This works but the naming is confusing" or "The approach is right but add error handling" helps AI learn what you need within the session.