Your New Pair Programmer Never Takes Sick Days

Let's be honest about what AI coding tools felt like two years ago: party tricks. You'd show a colleague how GitHub Copilot auto-completed a function, they'd say "huh, neat," and then you'd both go back to writing code manually because the suggestions were just slightly wrong enough to not trust.

Something has shifted. The "slightly wrong" has become "mostly right, occasionally brilliant," and the way senior developers talk about their tools has changed. Not "look at this trick" — more like "I don't really write boilerplate anymore."

This is worth taking seriously, because it changes what a good day's work looks like.

The Boilerplate Problem Is Solved

Every codebase has sections that aren't hard — they're just tedious. CRUD endpoints. Data transfer objects. Test scaffolding. Type definitions from a JSON blob. Migration files that follow an obvious pattern.

AI handles these extremely well. Not because it's smart, but because it's seen ten thousand versions of them and knows the shape. You describe what you want, it produces a first draft, you review and adjust. The job of reading critically and spotting the subtle wrong turn is still yours — and it turns out that's the part that required your brain all along.

The speed difference on boilerplate tasks is real and significant. What used to take an hour takes fifteen minutes. That's not a rounding error; it's a completely different relationship to the workday.

The Surprising Part: Understanding Code You Didn't Write

The use case that's flown under the radar is using AI to understand existing code rather than write new code.

You've inherited a 3,000-line service. You need to add a feature. The function you're looking at has no comments, the variable names are aggressive abbreviations, and the original author left the company in 2021.

Paste it in. Ask: "What does this do? What are the edge cases? What would break if I changed the return type here?" You get a structured explanation in seconds that used to require either careful reading (time) or finding someone who remembered (luck).

This is quiet, unglamorous, and enormously useful. The ROI on understanding code before changing it is enormous — most production incidents trace back to a change made without fully understanding the context it was entering.

What AI Is Still Bad At

It's worth being concrete here, because the hype is not always honest.

AI coding assistants don't have memory of your project. Every conversation starts cold unless you give it context. They don't know your conventions, your team's unwritten rules, the reason that weird abstraction exists, or the history of the decision you're revisiting. You have to tell them, every time.

They also hallucinate with confidence. An AI will tell you a function exists in a library that it doesn't, cite a documentation page that isn't there, and suggest an API that was deprecated two years ago — all in the same fluent, authoritative tone it uses when it's completely correct. You still need to verify. The tool has not made code review optional.

Architecture is also still very much a human job. Deciding what to build, how the pieces fit together, what the system needs to be in five years, what trade-offs to make — these require context, judgment, and accountability that AI doesn't have. AI is excellent at filling in a blueprint; it is not good at drawing one.

The Mental Model Shift

The developers getting the most out of AI tools seem to share a mental model: they are the architect and the reviewer, and the AI is a very fast, very well-read junior developer who needs supervision.

A junior developer is genuinely useful. They can do real work. But you don't give them a task and walk away — you check their work, correct their misunderstandings, provide the context they're missing. The collaboration produces better output than either of you alone, and over time, working through problems with them sharpens your own thinking.

The analogy is imperfect — a junior developer learns permanently, and the AI resets every session. But the working relationship looks similar: describe clearly, review carefully, ask follow-up questions, maintain responsibility for what ships.

What This Means for Learning

There's a legitimate concern worth taking seriously: if AI writes the boilerplate, do junior developers still learn the fundamentals?

The honest answer is: not automatically, and that's a real problem. A developer who's never written a database query from scratch, never wrestled with pointer arithmetic, never built a data structure by hand — they have gaps in their mental model that will eventually cause problems. The fundamentals aren't boilerplate. They're load-bearing.

The flip side is that the ceiling for what a single developer can build solo has risen dramatically. A one-person team with good judgment and AI tools can produce what previously required a team. For independent developers, for small companies, for people working on personal projects — that's genuinely exciting.

The right response to AI tools is not fear and not uncritical enthusiasm. It's something more like: understand what they're actually good at, use them there, and invest in the skills they can't replace. Judgment. Context. Architecture. Understanding why.

The pair programmer that never takes sick days is genuinely useful. It's just not a replacement for the human at the keyboard.