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

Different tasks benefit from different modes. The three modes below provide a practical starting toolkit; adapt them to the risk and evidence required by the task.

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 is not "ask once, get answer." It is a loop of generation, testing, review, and refinement, with a stopping condition based on acceptance criteria.

A feature may need several iterations before it is ready for review or release. Later cycles can fix bugs, add edge cases, improve types, and refine the design. The number and duration of those cycles depend on the task and the quality gates involved.

Work in Small Steps

A common mistake is to combine several dependent decisions in one request without defining interfaces or checks.

Build me a complete family

planner app with authentication,

database, real-time sync, and

a calendar view.

A focused task is easier to review. Large requests create more interacting assumptions; smaller coherent steps reduce that risk, provided you keep the relevant system context visible.

Ask for a Plan and Rationale

Before asking for code, ask for a concise plan, assumptions, and trade-offs. This can expose a weak design early and gives you something concrete to review.

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 the model states a plan, assumptions, and trade-offs, you can evaluate the approach before evaluating the code. Catching a flawed direction at this point can reduce later rework.

When AI Gets It Wrong

AI-generated code can be wrong even when it looks plausible. Plan checks for failure modes such as:

• 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

AI can help you navigate documentation by explaining terminology or suggesting what to look up. Treat the answer as a starting point, then verify version-sensitive APIs and behavior in the official documentation.

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.

Follow-up questions can help you identify the relevant concept or documentation section. For a question such as whether useMemo helps when filtering 500 activities, verify the current React guidance and measure the actual component before applying the suggestion.

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:

• Share relevant, permitted context — A sanitized excerpt, interface, failing test, or minimal reproduction is often more useful than a verbal summary. Do not send secrets, personal data, private logs, or code you are not permitted to disclose.
• 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.

Related Guides