For me it has stopped mattering who wrote the code. What matters is whether it works and whether it is any good, and that question has the same answer regardless of whether I typed every character or an AI produced it from a prompt I wrote. The authorship is a detail. The result is the thing.
What does not change is responsibility. If the AI ships something broken, that is on me, because I set it loose, I reviewed its work, and I put my name on the commit. I have never found that uncomfortable. It is the same deal I would have if I had a junior developer on my team: I delegate the work, but I still own the outcome. Once you internalize that, AI stops feeling like a stranger wandering through your codebase and starts feeling like part of how you build.
I was in denial too
Plenty of developers are still quietly convinced that AI is a toy, or a threat, or both. I am not going to lecture them, because I sat in that exact chair. I stayed skeptical until GPT-4o arrived in May 2024 and I watched it do something I had assumed was years away. That was the moment the resistance broke and curiosity took over.
The complaint I hear most is some version of “I tried it and the code was bad.” Sometimes that is fair. But far more often the real culprit is the instruction behind it. Blaming the model for a vague prompt is like blaming a new hire for a task you never properly explained.
Prompting is a managerial skill
Here is the part that matters most. Being good at writing code and being good at getting results out of an AI are not the same skill, and being excellent at the first does nothing to guarantee the second.
Think about what happens when a brilliant engineer becomes a manager for the first time. All that hard-won technical talent suddenly counts for less, because the job is no longer to solve the problem yourself. It is to describe the problem clearly, hand it off, set the constraints, and trust someone else to carry it. Some of the best coders make miserable managers, precisely because they cannot stop reaching for the keyboard.
Prompting is that managerial skill wearing different clothes. You explain the outcome you want, you spell out the rules the work has to respect, and you let the agent do the moving. The developers who dismiss AI are often measuring it against the one skill they already have, writing code, and missing that the real leverage lives in the skill many of them have never deliberately practiced: directing someone else toward a result.
Treat it like a junior developer
The mental model that has served me best is to treat the AI exactly like a promising junior.
When you give a good junior a task, you do not dictate every keystroke. You tell them what success looks like, you give them the context they genuinely need and nothing more, and you deliberately leave room for them to work some things out, because that struggle is where the good decisions get made. You describe the destination and trust them to find a sensible route.
A good junior also asks questions. When the task is ambiguous or the requirements contradict each other, you want them to come back and check rather than quietly build the wrong thing for two days. AI is the same, and you can ask it for the same behavior: tell it to question anything unclear before it starts, and it will surface the gaps in your own thinking that you did not know were there. Some of my best prompts are the ones where the agent asked me three sharp questions and I realized I had not actually decided what I wanted yet.
Beyond that, AI responds to the same treatment as a junior. Describe the result you want and, crucially, the reason behind it. The “why” does more work than people expect, because the moment the agent understands your intent it can make reasonable choices in all the little situations you forgot to mention. Skip the why and it is flying blind the instant reality diverges from your script.
And like any junior, it gets dramatically better when it can check its own work. Give it the tools to verify what it built: a test suite it can run, a browser it can open, a screenshot it can study, a type checker that will catch it when it lies to itself. Without a feedback loop, an AI is guessing and hoping. With one, it catches its own mistakes before they ever reach you, and the quality climbs accordingly.
The bike and the car
Here is the analogy I keep coming back to, and it is probably no accident that I landed on this one. I am Dutch, and the Netherlands is a bike country in its bones. We learn to ride as small children, there are more bikes than people, and for most short trips nobody even thinks about a car. So when I went looking for a way to understand a tool that carries you much further and much faster, the contrast that surfaced was the one every Dutch person feels in their legs: the bike you grew up on, and the car you reach for when the journey gets long.
A human coder is a bike. Every meter comes from your own effort, which is exactly what makes a bike so good. You feel the road through the handlebars, you can thread through an alley a car would never fit down, you stop on a coin, and you reach the doorstep no road leads to. That intimacy and precision is the whole point. But it has a cost. A bike is slow across distance, it tires you out, and asking it to cover a hundred kilometers of open highway is asking the wrong machine to do the job. Push a bike too far and the very thing that made it nimble becomes its limitation.
AI is a car. The power does not come from your legs anymore, so suddenly distance is cheap and broad ground that would have exhausted you on a bike disappears under the wheels. That is the gift: enormous reach for very little personal effort. But a car asks for things a bike never did. It needs roads, and in our world those roads are your specs and your architecture. It needs guardrails, and those are your tests and your reviews. Take that infrastructure away and a fast car becomes a hazard, because speed without a road just means you reach the ditch sooner. And for all its range, a car is clumsy where a bike is graceful. There are narrow paths it simply cannot take, places where the right move is to park it and pedal the last stretch yourself.
So the real skill is reading the terrain. Taking the car down a footpath where only a bike fits is foolish, and so is grinding out a long straight highway on a bike out of sheer stubbornness. The two are not rivals. They cover different ground, and a developer who can switch between them goes places neither could reach alone.
There is one more difference, and it is the one that convinced me to lean on the car for the big journeys. On a bike, a wrong turn is expensive. Twenty-five kilometers in the wrong direction can swallow your afternoon, because every kilometer back has to be paid for in sweat. In a car the same mistake barely registers. You notice, you turn around, and a few minutes later you are back on course as if nothing happened. AI works the same way. It will sometimes take a wrong turn or build the thing you did not ask for, but correcting it is fast and cheap. You point it back at the destination and carry on. That asymmetry, where mistakes on the car cost almost nothing to undo, is exactly why it is worth trusting on the broad, ambitious problems even though it is not perfect.
Through all of this, you are still the driver. The car has tremendous power and absolutely no idea where you want to go. You choose the destination, you hold the wheel, you watch the road. When you put down the bike, the craft simply moves into the driver’s seat.
Is any of this making money?
The last objection usually arrives dressed up as the clincher: “these AI companies do not even turn a profit, so the whole thing is going to collapse.” It is worth being precise here, because the picture is shifting under that argument’s feet. In mid 2026 Anthropic reported its first quarter of operating profit, somewhere around 559 million dollars, carried by genuinely explosive revenue growth.
I want to be honest about what that does and does not prove. It is one quarter of operating profit, not durable, company-wide net profitability, and Anthropic itself has said it may not stay in the black for the full year because it is spending hard to keep growing. So this is not a victory lap. But a trend line is a trend line, and this one is bending unmistakably in one direction. Betting that this technology quietly disappears is, at this point, a genuinely bad bet. The sensible move is to plan for it sticking around, because it is going to. And even if the top-tier cloud models somehow priced themselves out of reach tomorrow, local LLMs are getting better and cheaper to run every month. The capability is not going back in the box.
Get in the car
So this is my nudge, from one engineer to another. Step out of the denial phase. You do not have to throw away your craft to do it, and you should not want to. Keep your taste, keep caring about quality, keep your bike for the streets where nothing beats it.
Just get in the car too. Then learn to drive it: describe a destination, set the guardrails, and let the engine do the distance while you steer. Do that and you will get further, faster, than the bike alone was ever going to take you.