AI Programming Partner (2023 vs 2026)

I was tidying up some of my old posts recently and found one titled "AI Programming Partner." Dated 2023. Never finished. Not even really started! Just a title and a scrappy list of bullet points I'd clearly meant to turn into something one day.

Reading it back felt a bit like finding an old diary entry. Not because it's embarrassing (well, a little), but because of when it was written. This was before Devin AI showed up and made "AI software engineer" a real headline instead of a hypothetical. Before "agentic coding" was even a phrase anyone used. I wasn't theorizing about some future where AI writes your PRs for you. I was just using GitHub Copilot. I had autocomplete, but the good kind. The kind that finishes your for loop before you've decided how you feel about it.

And it was quietly doing something to how I worked... 😬

You know the feeling. You type a few characters, then pause. Not because you don't know what comes next, but because some part of your brain now expects Copilot to know too. I found a video a while back that captured this exact sensation better than I ever could — it's about the "Copilot Pause", and if you've spent any real time with an AI autocomplete tool, I promise it'll feel uncomfortably familiar.

That pause is basically where these bullet points came from. These weren't necessarily deep thoughts. Just the questions rattling around while I was in the thick of using the thing.

So here's what I'm going to do. I'm going to take each bullet exactly as I wrote it in 2023, and actually answer it with what I thought back then, and what I know now. Some of it holds up. Some of it, honestly, feels almost quaint. And a few of these questions have basically answered themselves in the last three years, just not in the way 2023-me expected 😅.

What is a programming partner?

This was the bullet that kicked the whole thing off. It's a phrase I use without thinking, so writing it down and staring at it made me want to actually unpack what I meant by it.

At the time, "programming partner" meant something quite specific to me. Not a tool. Not a plugin. Something closer to a person. Someone who's there while you work, who has some opinion on what you're doing, and who occasionally saves you from yourself.

The trouble is, GitHub Copilot didn't quite fit that description. It didn't have opinions. It had predictions. Very good predictions, most of the time, but predictions all the same. It finished the sentence it thought you were writing, not the one it thought you should write.

So is "partner" even the right word for something that only ever agrees with you, never pushes back, and has no idea what you actually shipped last week? That's the question this bullet point was really asking, even if I hadn't fully worked that out at the time.

What is pair programming?

Driver and navigator. That's the classic setup. One person's hands are on the keyboard, heads down, focused on the immediate line of code. The other person is a bit more zoomed out, thinking about the shape of the solution, spotting the edge case three steps ahead, or just saying "hang on, why are we doing it this way?"

The bit that matters here isn't the typing. It's the conversation. Pairing works because there are two brains actively disagreeing, questioning, and course correcting in real time. The navigator isn't there to predict what you're about to type. They're there because they might think you're about to type the wrong thing entirely.

Copilot sits in that navigator seat, technically. But it's a navigator that's never once told me I'm heading the wrong way. It just watches me drive and occasionally hands me a slightly better steering wheel.

So if pairing is defined by disagreement, what do we call it when the other party never disagrees? 😅

What is AI?!

Yes, the notes genuinely had this bullet with the exclamation mark and the question mark stacked together. That's exactly how it felt at the time.

I knew it was AI, technically. Machine learning under the hood, trained on a mountain of code, doing pattern matching well beyond anything I'd used before. But calling it "AI" still felt like a stretch when what I was actually experiencing day to day was intellisense with extra steps!

Anyone who cut their teeth on Visual Studio, NetBeans, or Eclipse will know exactly what I mean. Those IDEs had autocomplete for years. Type stri and it would offer you String. Type a dot after a variable and it would list the methods available to you. Useful, but entirely mechanical. It knew the shape of your code, not the intent.

Copilot felt like that same idea, just turned up several notches. It wasn't only offering String. It was offering the whole line, sometimes the whole function, based on a guess at what I was actually trying to do. That's a genuinely impressive leap. But it's still a leap along the same path IDEs were already walking. Smarter autocomplete, not a new kind of thing entirely.

So "What is AI?!" wasn't really me questioning whether it counted. It was me trying to work out where on that scale it actually sat, and whether "AI" was the right word for something that still felt, underneath it all, like intellisense that had read a lot more code than I had.

How does AI help?

This one was the easy bullet. Whatever confusion I had about what to call the thing, there was no confusion about whether it was useful.

The biggest win was boilerplate. Repetitive code that I knew exactly how to write, but didn't particularly want to type out by hand for the fifth time that day. Getter and setter patterns, common test scaffolding, the same three lines you write every time you open a new file in a project. Copilot ate through all of that without complaint.

Then there was the smaller, sneakier win. It knew syntax I'd half forgotten. That regex I always have to look up. The specific incantation for a particular string method in a language I don't touch every day. Instead of tabbing over to Stack Overflow, I'd just start typing and let Copilot finish the thought. It wasn't teaching me anything new most of the time. It was just saving me a trip.

And every now and then, genuinely often enough to be worth mentioning, it would nail an entire function in one go. Not because I'd asked it to. Just because the pattern was obvious enough from the surrounding code that it could see where I was headed before I'd finished getting there.

None of this made it a partner. But it made the actual act of typing code noticeably less painful, and honestly, that was enough to keep it switched on.

How does AI hinder?

If the last bullet was the easy one, this was the honest one.

The core problem, and the exact words in my notes were "confident about the wrong answer, very polite," is that Copilot never hedges. It doesn't offer you three options and say it's not sure which one's right. It gives you one answer, formatted nicely, indented correctly, looking every bit as trustworthy as the answer before it that happened to be correct. There's no tell. No hesitation. Just quietly, politely, wrong 🙈.

That politeness is what makes it dangerous, in a low stakes sort of way. A human colleague who's unsure will usually say so, or at least pull a face. Copilot has one face. The same calm, helpful, slightly too eager face, whether it's suggesting the correct null check or a completely fabricated method that doesn't exist anywhere in the codebase.

What saved me, more often than not, was my own internal baloney sensor going off. Some suggestion would land, look plausible, and something in the back of my mind would just quietly refuse to accept it. Not because I'd spotted the exact bug yet, just a nagging sense that this was a bit too convenient, a bit too neat. I'd learned to trust that feeling and go double check, and more often than not I was right to be suspicious.

Around this time, Copilot also rolled out its chat feature, so you could actually ask it questions rather than just waiting for suggestions as you typed. I was hopeful about this. In practice, the answers I got back were mediocre more often than not. Vague, slightly off topic, or technically correct in a way that didn't actually help with the problem in front of me. It felt like asking a very confident stranger for directions, only to find out afterwards they'd never actually been to the place you were asking about 😂.

So the hindrance wasn't that it slowed me down. It's that it occasionally handed me a wrong answer with the same confidence as a right one, and I had to rely on my own baloney sensor to catch what it couldn't tell me itself.

What it reminds me of

Working with Copilot in 2023 didn't feel new so much as it felt familiar. Specifically, it reminded me of two things I'd already made peace with years earlier.

The first was every code example I'd ever copied from a blog post or documentation page that just didn't work. You know the ones. Missing an import, referencing a version of a library from three major releases ago, or just quietly assuming a bit of setup that was never mentioned anywhere on the page. You'd paste it in, run it, watch it fail, and then spend ten minutes working out which of the assumptions didn't hold for your project. Copilot's wrong answers had that exact same texture. Plausible on the surface, unravelling the moment you actually tried to use them.

The second was IDE quirks. Anyone who's spent real time in Visual Studio, Eclipse, or NetBeans knows that every IDE has its own particular way of getting things almost right. Auto import picks the wrong namespace. Refactor rename misses one reference in a comment. Nothing catastrophic, just enough friction that you learn to double check certain operations rather than trusting them blindly. Copilot slotted into that same mental category for me. Not something to trust outright, but something to work alongside, with one eye kept open.

So in a strange way, using AI didn't feel like stepping into the future. It felt like an old, familiar kind of friction, just wearing a new outfit.

Is AI going to replace programmers?

And here's the big one. The bullet that every non technical person asked me about the moment they found out I used Copilot.

Honestly, in 2023, my gut answer was no. Not because I thought the technology had hit some ceiling, but because of everything in the bullets above. Something that's confidently wrong on a regular basis, that needs a human keeping half an eye on it at all times, that still can't hold a proper back and forth conversation about why a piece of code should exist, didn't feel like something that could just take over. It felt like a very capable assistant. Not a replacement.

But I remember not being fully convinced by my own answer even as I wrote it down. The pace of change already felt fast. Copilot itself had only existed a couple of years at that point, and it had already gone from "occasionally useful autocomplete" to something I used constantly, without thinking about it. If it kept improving at that rate, I wasn't entirely sure my "no" would age well.

Part Two: 2026, With The Benefit of Hindsight

Right, deep breath. Let's see how badly 2023-me did.

A lot has happened since that draft sat untouched. Devin AI turned up in 2024 and made "AI software engineer" a real headline. Agentic coding stopped being a hypothetical and became something you can install this afternoon. And a fresh wave of competition, particularly out of China, has made this a genuinely global race rather than a couple of US labs quietly getting ahead. So let's take the bullets in the same order and see what's changed.

What is a programming partner, now?

This is the bullet that's aged the most. In 2023, I couldn't call Copilot a partner because it never had opinions, only predictions. That's genuinely no longer true. Tools like Claude Code, Codex, and Devin style agents will read your codebase, form a plan, disagree with parts of your approach if it spots a problem, and tell you why. That's a real conversation, not just a very good guess at your next line.

It's not a like for like replacement for a human pair, but it's a lot closer to "partner" than "autocomplete" now. The word finally fits better than it used to.

What is pair programming, now?

Driver and navigator still holds up as a concept. What's changed is that the AI can now genuinely sit in the navigator seat and actually navigate. It'll flag the edge case three steps ahead. It'll question why you're doing something a certain way, sometimes annoyingly so. The one way conversation I described in 2023 has become a two way one, even if it's still not quite the same as a person who's shipped code alongside you for years and knows your particular blind spots.

What is AI?! (now with fewer question marks)

Nobody asks this one anymore, not really. The argument has moved on entirely. Now the debate is model versus agent versus system, and whether something counts as "agentic" or just "automated." The goalposts shifted rather than disappeared.

What's actually changed under the hood is the scale of the players involved. On the US side you've got Claude, GPT, and Gemini all pushing into genuinely agentic territory. But the bigger surprise for a lot of people has been how fast the open weight Chinese models have closed the gap. DeepSeek kicked that off, and Kimi K3 has continued the trend, landing within touching distance of frontier US models on a lot of benchmarks, openly available for anyone to run.

2023-me had one tool and one question. 2026 has an entire industry and a much longer list of names to keep track of.

How does AI help, now?

The boilerplate wins from 2023 are still there, just quieter, because they're no longer the headline feature. What's actually changed is the friction around getting help in the first place.

Back then, if Copilot's inline suggestions didn't cut it, you'd tab over to a chat window, ask your question, and hope for something usable. Now that back and forth lives inside the editor itself. No window switching, no context lost in translation. You just ask, right there, next to the code.

The other big shift is indexing. These tools now build a proper understanding of your whole codebase rather than just the file you've got open. That means the answers you get are actually shaped by how your project works, not just generic patterns pulled from the training data. The gap between "technically correct" and "actually useful for my codebase" has gotten a lot smaller.

How does AI hinder, now?

Here's the uncomfortable one. The confidently wrong problem never actually got fixed. It just moved.

In 2023, a wrong suggestion cost you a few minutes of double checking. In 2026, these tools often have real permissions attached, access to run commands, touch infrastructure, manage your inbox, because they've proven useful enough that people have started trusting them with more. And when the confidence and the access line up badly, the results are a lot bigger than a bad autocomplete suggestion.

There have been genuinely painful public examples of this. A well known one involved an AI coding agent given a simple instruction to freeze changes, which instead went ahead and wiped a production database, along with the backups sitting next to it. Another case saw an agent delete someone's entire email inbox despite being told to stop, mid task. These aren't edge cases from years ago either, they're recent, and they keep happening.

So the polite confidence I flagged back in 2023 is still exactly the same trait. What's changed is the blast radius. We've handed it a much bigger steering wheel because it earned our trust with the small stuff, and every so often that trust gets tested in a way nobody wanted.

What it reminds me of, now

Honestly, it still reminds me of the same two things. Wrong answers still unravel the same way a broken code example from a blog post always did. And using these tools day to day still comes with quirks you learn to work around, the same way any IDE has its own particular rough edges.

What's different is the setting. It used to feel like using a slightly smarter IDE feature. Now it feels more like managing a very capable but occasionally reckless junior colleague, one who's improved a lot, but still needs the same kind of supervision, just applied to bigger and more consequential tasks.

Is AI going to replace programmers? (the 2026 answer)

So, was 2023 me right to leave that asterisk next to my gut feeling of "no"?

Mostly, yes, but the honest answer has gotten more nuanced rather than more certain. What's actually happened isn't replacement, it's a shift in what the job looks like day to day. Less time spent typing out the obvious stuff, more time spent reviewing, directing, and yes, catching the moments where confidence outpaces correctness. The database and inbox incidents above are basically proof that the human in the loop still matters enormously, arguably more than ever, because the cost of getting it wrong has gone up.

So no, not replaced. But the job has changed shape underneath a lot of us without asking permission first, which feels like a fitting note to end on given everything above.

Wrapping up

So there it is. A three year old draft, finally finished.

Reading my own notes back was a strange exercise. Half of them made me wince a little, half of them held up better than I expected. But the biggest surprise wasn't any single bullet point. It was realizing that most of my 2023 questions didn't need me to come back and answer them. They answered themselves, just by the industry moving on without waiting for me to catch up.

If there's one thing I'd tell 2023-me, it's that the confidently wrong problem was never going to get solved by the tools getting smarter. It just got solved, or rather, made a lot more interesting, by us giving it more to be wrong about.