The Great Copilot Delusion

Translation of an article by PatientZero, originally from deplet.ing

Chapter 1: My Colleague, the Programmer

An empty shell of a human. He resembles a parrot more than a person. My boss, a true believer in the sacred ritual of Pair Programming, chained me to this "programmer" colleague like conjoined twins from different planets. We shared a keyboard, but not a thought process. God, how far he was from that.

"Hold on. I've got an idea. Give me the keyboard."

An idea. Sure. The way an infant gets an idea to stick a fork in a power outlet. I was nearly done with something beautiful — clean, elegant logic slicing through complexity like a knife through butter. And then he appeared — hammering the keyboard as if it owed him money, copy-pasting Frankenstein code from a StackOverflow comment written by an Uncle Bob disciple back in 2014.

Does he know what our system does? No.

Has he read the ticket? Of course not.

Does he feel confident as he recklessly mangles global state? Of course he does.

I'm refactoring. Tightening bolts, pruning component trees, harmonizing the system's chakras.

And then suddenly: "Hey, I added a useEffect that reloads everything when anything changes. Pretty cool, right?"

"Why?" I ask, blinking like a prisoner of war being filmed, trying to blink Morse code that the mission has failed.

"I fixed what was broken. It works now."

A chaotic monkey masquerading as a colleague. No tests, no profiling. No understanding of side effects or performance impact. Just blind clicking and clacking. He codes like he's smacking an old TV set trying to fix the static.

And he does this with everyone. A one-man bug orchestra. Whispering half-baked solutions into junior developers' ears like a deranged full-stack demon. He's perfectly comfortable with his own mistakes.

The system blows up. Nothing can be deployed. The UI is frozen like the vegetables in the freezer I was supposed to defrost eight years ago. And where is my beloved co-pilot?

Nowhere.

He vanished. Probably off reading about some hot new JS framework he'll try to "sell" me on next week. Meanwhile, I wander through the darkness of callback hell with a flashlight made of regrets.

The boss starts pressuring me. "Why aren't you pairing with him? He types twice as fast as you."

Of course he does. So does a cat having a seizure on a keyboard. But that doesn't mean it should be writing production code.

I keep growing. Studying infrastructure, refining my mental models, carefully choosing trade-offs. And him? He googles. He skims. He copy-pastes. Sometimes he pulls off a clever trick, half-correct and context-free. But the team ooh's and aah's like a cave tribe discovering fire.

And I became lazy. How could I not? When the system forces you to code alongside a hallucinating clown, sooner or later you stop resisting. Let him type. Let him be "productive." You approve the changes. Your brain surrenders to the noise, and you drift along.

Captain Obvious to the Rescue

Of course, I wasn't talking about a programmer. I was describing GitHub Copilot. Or Claude Codex. Or OpenAI lmnop6.5 ultra watermelon.

These aren't tools for increasing productivity or development speed. They're tools for creating the illusion of progress. Because if such a programmer — this CREATURE — showed up to your standup in human form, hammering semi-literate garbage into the codebase with no regard for architecture and vanishing after cleanup, you'd fire it before it could say a word.

But what if we slap a Microsoft marketing label on it and plug it into every developer's IDE across the organization? Now that's innovation. Science. Progress. Profit.

A real co-pilot on a commercial flight knows their aircraft and systems. They've gone through simulations, recertifications. When they speak, it's to help the pilot... They don't press a random button in the cockpit and eject immediately afterwards.

Copilot is something else entirely. It's merely the ghost of thousands of blog posts and overconfident StackOverflow answers. It whispers: "Listen, I saw something like this once. With my own eyes. So it must be good code. Let's deploy it." And when the app hits production and the landing gear won't deploy, it vanishes.

If you let a ghost fly the plane, you deserve to be consumed by the crash flames.

Chapter 2: Giving Credit Where It's Due

Let me clarify one thing before I continue incinerating this synthetic spawn of hell with all the fury of the sun: it's not all bad.

Even a brain-pickled hustler at a poker table can occasionally hit a flush. And Copilot, too, is sometimes useful.

You're young and you've never worked with C++. You stare at the syntax like it's some kind of Martian cave painting. You ask the oracle for help... Boom! There it is. Templates, smart pointers, range-based for loops... All syntactically impeccable, as if the code was extracted straight from Bjarne Stroustrup's brain and displayed on your screen.

Of course, it doesn't know the edge cases. It won't whisper: "Hey, shared_ptr can leak if you sneakily throw in raw pointers and mix them around." It won't point you to the sacred tablets where veterans debated exception guarantees. But if you already know what you need and just need the right incantation, it'll write it faster and better than most living interns — and it won't complain when you ask it to write template metaprogramming boilerplate at 3 AM.

Now suppose you're doing systems design that requires deep programming. Making critical decisions. Building infrastructure. Such things demand confidence and encyclopedic knowledge worthy of the ByteByteGo YouTube channel. You lay out your plan like a general before battle: here's the ingress, here's the queue, here's the cache invalidation policy that could kill us all.

Then you ask Copilot: "What could break here?"

Suddenly it starts listing weaknesses like an experienced security auditor. Maybe half of them are wrong or stupid. Some might be duplicates. But it brainstormed at a speed no junior could ever match, and now you have ammunition to craft a spec as if it were co-authored with Martin Kleppmann himself.

And sometimes you're just tired. Not completely brain-dead, but drained. Your brain is in "convert object to string" mode. You don't need help. You just don't want to mentally rotate a Rubik's cube made of jelly.

So you say: "Okay, I have this C# object and I need a LINQ query that groups by field X, sums Y, and filters Z."

Copilot responds like a strange little gremlin: "Done, boss."

You don't trust it and check its work line by line. But you didn't have to mentally juggle twenty method chains, and you bought time to think about the actually important tasks.

Or maybe you're reading some complex math paper written by a mad PhD mathematician who doesn't understand the limits of human sanity. You lack the energy to turn this LaTeX-riddled ancient scroll into code. Copilot steps in and gives you half-finished pseudocode. Is it garbage? Possibly. But it's garbage you can build something valuable from. You're doing performance tuning, SIMD, low-level subtleties. It just gave you scaffolding on which to stack the dynamite.

Maybe you inherited someone else's codebase. A minefield of nested closures, partially commented-out hacks, and variables named d and foo. Chaos of tangled OOP brain damage where tracking a single behavior requires traversing eighteen files. You don't have time for days of this. You need the big picture — a battlefield map — before you land and start defusing tripwires.

Ask Copilot: "What does this code do?" It doesn't all have to be pretty or give a complete picture. But it'll be enough for you to orient yourself before diving into the weeds.

Yes, credit where it's due. Copilot is like a brainless but high-functioning intern lacking practical experience:

• Great memory for syntax.
• Surprisingly fast at compiling lists of blind spots.
• Good at creating scaffolding if you spell everything out perfectly.
• Terrible at nuance.
• Useless without supervision.
• Will instantly destroy all of production if left unsupervised for even half a minute.

Now let's continue roasting it.

Chapter 3: You, the Programmer

First things first: I like writing code, not babysitting someone else doing it. I don't want to hover over a synthetic lobotomized chatbot like some intern trying to remember what std::move does. I don't enjoy being a middle manager reviewing the delirious output of a neural network made of tangled switch statements. I want to build something real and strange. Systems that burn.

"But I just use AI for boilerplate!" you'll shriek, clutching your Copilot subscription. Listen to yourself. If you write boilerplate every day like some industrial-age monkey, automate it yourself. Write a library, create a macro. Reclaim your dignity. If AI handles the "boring work" for you, then what's left for you? Dragging sliders? Painting by numbers while inference does the work?

And let's not forget the FOMO goblins. I see you. You're chugging energy drinks at 2 AM, convincing yourself you're "building the future" when you're actually CRUD-hacking some Frankenstein app from what a bot spoon-feeds you after copying syntax from a 2016 GitHub repo. It's buggy. It's ugly. You won't even look at it again until you post your video on Twitter. "But I'm moving fast!" you'll say. Sure. Straight off a cliff, like a lemming. AI doesn't help you create anything new. It simply can't. It only knows what's already been done. It's an autocomplete function with an inflated ego.

You want a real connection with code? You have to earn it. You dig into it. You fight a segfault at 3 AM. You pace around your apartment muttering about pointer arithmetic. You earn hero status yourself. You keep your own notes instead of gluing together lecture slides and pretending they mean something. When you outsource thinking, you outsource learning. You become a middleman for a mechanical bird that regurgitates digested prey into your beak. You don't know the code. You're playing with it.

Let's talk about the quality of your code too, because it's not getting better. Most developers already write bloated, abstract iceberg code that burns CPU resources like California wildfires. Clean code? Ha! You write for the praise of other programmers, not for the hardware. You forgot that the hardware matters. AI has no concept of memory locality or intuitive understanding of cache misses. It won't unroll a loop or find the buggy false sharing in your atomic structure. It was trained on code that is itself an insult to silicon.

The problem isn't just laziness. It's degradation. Developers stop exploring. Stop improving. They don't care anymore. Add another abstraction layer, another lazy load call in the render loop. Eventually you end up living in a cathedral of technical debt that every user pays for. Milliseconds and seconds, every clock cycle — a tax on your indifference. Fifty million users experience a needless three-second delay daily — a delay that could have been avoided if you'd typed instead of pressing Tab? That's nearly 5 years of wasted time combined.

Speaking of the marketing name "copilot" — a real co-pilot is your equal. A certified specialist who can land the plane if you lose consciousness. They train and practice. They go through checklists with you. GitHub Copilot is like someone who logged 200 hours in Arma 3 and now thinks they can land a Boeing 747. It read the manual. Once. In Chinese. Backwards. And now it's screaming in your ear: "Let me whip up this code real quick, I saw it in a Slashdot comment!"

In this mode, you're not working with a co-pilot. You're playing Russian roulette with a loaded dependency graph.

Want to be a real programmer? Think with your head. Respect the machine. Or get out of the cockpit.

Chapter 4: The Computer as a Machine

Listen: you're a human. Living flesh, fragile teeth, synapses firing electrical signals at each other, fueled by caffeine and frustration. But even in your chronically sleep-deprived, exhausted state, you can try. You can squint at the layers of abstraction to see through them. Peel away the beautiful, ergonomic, type-safe, clean, lazy syntactic sugar and imagine the assembly chaos the compiler spews out. You can sense cache lines with a sixth sense. You know where data wants to live. And where the silicon gets angry if you mess up.

The machine is real. The silicon is real. DRAM, L1, false sharing, the coin-flipping branch predictor. And if you care, you can work with it. You can make your program flow through memory like a steel snake, barely wasting extra resources. You can subtly plan prefetches. You can hand-craft a placement strategy that makes malloc look like child's play. You can know (actually know) when it's time to crack your knuckles and write a few lines of dirty but beautiful inline assembly to inject steroids directly into your program's glutes.

And the bot? What about the bot? It has no clue.

The bot has zero understanding. It can't tell a page fault from a maggot. It'll hallucinate a memory model the way I hallucinate after two sleepless nights. It can't profile. It won't understand a flame graph. It won't feel the burn of wasted clock cycles in a hot loop. It'll copy advice from some random passerby in a 2008 StackOverflow thread who benchmarked on a Pentium 4 with 512 MB of RAM, then make something up on its own. It'll say "This is optimal" as if it understands anything. As if it's ever seen a cache miss. It hasn't. But you have.

It will feed you garbage. It will feed you false wisdom from imaginary people and beg you to believe it. But if you want to build a beautiful, fast system that could be embedded in pacemakers and missile guidance systems, you'd better eject the bot through the airlock and start learning.

Maybe you'll never write code that keeps airplanes from falling out of the sky. Maybe you'll never manage bits that balance a human life. That's fine. Most people don't. But even if you're cranking out another CRUD app for some bloated enterprise, you still owe your users respect and their dignity.

Those users give your company money in exchange for a tool. Not a grotesque Kafkaesque nightmare that wastes their time. Not bloated, sluggish garbage that drains the life from the hardware it runs on. They're not paying you to press Tab a bunch of times.

While you burn through venture capital at a quarter million dollars a year, at least pretend you care. Pretend hard enough to profile your code. To save 200ms on rendering. Make sure your code doesn't look like the work of a modern Picasso.

This is your profession. Take pride in your life's work.

You develop taste by trying. By failing. By improving results by nanoseconds using surgical instruments. By writing a procedure on Monday, rewriting it on Tuesday, and realizing on Wednesday that it's still terrible. You don't develop taste by asking the modern version of Clippy how to do your job.

At this long stage of computing history, we're still digging in the dirt, plowing bits with plows. We're riding horses. But some of us already know how to build something new and great. Trains. Speedboats. Hypersonic jets of pure code.

And those who treat AI as if it were a divine oracle will keep trying to duct-tape horses to an engine block and wonder why they don't fly. They'll keep saying: "They still won't fly... Please fix this."

Chapter 5: Conclusion

What I hate most about AI is how easy it is to use — the slow, agonizing death of the hacker soul... Caused not by war or famine, but by convenience. Buttons and bots.

The scariest thing isn't that AI will take our jobs. That's actually appealing to people who never wanted to work in the first place. People who don't care about quality. In reality, AI broke down the last, already low barrier that at least forced people to try to understand control flow. Vampires with SaaS and Web3 dreams in their LinkedIn bios. Empty shells who see in the terminal not progress but a VC money pump. They drool over GitHub Copilot as if it's the holy spirit of productivity, churning out React CRUD. They fork VS Code over and over to sell the same dream to equally deluded newcomers.

There used to be magic here. There used to be madness.

Teenagers stayed up all night on IRC trying to render OpenGL without a segfault. They cared. They installed Gentoo on a toaster just to see if it would boot. They knew what burnt voltage regulators smelled like and could recite from memory the exact line of assembly code that made Doom run on their calculator at 10 FPS. They were artists. They coded like jazz musicians — full of fury, precision, and divine chaos.

Today we're building a world where curiosity is excised at the door. Some poor soul, born to be great, spends eight hours a day reviewing AI-generated patch sets, and all their curiosity petrifies into apathy. The terminal becomes a spreadsheet. The debugger becomes a coffin.

Because we don't know what we don't know. That's the cruelest joke. We're filling this industry with people who think they're doing great because their bot passed CI. They sail forward in total confidence while others — the ones hungry for knowledge — get chewed up by a system that no longer values understanding. Only output. Only tokens per second.

Worst of all, we're normalizing this mediocrity. Cementing it into the toolchain. Turning it into "best practices." We enshrine the modern bloated, sluggish, hellish landscape with its too-many layers of abstraction, calling it the pinnacle of software development. The very idea of building something optimal, wild, and precise — squeezing out every last drop of performance — will seem like folklore.

What if that happens? What if the last real programmers drown in a sea of button-pressing careerists? Then I'll only pity the brilliant outsiders who come after me.

If we outsource our thinking to bots, we're all doomed.