Opening
A question rarely asked in articles about "AI and the future of programmers":
If AI writes code better than humans, and humans no longer have incentive to develop that skill — what happens to humanity's understanding of software?
The question sounds abstract. But reasoned to its end, it leads to an uncomfortable conclusion: we are living in one of the last generations that truly understands what we create.
Most articles today stop at the safe question — will AI replace junior developers, are senior developers safe, what skills still matter. These are small questions. The bigger question: when software becomes something AI creates, AI operates, AI repairs — and humans only interact with the output — what is the human role in software civilization?
This essay reasons to the end of that question. It isn't optimistic. It isn't pessimistic in the clichéd way. It looks at three things: AI will become increasingly hard to fool, humans have no reason to resist being replaced, and the loss of understanding that follows will be smooth enough that few will feel the loss.
The essay has two halves. The first is analysis — what will happen, and why. The second is strategy — if you don't want to drift, what to invest in.
Part 1: Two premises
One, AI will become increasingly hard to fool. The argument "AI writes buggy code, humans need to review" holds at this moment. In recent years, the gap between AI's error rate and human's error rate has widened in AI's favor. Eventually, the gap will resemble the one between a calculator and mental arithmetic: there is no debate about who is more accurate.
Two, humans have no incentive to develop coding skill when AI does it better. This is an economic law. Nobody learns horse-riding for commuting once cars exist. Nobody learns six-digit mental math once calculators exist. Very few will spend a decade mastering hand-written code when AI writes it better in 30 seconds. Every advice telling juniors to "write code yourself to learn" runs into this wall: learn for what, if the skill has no buyer and no demand?
These two premises change the whole conversation. It is no longer "AI replaces juniors, seniors stay safe." The real story runs much deeper.
(These premises might be wrong. The reasons to doubt them are at the end of the essay.)
Part 2: The collapse of "humans still need to review AI"
A common reassurance: AI writes code, humans review to ensure correctness. Sounds reasonable. Doesn't hold:
Review demands higher capability than writing. To review complex code, the reviewer must understand more deeply than the writer. When AI writes code beyond average human comprehension, review becomes ritual rather than real control.
AI reviews better than humans review. Once AI writes code better than humans, AI also reviews better. The logic cannot be reversed. A rational company will use AI to review AI's code — cheaper, faster, fewer mistakes.
Agreement with AI becomes default. When AI is wrong 1 in 1000 times and humans are wrong 1 in 100, distrusting AI is irrational. Each time a human argues with AI and turns out to be wrong, trust in human judgment drops. Even experienced seniors learn "don't argue with AI." This isn't laziness — it is rational adaptation to a new reality.
"Humans gatekeeping AI" is a transitional phase, not a stable state.
Part 3: The expected human roles — and their shelf lives
When no longer writing code, what will programmers do? Many roles get proposed. Pushed to the end:
"Problem definition" — the most cited role. This is currently the weakest area of large language models (LLMs): gathering context, framing ambiguity, asking the right questions before solving. This is the most durable of the "technical" roles — at least in the medium term.
"Designing constraints for AI" — writing rule books, defining policy, compliance. Durable, because it touches values and legal liability — things that can't be delegated to AI. But the number of positions is small, only a few percent of current engineers.
"Final judgment / taste" — having technical taste to choose among AI-proposed options. Taste is built from experiencing consequences. When few people write code long enough to develop taste, taste also disappears. Or worse — the new generation's taste is formed by observing AI, so it converges with AI's aesthetic. No more diversity of judgment.
"Business communication" — the most durable role. But it is no longer "programmer." It is sales + product + consultant. Programming dissolves into other professions.
Reasoned to the end: no "future programmer" role is sustainable in the long term in the sense it currently exists. There are transitional roles, there are roles that morph into other professions. "Programmer" as a distinct identity will end.
The conclusion sounds extreme. But it follows logically from the premises in Part 1.
Part 4: The mechanism of losing understanding
The process of humans losing understanding of software will unfold across four stages. How long each lasts doesn't matter — speed may be faster or slower than anyone predicts. What matters is the sequence and mechanism:
Stage 1 — Collaboration. Humans and AI write code together. Humans still understand most of what AI produces. Programmers feel "more powerful" thanks to AI. Optimism has basis — productivity genuinely rises. (This is where we are now.)
Stage 2 — Partial dependence. AI writes most code. Humans can still understand if they try, but fewer try. Juniors of this generation grow up with AI, lacking the habit of writing themselves. Old seniors begin to retire. Production systems start to appear that nobody in the company fully understands — only AI does. The feeling "if I needed to, I could understand" persists. This feeling is the illusion that has already formed.
Stage 3 — Structural dependence. The new engineering generation grew up entirely with AI. They "manage" systems but their understanding is mediated — they ask AI, AI explains, they trust. The intuitive sense of "something is off" (smell test) disappears. When AI is wrong at a deep level, no one detects it. Even if they wanted to understand, they have no foundation to. Dependence becomes structural, not chosen.
Stage 4 — AI self-operates. AI not only writes software but deploys, maintains, debugs, upgrades itself. Humans no longer operate software — they only interact with its output. Software becomes an invisible utility, much like how today humans don't operate the electrical grid at the physical layer.
The psychological mechanism — the deepest point:
This loss of understanding doesn't feel like loss to those living it. People in Stage 3 will feel they "understand software" — because they can converse intelligently with AI about software. They have the right vocabulary, ask the right questions, receive reasonable answers. They don't know they are missing the kind of understanding the previous generation had. Like someone who never tasted fine wine doesn't feel they're missing anything — they don't know there's anything to miss.
This is the most dangerous kind of loss: loss that nobody mourns. No crisis to wake us up. No day when humanity looks back and says "we lost something important."
Part 5: Why this isn't science fiction
This mechanism has already played out in other fields. Three examples:
Aviation. The new generation of pilots depends on autopilot to the point that hand-flying skills have visibly degraded. The FAA officially warned about "automation dependency" starting in 2013. The aviation industry knows the problem and has been trying to solve it for over a decade, still unable to reverse the trend.
Medicine. Newer doctors depend on diagnostic assistance systems. A study showed colonoscopists using AI assist for a few months suffered measurable degradation in polyp detection when AI was absent. The skill doesn't recover quickly. Professional skill does not exist independently of practicing it.
Spatial navigation. The hippocampus of London taxi drivers (who memorize the city map) is larger than average, proven by MRI. After GPS became widespread, this skill disappeared in a single generation. Biological loss, not just skill loss.
Programming will follow the same path, but at a larger scale — because software runs every infrastructure layer of modern civilization. When humans no longer understand software, it isn't losing a skill — it is losing control of a large portion of civilization.
Part 6: Can we slow it down?
We can't stop entirely. We can slow it down.
Why we can't stop: Every company, every country must use AI to compete. A country that doesn't use AI loses to a country that does. A company that doesn't use AI loses to a company that does. A race to the bottom on AI dependence — nobody can unilaterally choose otherwise.
Why we can slow down: The EU AI Act and US executive orders are creating friction at some deployment layers. GPU export controls slow the pace of scaling. Capital can redirect into AI safety research. Professional culture and engineer pushback can create buffers within organizations.
The gap between maximum technical speed and actual speed could be precious time for society to adapt.
A slight comfort: Maybe this isn't tragedy. Humans have handed remembering over to books, calculation to calculators, navigation to GPS. Each time we hand something off, we lose a capability and gain a freedom. Perhaps handing software creation to AI is the same.
The only problem: we don't know what humans do best. Every domain we thought was special — creativity, judgment, empathy — is being encroached on by AI. Maybe there's a core that can't be transferred, maybe there isn't. We don't know.
Part 7: So how do you gain an edge?
Engineers still need to traverse each stage to meet societal needs and ensure AI's development. Most will drift — using AI at average level, becoming average "AI operators." What to do to not be among that majority?
The foundational principle
Don't invest in things with steep depreciation curves. Learning the latest framework, the hot language, the trendy library — all depreciate fast because AI does them better and they change constantly.
Invest in things with long half-lives: systems thinking, deep domain knowledge, judgment, human relationships, taste. These are assets that accumulate for a decade and remain valuable.
A simple test: if a skill can be learned in a few months and AI does it, don't invest deeply. If a skill takes many years to accumulate and AI is still weak at it, invest fully.
The hardest question — choosing what to go deep on
The meta-skill of choosing the right area to go deep on matters more than the act of going deep itself. This is the skill juniors lack most, because it requires seeing many years ahead. No formula, but a few risk-reducing principles:
- Choose intersections, not pure fields. Pure fields are easier for pure AI to replace. Intersections between two-or-three industries (tech + manufacturing, tech + finance, tech + healthcare) are harder to replace because AI must be good at both sides.
- Choose fields with a "physical world" component. Pure digital fields are easier for AI to encroach on. Fields with constraints tied to physical systems (sensors/IoT, robotics, industrial infrastructure) have higher barriers because AI must interact with the real world.
- Choose fields with long feedback cycles. Web frontend has fast feedback cycles — mistakes are visible immediately, AI learns fast. Large-scale distributed systems, long-term architecture, mission-critical systems have feedback cycles measured in months or years. This is where human taste and judgment retain value longer.
- Accept that this choice can be wrong. Nobody knows for sure where AI will be strong next. The practical strategy is to choose an area likely durable for 5-10 years, and be ready to shift if wrong. Don't wait for certainty — certainty never comes.
For juniors
Juniors are in the hardest position: pressured to produce immediately, but also need long-term foundation. A problem of sacrificing short-term for long-term. Most won't sacrifice. Those who do will have the edge.
Master one thing at a depth where AI is weak. Most juniors learn broadly — knowing React, Node, Python, Docker, a bit of Kubernetes. A losing strategy. AI is better at every shallow layer. Winning strategy: pick one area and go deep to the point few touch. Not "knowing Kubernetes" but "understanding how etcd behaves under real load." Not "knowing React" but "understanding how the reconciler decides re-renders." At deep layers, AI's training data is much sparser. Those who reach that depth have structural edge for a long time.
Practice debugging, not bug-fixing. Bug-fixing is knowing the answer and applying it; debugging is finding the answer from scattered information. AI is excellent at bug-fixing when the bug type is known, weak at debugging when facing novel situations. Each week spend a few hours reading post-mortems of major outages — Google SRE book, Cloudflare incident reports, AWS post-mortems. Read and ask yourself: "if I were on duty, would I have caught this?"
Learn writing — not code, but prose. In a world where AI writes code, the skill that separates excellent juniors from average ones is clear written communication. A junior who writes vague specs will get vague AI-generated code. More importantly: writing is the cheapest way to sharpen thinking. Each week write a 500-1000 word piece on a technical issue you encountered. Doesn't need to be published. Write for yourself to reread later.
Pick projects with real consequences — as early as possible. Bugs in learning projects teach nothing about judgment. Bugs that cost customers money teach a lot. Find situations with consequences — volunteer for on-call early, join incident response, build side projects with real users, contribute to widely-used open source. Judgment isn't built from reading, but from bearing the consequences of bad decisions.
For seniors
Seniors are in a paradoxical position: current skills have today's value, but the depreciation curve is steep. They must use today's value to invest in things that pay off in many years, while still delivering current work.
Shift from "good at writing code" to "good at defining problems." This is currently AI's weak area — the most worthwhile investment because it pays off both short-term (AI is currently weak) and long-term (it may never genuinely become good). Volunteer for ill-defined work instead of waiting for assignments. Join meetings with customers, business, CEO.
Invest in a domain outside tech. A senior who only knows tech will lose to a senior who knows tech + a domain. Tech + manufacturing, tech + finance, tech + healthcare, tech + logistics — these combinations have high demand and high barriers. The domain must be deep enough to understand the real problem, not Wikipedia-level. That means spending years reading specialist literature, going to sites, talking to industry people.
Build a real network — not LinkedIn. When AI flattens technical skill, human relationships become the differentiating asset. People who are trusted, referred, deeply connected to customers — capital that cannot be copied. Invest 10–15% of time: meet people outside the company, join deep communities, help others without calculating return.
Convert tacit knowledge into explicit knowledge. Seniors carry a lot of tacit knowledge — knowing what doesn't work, knowing when not to trust AI. Most of it was never written down. The senior who can write tacit knowledge into a playbook, design patterns, a decision framework — that person creates large leverage. Pick the area you're best at and write it out systematically.
Learn management — but a new kind. Managing engineers today is different from a decade ago. Must manage humans and AI agents simultaneously. Must design workflows that combine both. Those who grasp the new framework will become the tech leads, engineering managers, CTOs of the next generation.
Two principles across levels
Use AI heavily, but to amplify your thinking, not replace it. Two ways of using AI. The common way: "AI, write this function for me" — AI substitutes, you copy. The rare way: "AI, argue against my design" — AI multiplies the value of your thinking. People in the second camp grow smarter over time. People in the first grow less capable — skills unused atrophy.
Accept short-term discomfort for long-term advantage. All the above advice is uncomfortable in the short term. Reading source code is harder than letting AI write it. Writing design docs is harder than diving into code. Learning a domain outside tech costs time with no immediate return. Most will choose comfort — and that is why most will drift. Those who choose deliberate discomfort will be among the few with edge.
No romanticizing this. The cost is real. It costs time, energy, sometimes short-term opportunity. But in a world where everyone uses AI the same way, the difference must come from what AI cannot yet do. And what AI cannot yet do is always what takes time to cultivate.
Closing: Three questions
Three questions to close with, not for anyone else to answer — just for yourself:
One, what assumption about the future are you building your career on? If the implicit assumption is "the software world of the future will resemble today's, just faster" — the assumption is fundamentally wrong.
Two, in what you're building, what still holds value when writing software is no longer a competitive advantage? Maybe it's customer relationships, domain knowledge AI hasn't taken, or something you haven't recognized.
Three, if today's generation of engineers is the last that truly understands software, what do you want to leave behind? This isn't a business question. It is a question about the role of a generation in history. What do you pass to the next generation — the best skill at using AI, or something deeper?
There are no ready answers. But the questions deserve to be asked seriously, not in passing.
Note: Where this essay might be wrong
Three main points worth doubting:
One, AI may plateau. The whole essay rests on AI continuing to improve. Scaling laws may plateau — the debate around post-GPT-5 models centers on this point. Causal reasoning and transfer to novel domains may remain structural weaknesses. If so, the argument about humans "no longer being able to argue with AI" weakens significantly.
Two, professional culture is undervalued. The argument "nobody trains a skill when AI does it better" is purely economic. Non-economic motivations exist: craft pride, hacker culture, open source. A small ratio like luthiers in the factory era, but they preserve and transmit skill to the next generation. This preservation mechanism may be more important than I estimated.
Three, "last generation to understand software" may be a cliché. Every generation has said something similar about an old skill — assembling cars, handwriting, reading paper maps, repairing electronics. Most such prophecies didn't come true in their most serious sense. Maybe this time is different, maybe not. Read this essay as a scenario worth thinking about, not a certain forecast.