Pairing and Collaboration

How to pair. Working with AI.

Why Pair

Two people. One problem. One keyboard.

Pairing isn't about typing faster. It's about thinking together. Two brains catching errors one brain would miss. Shared context that doesn't need to be communicated later. Knowledge that doesn't live in one head.

Done well, pairing produces better code faster with fewer bugs and shared understanding. Done poorly, it's two people doing one person's work at half the speed.

The difference is how you do it.

Pairing With Humans

The mechanics are well documented: one drives, one navigates and thinks ahead, you swap often and think out loud.^[1] What actually decides whether a session works is engagement. The navigator suggests instead of dictating, the driver explains instead of just typing, and silence means someone has checked out.

Pair when the problem is complex, the decision is load-bearing, someone is stuck, or knowledge needs to move between heads. Solo when the task is well defined and what it needs is depth, or when you're too drained to be present. And when a pair isn't working — pace mismatch, keyboard hogging, a dynamic that isn't clicking — say so. Suffering in silence is the only unrecoverable pairing mistake.

Working With AI

I used to say AI is a junior pair programmer. That undersells what changed and hides what didn't.

What changed: drafts got cheap. Code, plans, tests, documentation, alternatives, explanations, all of it keeps getting cheaper to produce. What did not change: judgment stayed expensive. Framing the problem, choosing the boundary, recognizing plausible wrongness, integrating into a system with history, owning the consequences. This is the frame I work from now, and I keep re-testing it as the tools improve.

What Got Cheap, What Did Not

AI can:

• Generate code quickly
• Explain concepts
• Suggest approaches
• Find bugs
• Do tedious tasks

AI cannot:

• Guarantee correctness
• Reliably infer the requirements you have not stated
• Take responsibility for what ships
• Replace your judgment

The more the first list accelerates, the more your value concentrates in the second. The ability to generate more code increases the value of knowing which code should exist.

The Principle

AI assists privately. What lands in shared spaces (PRs, Slack, docs) should be unmistakably yours.

• Your voice
• Your judgment
• Your standards

If you can't defend it, don't ship it. "The AI wrote it" is not an excuse.

Your organization may have stricter norms: requiring disclosure in PRs, prohibiting AI for certain work, or mandating review of AI-generated content. When in doubt, check your team's policy.

The Baseline

These practices protect you and your team:

Don't paste into AI:

• Secrets, credentials, API keys
• Customer data or PII
• Proprietary code you don't own
• Anything covered by NDA

Be able to:

• Explain any code you ship (line by line if asked)
• Debug it without AI assistance
• Modify it confidently
• Defend the design decisions

Consider disclosing (especially if your team asks):

• AI-generated code that made it to production
• AI-assisted design decisions
• AI-generated documentation

Review Everything

AI makes confident mistakes. It will generate code that looks right but isn't. It will miss edge cases. It will misunderstand requirements. Use it for first drafts, exploration, tedium, and explanation; hold everything it produces to the same standards as your own hands, because the standards don't know who typed.

You own the why on every decision you ship. For anything the AI drafted, you should still be able to answer: Why this boundary? Why this schema? Why this test? What happens when it fails? How do we know it works? How do we reverse it? What did the model assume?

One limit keeps this honest. Requiring understanding is not the same as requiring manual authorship of every artifact. The goal is ownership, not ritualized inefficiency.

The Crutch Warning

AI can become a crutch. You ask it to solve problems instead of solving them yourself. You stop thinking and start prompting.

Watch for:

• Not understanding the code you're shipping
• Struggling without AI access
• Skills atrophying
• Losing the ability to debug AI-generated code

AI should accelerate you, not replace your thinking. If you're not growing as an engineer, something's wrong.

The Core Discipline

Whether pairing with humans or AI:

Stay engaged. Be present. Contribute.

Think out loud. Share your reasoning. Listen to theirs.

Review everything. Don't ship what you don't understand.

Own the output. Your name is on it. Take responsibility.

Collaboration multiplies capability. But only if you do it well.

Two heads are better than one if both are actually thinking. Pair with intention. AI is a tool, not a replacement. You're responsible for what ships.