I've been writing software for years and I've never seen the profession this divided: half swear there won't be a single programmer left in two years, the other half swear it's all hype. Both camps are wrong — and while they argue, the ground is shifting under everyone.
This isn't a motivational post or a list of "5 courses so you don't fall behind." It's what I see from the inside — working every day with agents that write most of my code — about what's really changing, what's losing value, what's gaining it, and what I would do today depending on where you are in your career.
First: separate signal from noise
The confusion comes from mixing up two different questions. "Can AI write code?" — yes, it has for a while now, and better than most of us on well-scoped tasks. "Can AI do an engineer's job?" — no, because the job was never writing code.
The job was always something else: understanding an ambiguous problem, deciding what to build (and what not to), negotiating constraints, noticing that the ticket asks for one thing but the business needs another, and answering for what ships. None of that has been automated. What got automated was the part in the middle: translating decisions into syntax.
💡 The sentence that keeps my head straight: AI isn't coming for your job, it's coming for your tasks. If your job was the sum of those tasks, you do have a problem. If your job was the judgment that ordered them, you just got multiplied.
What's losing value (and it hurts to say)
Let's be honest about what's already worth less in the market:
- Writing correct, clean code by hand. It was our identity. Today it's the baseline any well-directed agent produces.
- Knowing a framework by heart. Encyclopedic API knowledge used to be a competitive edge; now it's one prompt away from anyone.
- The junior who only executes tickets. This is the hardest hit and the most real one: "take this well-defined task and bring it back done" is exactly what agents do best.
- Typing speed as a productivity metric. Producing more lines no longer sets anyone apart. What does is producing fewer lines that survive longer.
What's appreciating
The opposite list is more interesting, because it's where you should invest:
- Review judgment. AI-generated code looks impeccable — formatted, sensibly named, commented. The danger lives in what looks correct. Reading code with suspicion is now worth more than writing it.
- Architecture and decomposition. An agent performs in direct proportion to how well-scoped the problem is. Slicing a system into pieces an AI can execute without breaking anything is the new senior skill.
- Business context. Understanding why something is being built is the one thing AI can't infer from your repo. The engineer who talks to product and to customers becomes impossible to replace.
- Verification. Tests, evals, observability, staging environments that resemble production. When code volume multiplies, the bottleneck moves to trust: how do I know this works?
- Accountability. Someone has to sign off on the deploy. The AI doesn't attend the postmortem. That "someone" is trading up.
The new workflow (mine, at least)
My day-to-day no longer resembles what it was three years ago. The pattern that works for me has three phases, and none of them is "writing code":
// My division of labor with agents
// 1. BEFORE — invest in context: clear specs, documented
// conventions, explicit acceptance criteria.
// 2. DURING — steer, don't dictate: the agent proposes, I cut
// scope, correct course, ask for alternatives.
// 3. AFTER — verify with hostility: read the diff as if it were
// written by someone trying to fool me, run the
// tests, poke at the edges.
The ratio surprises anyone who hasn't lived it: I spend roughly 40% of my time in phase 1. The quality of what comes out of an agent is a nearly linear function of the quality of the context that goes in. Teams that adopt AI and see no improvement almost always fail there: they delegate the writing but don't invest in the specification.
If you're just starting out: the uncomfortable advice
The entry-level rung broke, and denying it helps no one. But notice the nuance: the rung broke, not the ladder. Companies still need seniors, and seniors aren't born — they're made. Sooner or later the market will have to rebuild the pipeline, and the juniors who survive this transition will be the ones who arrived differently:
- Use AI to learn, not to avoid learning. Ask it to explain every line it generates. The difference between "it works and I don't know why" and "it works and I know why" is your entire career.
- Build complete things. A deployed side project, with real users and real bugs, teaches what no tutorial can: the part of the craft AI doesn't cover.
- Learn to actually debug. When the agent gets stuck — and it does — the person who can drop down to the log, the breakpoint and the protocol is the one who unblocks the team.
- Fundamentals don't expire. Networking, operating systems, databases, complexity. The frameworks AI has mastered change every year; the things they stand on don't.
If you've been at this for years: your risk is different
The senior doesn't compete against AI; they compete against the senior who uses it well. And there I see two symmetric mistakes. The first is rejection: "I review better than any model" — true today, irrelevant within two improvement cycles. The second is surrender: accepting everything the agent generates without reading it, until a production incident reminds you whose name was on the deploy.
The middle ground has a boring name: management. You direct a small fleet of agents the same way you used to coordinate people — with specs, with review, with standards. If you ever considered moving into management but didn't want to stop touching code, the good news is that this hybrid role was just invented and nobody has ten years of experience in it.
What doesn't change
After all the vertigo, one thing calms me down: software is still the discipline of deciding what should happen and making sure it does. The tools for getting there have changed more in three years than in the previous twenty, but the nature of the craft — judgment, accountability, translating between what people need and what the machine does — remains intact.
Surviving this era isn't about outrunning the AI. It's about moving one level above it — which is exactly the same move made by those who went from assembly to compilers, and from physical servers to the cloud. The ones who clung to the layer being automated had a rough time. The ones who moved up a layer couldn't keep up with all the work.
