When Code Costs Nothing

Machines now write most of the code at the frontier. What history says happens next, an era-by-era forecast to 2056 with my own odds, and where engineers should bet: jobs, indie hacking, and the skills that stay scarce.

A small round clay creature holds a glowing blueprint on a ridge at dusk; glowing rings lead to a luminous city of block towers built by tiny flying helper robots.
0:00
/6:25
When Code Costs Nothing: a short animated film about the next thirty years of software engineering.

On 10 November 1954, an IBM team led by John Backus described a system it called FORTRAN and promised that it "should virtually eliminate coding and debugging." Six years later, Herbert Simon wrote: "It is far more likely that the programming occupation will become extinct than that it will become all-powerful. More and more, computers will program themselves."

Today, the United States alone employs about 1.7 million software developers (BLS, 2025). Every generation has been promised the end of programming, and every generation ended up with more programmers.

This time the claim comes with an SEC filing. Anthropic told investors that more than 90% of the contributions to its codebase in September 2026 were written by Claude. So the honest question is no longer whether machines will write the code. It is what happens to the people, the companies and the economy when writing code costs almost nothing, and what an engineer should do about it this year.

I keep four kinds of claims apart throughout: measured (studies, filings, telemetry, with vendor numbers labeled), forecast (named people saying when), history (what happened last time), and opinion (mine, labeled, with probabilities you can check me against). Sources were read on 16–20 November 2026.

The thirty years in one screen

WhenWhat I expect, and the evidence it rests on
Now (late 2026)Most new code at the frontier is written by AI: more than 90% of contributions at Anthropic in September (its IPO filing), 75% of new code at Google (April). The classic benchmarks are saturated, and the best ruler for agent autonomy stopped working at about 16 hours
2027–2029The supervisor years. Agents run for days; engineers manage fleets. Review, specs and evals become the bottleneck. The entry rung keeps narrowing. Forecasters at the AI Futures Project expect a superhuman AI researcher in 2027
2030–2034The cost collapse. A working feature costs a small fraction of what it does today. Product teams shrink to a handful of people; one-person companies with real revenue become ordinary; seat-priced software breaks
2035–2045Software as weather. Most software is generated on demand from intent and constraints, regenerated rather than maintained, and machine-checked rather than human-read. Proofs become cheaper than code review
2046–2056Intent engineering. The human job is deciding what should exist, under which constraints, and answering for it. "Programmer" goes the way of "computer", a word that used to be a job title

The first row is measured, apart from my reading of METR's ceiling. Everything below it is forecast: some by named people, most of it mine, labeled as such with probabilities further down. The rest of the article shows the work.

Where we actually are

The code is already mostly written by machines, at the frontier

Anthropic's IPO filing says: "Over 90% of the contributions to our codebase in September 2026 were written by Claude." In April, Sundar Pichai said that "75% of all new code at Google is now AI-generated and approved by engineers, up from 50% last fall." Both are companies describing themselves.

The prediction behind those numbers came early and ran late. In March 2025 Dario Amodei said AI would write 90% of code in "three to six months," and that in twelve "we may be in a world" where it writes "essentially all of the code." It took the frontier labs roughly a year longer, and it is still not true of the industry. The lesson I take: the direction of these forecasts has been right more often than the dates.

Amodei also drew a distinction most headlines skip. In a January 2026 essay he wrote that "'Writing all of the code' and 'doing the task of a software engineer end to end' are very different things, because software engineers do much more than just write code." In May he put it more simply, as quoted by Fortune: "If you automate 90% of the job, then everyone does the 10% of the job." Most of this article is about that ten percent: how big it is, who gets to do it, and how to get good at it.

Four minutes to sixteen hours

METR measures how long a task, timed in human expert hours, an AI can finish on its own half the time. GPT-4 managed about 4 minutes in March 2023. By March 2026, Claude Mythos Preview reached "at least 16 hours" (95% interval: 8.5 to 55), as The Decoder reported METR's estimate. METR's Time Horizon 1.1 puts the doubling time at 88.6 days for models since 2024. Then the instrument hit its own ceiling: METR's page says "Measurements above 16 hrs are unreliable with our current task suite," and it stopped updating on 8 September.

The anecdotes past the ruler are vendor claims and single runs, but they show the shape. Anthropic says one engineer let Fable 5.2 start from an empty folder; it coordinated more than 1,000 subagents for eight days and "produced a working operating system that boots on a laptop." On 5 November METR estimated that Anthropic is improving its models on well-specified tasks "at around twice the rate" of 2024–25, and that "perhaps ≈80%" of the acceleration comes from AI. METR also notes that Anthropic redacted most of the evidence METR found most informative.

Passing the tests is not the same as shipping

The counter-evidence matters as much as the headline. METR had maintainers of scikit-learn, Sphinx and pytest review 296 AI-written pull requests. Roughly half of those that passed the tests would not have been merged; automated grading scored them about 24 points higher than the maintainers did.

Security improved this year but is far from solved. Veracode's October update (vendor research) found the best models (Claude Opus 5.5 and GPT-6 Sol) produce secure code in 73% of its tasks, the average model in 62%. In Java, only 31% pass. Models also invent package names that do not exist, at least 5.2% of the time for commercial models and 21.7% for open-source ones, and attackers can register those names ("slopsquatting").

And people are bad at judging their own speed. In METR's 2025 trial, experienced open-source developers took 19% longer with AI and believed afterward that it had made them 20% faster. The 2026 follow-up points to a speedup, about 18% for returning developers, with an interval wide enough to include none. It also hit a problem no one planned for: developers refused to join because they "do not wish to work without AI."

The bottleneck moved to review

Faros AI's telemetry across more than 10,000 developers (vendor data) found that teams with heavy AI use complete 21% more tasks and merge 98% more pull requests, while review time rises 91%. Google's DORA 2025 report says AI adoption "now improves software delivery throughput" but "still increases delivery instability." Anthropic reports that by August its interactive agent hours outnumbered employee hours six to one, and commits per engineer were five times what they were six months earlier.

Writing code got cheap. Knowing whether the code is right did not.

The economics of free code

What falls, what rises

When the cost of something falls by orders of magnitude, three things happen at once: we make far more of it, the people who made it by hand lose pricing power, and the value moves to whatever is still scarce. Coal did it in 1865, when William Stanley Jevons noticed that more efficient engines raised coal consumption. Satya Nadella reached for the same idea in January 2025: "Jevons paradox strikes again!"

For software, the near-term data already shows both effects. Indeed's index of US software-development postings peaked at 233.8 (February 2020 = 100) in February 2022, fell to 61.1 in May 2025, and stood at 81.7 on 13 November 2026, according to Hiring Lab's public data. The rebound is real and lopsided: Hiring Lab found that 71% of the increase from May 2025 to May 2026 came from senior roles, and 37% from jobs with AI in the title.

The long-run official view is calm. The US Bureau of Labor Statistics projects software developer employment to grow 10% from 2025 to 2035, with a median wage of $135,980 in May 2025. Its separate category for computer programmers is projected to shrink 7%: "Computer programming work continues to be automated." The split inside one agency's tables is the whole story in miniature. Translating specs into code is shrinking. Deciding what the code should do is not.

The entry rung broke first

The pain is concentrated at the bottom of the ladder:

  • Employment of 22-to-25-year-olds in AI-exposed jobs "now stands 19% below where it would be had it kept pace" with less-exposed peers, "with no comparable gap for experienced workers" (Stanford's Canaries in the Coal Mine, August 2026). It works "primarily through reduced hiring rather than increased separations."
  • New-graduate hiring is "down roughly 65% at the Tech Majors and down ~76% at early stage startups compared to 2019" (SignalFire, VC data, June 2026).
  • Among 73 majors, computer engineering graduates have the second-highest unemployment rate (7.8%) and computer science the fourth (7.0%), against 4.2% for all recent graduates (New York Fed, February 2026, 2024 data).
  • At firms that adopted generative AI, junior employment fell about 9% after six quarters while senior employment held (Hosseini and Lichtinger, Harvard, May 2026).
  • Students noticed: spring 2026 enrollment in computer and information sciences fell 8.4% at four-year institutions (National Student Clearinghouse).

Nobody is firing juniors en masse. They are simply not being hired. That is quieter than a layoff wave, and in the long run it may matter more.

Even the pay data shows the tilt. Levels.fyi measured the AI-engineer premium over other engineers at 6.2% at entry level in 2025, down from 10.7%, and 18.7% at staff level, up from 15.8%.

Where the money is going

The four largest cloud companies guided to roughly $730 billion of capital spending in 2026 (CNBC, 29 October). That money buys chips, data centers and power, not headcount. Anthropic's filing shows $17.0 billion of third-quarter revenue against $1.4 billion a year earlier. Lovable reported $400 million of annual recurring revenue with 146 full-time employees (its own figures), about $2.7 million per person by my arithmetic. In June, SpaceX agreed to buy Cursor for $60 billion in stock (TechCrunch). In February, a week-long selloff of software stocks, reportedly triggered by Anthropic's Cowork plugins, wiped out about $1 trillion of market value, according to Reuters.

The macro forecasts disagree by an order of magnitude. Daron Acemoglu estimates "no more than a 0.66% increase in total factor productivity" over ten years. The Penn Wharton Budget Model estimates GDP 1.5% higher by 2035 and 3.7% by 2075. Goldman Sachs said 7% of global GDP over a decade. As I read them, none of them assumes AI that does AI research, which is what the frontier labs now say they are building.

What history says

Every earlier wave of automation in knowledge work left a similar pattern. It is worth knowing in detail, because the details are where the career advice is.

WaveWhat was automated, and what happened
Compilers (1954–57)Hand-written machine code. FORTRAN's 1957 paper describes a job programmed in four hours with 47 statements, compiled in six minutes into about 1,000 instructions; by hand, an estimated three days. Programming grew into a mass profession
VisiCalc (1979 on)Bookkeeping arithmetic, by spreadsheet. Since 1980, "400,000 bookkeeping and accounting clerk jobs have gone away. But 600,000 accounting jobs have been added" (NPR Planet Money, 2015)
ATMs (1970s–2000s)Cash handling. Tellers per urban branch fell from 20 to 13 between 1988 and 2004, but urban branches rose 43% and teller jobs held (Bessen, IMF). BLS now projects −13% for 2025–35 as branches decline from "technological change"; my reading is that the smartphone, by removing the branch visit, did what the ATM did not
Phone switching (1920–40)Telephone operators. Automation "eliminated most of these jobs" but "did not reduce future cohorts' overall employment." The operators already in the job were "a decade later more likely to be in lower-paying occupations or no longer working" (Feigenbaum and Gross, NBER)
Power looms (1810s–20s)Handloom weaving. About a quarter million handloom weavers at the peak; wages collapsed in the 1820s and employment followed (Robert Allen, Oxford)
Radiology AI (2016 on)Image reading, supposedly. Geoffrey Hinton, 2016, as recalled by Joshua Gans: "People should stop training radiologists now." By 2025, average radiologist pay was $571,000, up 9%, with case loads up 25% since 2018 (Medscape and others via Fortune)
ChatGPT and writers (2022 on)Freelance writing gigs. Monthly earnings of writing freelancers fell 5.2%, with "suggestive evidence that top freelancers are disproportionately affected" (Hui, Reshef and Zhou)

Four lessons come out of that table.

The narrow job dies; the wide job often grows. Clerks, operators and weavers did a task. Accountants, bankers and radiologists did a job that contained the task. When the task got cheap, the job got cheaper to buy, and people bought more of it. Jevons wrote the labor version of his paradox in the same 1865 book: "such is the increased demand for the cheapened products, that eventually the sphere of employment is greatly widened." Software has both kinds of work inside one title. "Turn this ticket into code" is the clerk's part. "Decide what this system should do and answer for it" is the accountant's.

The people holding the job at the moment of change pay for it. Even when the next generation is fine, the incumbents rarely are. Later cohorts found clerical jobs; the operators already in the job moved to lower-paying work or stopped working. This is the part of the history that optimists skip.

Responsibility slows displacement more than capability speeds it. Radiology AI got good at reading images years ago. Radiologists still sign the report, carry the liability and see more cases than ever. I expect software that runs payments, cars and hospitals to follow the radiologist's path, not the clerk's.

The second technology can be the one that kills the job. The ATM did not eliminate tellers; on my reading, the smartphone is now doing it, by removing the reason to visit a branch. For software, the equivalent is not a better code generator. It is the moment a business no longer needs a codebase at all, because an agent can produce the outcome directly.

Natural language as a programming language has a history as well. COBOL's designers apparently believed English-like statements would make programs readable by managers, "but the semantics of programming are at least as challenging as the syntax," Ben Shneiderman wrote in 1985. Dijkstra was sharper: the "naturalness" of our native tongues "boils down to the ease with which we can use them for making statements the nonsense of which is not obvious." Karpathy's "The hottest new programming language is English" (2023) is the same bet with far better machines. The semantic problem did not go away. It moved into the prompt.

The resistance has a history too. Backus recalled that 1950s programmers saw themselves as "a priesthood guarding skills and mysteries far too complex for ordinary mortals," and were "unalterably opposed to those mad revolutionaries who wanted to make programming so easy that anyone could [do] it."

And there is a classic argument that this time is the same. In 1986 Fred Brooks split software difficulty into essence and accident and argued that no tool could give an order-of-magnitude gain unless accidental work was "more than 9/10 of all effort." Compilers, IDEs and frameworks all attacked the accident. What makes this wave different, in my view, is that AI is the first tool that reaches into the essence: it proposes designs, questions requirements, writes the tests that define correctness. But Brooks's most quoted line still marks the last ground: "The hardest single part of building a software system is deciding precisely what to build."

The next thirty years, era by era

What follows is my forecast. I've tied each era to the evidence above and to named forecasts where they exist; the rest is my judgment.

2027–2029: the supervisor years

Agent runs stretch from hours to days. A competent engineer runs several agents at once and spends most of the day writing specs, reading diffs, designing tests and saying no. The scarce resource in a software company becomes an hour of a senior engineer's attention, and teams start budgeting it the way they budget cloud spend.

Three things break in this period. Code review, because volume outgrows human reading speed, which pushes teams toward machine-checkable specifications, property tests and staged rollouts. Change management, because the first famous outages and breaches caused by agents will produce new rules about who approved what. And the apprenticeship, because the tasks juniors used to learn on are exactly the ones agents now do.

The forecasters' version is more aggressive. The AI Futures Project wrote on 10 November that "all of us forecast that Superhuman AI Researcher (SAR) will likely arrive at some point in 2027," with "a 35-65% chance" that AI able to "automate all white-collar work" arrives before 2028. If they are right, every era below arrives sooner.

2030–2034: the cost collapse

The price of a working feature falls by something like ten to a hundred times from today. Product teams shrink to two to five people. One-person companies with real revenue become ordinary. Seat-based SaaS pricing breaks, because a company that needs fewer seats will not pay per seat, and because a customer can generate a close-enough internal tool over a weekend.

Two less obvious things happen. A migration wave: decades of COBOL, old Java and unmaintained systems get rewritten by agents, with machine-checked evidence that the new code behaves like the old. And personal software: programs built for one person, one task, one week, then thrown away. Most software ever written will be written in this period and most of it will be disposable.

The title "software engineer" splits. Builders own a product and its users. Verifiers own correctness, security and reliability. Platform engineers own the infrastructure agents run on. Domain engineers sit inside medicine, law, energy or manufacturing and translate between the field and the machines.

2035–2045: software as weather

By the late 2030s, most production software is generated from intent, constraints and tests, and regenerated when requirements change instead of being maintained. Humans mostly read specifications and proofs, not code. Formal verification becomes routine for anything important, because proofs became cheap and human review did not. The data point that convinces me: verifying the seL4 microkernel by hand took about 25 person-years, roughly $700 per line. This November, Google DeepMind said its agents wrote "over six million lines of Lean" proving properties of the code behind the Signal protocol, in four weeks (a vendor claim).

This is also when the missing cohort shows up. The juniors who were not hired in the mid-2020s are the seniors who do not exist in the late 2030s. Companies that cut the bottom rung will find that judgment cannot be bought on demand, and the engineers who did get through will be very expensive.

The number of people who make software explodes into the hundreds of millions, because describing what you want becomes enough for most needs. The number of professional software engineers is flat or lower, and the profession looks more like civil engineering: fewer people, more accountability, sign-offs that carry legal weight. Most growth moves into software that touches atoms: robots, labs, grids, factories.

2046–2056: intent engineering

The human job is deciding what should exist, under which constraints, for whom, and answering for the consequences. Writing code by hand survives the way calligraphy survives: as a craft, a teaching tool and, in a few places, a requirement. "Programmer" ends up like "computer", once the job title of people who did calculations by hand, before the machines took the name.

The 2023 survey of 2,778 AI researchers gave a 50% chance of machines beating humans at every task by 2047 and of full automation of all occupations by 2116. Forecasters in 2026 put a narrower milestone, a superhuman AI researcher, in 2027, about two decades earlier. My 2056 sits between the survey's two dates, because I expect the work of deciding and owning to outlast the work of typing by a long way.

My forecasts, with numbers

These are my own probabilities, made on 20 November 2026, so they can be checked.

PredictionMy probability
By end of 2028, a frontier lab reports more than 99% of its merged code written by AI80%
By end of 2028, big tech companies stop reporting the share of code written by AI75%
By 2030, a typical new product team at a software company has five or fewer people70%
By 2030, US software developer employment (BLS) is below its 2025 level50%
Indeed's software postings index climbs back above its February 2020 level at any point before 203135%
A verified one-person company reaches a $1 billion valuation before 203140%
By 2032, people building software with AI outnumber professional developers ten to one75%
By 2035, most new safety-critical code ships with machine-checked proofs60%
By 2036, AI does the full job of a senior engineer on a typical product team with no human reviewer35%
By 2040, most production code is never read by a human85%
By 2040, the US or EU requires a named, accountable sign-off for AI-built software in at least one regulated sector65%
In 2056, "software engineer" is still a common job title40%
In 2056, the work of deciding, verifying and owning software systems is still done by people95%

The 50% row is a genuine coin flip. The Jevons argument says cheaper software means more demand for people who direct it; the entry-level data says companies need fewer people to get it. I don't know which wins by 2030.

Three futures

Abundance (my weight: 45%). Jevons wins. Software becomes so cheap that every business, scientist and household commissions it constantly, and the people who can direct, verify and own it are in more demand than ever. The early sign: postings rising even as AI writes most code. Indeed's software postings rose almost 15% from Claude Code's launch in February 2025 to July 2026 (Hiring Lab) and kept rising through November. That is a hint, not proof.

Hollowing (35%). A superstar economy. A small number of senior engineers with agent fleets do what departments used to do; juniors never get in; pay splits into a very high top and a crowded bottom. The early signs are all in the entry-level numbers above.

The wall (20%). Reliability, energy, regulation or a capability plateau slow everything down, and agents settle into being excellent power tools. The early signs would be the maintainer-merge gap refusing to close and the security pass rate stalling.

The weights are for which one dominates by 2040. In practice I expect all three, in sequence and by sector: hollowing first (now to the early 2030s), abundance after, with walls in regulated and physical domains. A fourth outcome sits outside them: the AI Futures Project's world, where white-collar work is automated broadly and fast. If that happens, the career advice below matters less than the politics.

What doesn't get cheap

Five things do not fall with the cost of code, and they are where the value goes:

  • Accountability. A 1979 IBM training slide, as it circulates (its original is lost), says: "A computer can never be held accountable. Therefore a computer must never make a management decision." Someone has to sign. I expect regulators, insurers and courts to insist on it.
  • Verification. Knowing whether a system does what it should, under load, under attack, at the edges. The METR merge gap and the security numbers say this is the hard part, and it gets harder as volume grows.
  • Judgment and taste. What to build, what not to build, which tradeoff to accept. Even Amodei's 90% prediction came with the caveat that "the programmer still needs to specify ... what is the overall app you're trying to make." Anthropic's own study of about 400,000 Claude Code sessions found people make "about 70% of the planning decisions but only 20% of the execution decisions," and that the ability to steer toward success comes "more from command of a domain than from the ability to write code."
  • Context. The unwritten knowledge of a business, its users, its history and its constraints. Agents are only as good as what they are told.
  • Trust and distribution. People buy from people and companies they trust. When anyone can build anything, the hard part is getting it in front of the right people.

Best bets: where to put the next five years

For most engineers the useful question is not "will AI take my job" but "what do I do on Monday." Here is what the evidence supports, split by the two paths: a job, or a company of your own.

If you want a job

BetWhy it holds up
AI engineeringAI Engineer is LinkedIn's fastest-growing US role for the second year running. AI engineers' share of software hires is 14 times its 2019 level (LinkedIn Economic Graph, February 2026).
Forward-deployed and customer-facing engineeringPostings for forward-deployed engineers grew several hundred percent in a year (estimates run from 350% to over 1,100%, all from job-data vendors, from a small base). The job is to sit with a customer and make AI work in their mess, which is exactly the context agents lack
Security and verificationAI writes code faster than anyone can audit it. The best models still fail Veracode's security tasks 27% of the time. In ISC2's 2025 study, 59% of respondents cited critical or significant skills needs, and AI was the top need (41%)
Software in the physical and regulated worldDefense tech venture funding hit a record $49.1 billion in 2025 (PitchBook, via Defense News). Robotics startups had raised $18.8 billion in 2026 by late June, more than all of 2025 (Crunchbase). Grids get about $400 billion a year against roughly $1 trillion for generation (IEA). Eight of the 11 most critical US federal legacy systems run on outdated languages (GAO). These sectors need engineers who understand the domain and the liability
Senior depth, anywhere71% of the 2025–26 rebound in US software postings came from senior roles (Indeed). The cuts fall on beginners, not seniors. Depth is what companies pay for

On location: 45% of US developers work fully remote (Stack Overflow, 2025), while office-based roles rose 12% in Levels.fyi's submissions. In my view, for juniors especially, being near people who will teach you is worth more than the commute costs.

Two warnings. First, "AI" in a job title is not a moat; I expect every engineering role to be an AI role within a few years. Second, the industry mix is shifting: the share of US software-engineering postings from professional services rose from 21.2% to 28.2% while tech's share barely moved (LinkedIn). More of the work is moving to companies whose main business is not software.

If you want to build your own thing

Indie hacking deserves a closer look, because AI cut the cost of building a product.

The good news is real. The share of new startups with a single founder rose from 23.7% in 2019 to 36.3% in the first half of 2025 (Carta, as reported secondhand). On Stripe Atlas, 20% of startups charged their first customer within 30 days in 2025, up from 8% in 2020, and the number of companies reaching $10 million ARR within three months doubled (Stripe's own data).

The base rates are brutal. Stripe reports that median six-month revenue for solo founders fell 23% in 2025 while the top decile rose 19%; the top decile now makes about 61 times the median, up from 34 times. In MicroConf's 2024 survey, 28% of independent SaaS companies made under $1,000 a month, the single largest group. The famous examples are messier than the headlines: Base44, sold to Wix for $80 million after six months, "wasn't truly solo," TechCrunch reported; Wix confirmed it had eight employees. Sam Altman's 2024 "betting pool" on the first one-person billion-dollar company has no verified winner as of November 2026.

Building got cheap for everyone at once. App releases rose 60% year over year in the first quarter of 2026, 80% on iOS (Appfigures, via TechCrunch). When Google shows an AI summary, users click a search result in 8% of visits, against 15% without one (Pew). The bottleneck moved from building to distribution and retention.

Stripe's data on what top-decile solo founders do differently is the most useful thing I found: they were about twice as likely to build AI-native products, sold into an average of ten countries in their first month against three for the median, and nearly 30% of their customers came back the following month against 8% in the middle. In other words: global from day one, and a product people return to.

My advice, as opinion: treat indie hacking as a portfolio, not a leap. Keep an income. Pick a niche you know from the inside, preferably business customers with a painful, recurring problem. Build an audience before the product, because distribution is now the scarce part. Ship small things often and kill them quickly.

Where to invest your time

If I had to split the next five years of learning, this is my allocation:

  • About 40% on depth: one domain you could be an expert in (payments, healthcare, energy, a scientific field) and one hard technical area (distributed systems, performance, security, ML systems). Depth is what lets you steer and verify.
  • About 30% on agentic engineering: running agents in parallel, specs, evals, testing strategy, reading proofs. This is the new baseline, and the craft is still being invented.
  • About 20% on people: users, writing, explaining, selling. Every path above, job or company, now runs through it.
  • About 10% on experiments: small products, open source, things you ship in public. They are the cheapest way to find out which bet is yours.

How to adapt, and how to excel

The research points one way: AI amplifies the expertise you already have. Sessions Anthropic rated expert reach verified success more than twice as often as novice ones. DORA's summary of its 2025 survey: "AI doesn't fix a team; it amplifies what's already there." The playbook follows from that.

  • Keep a manual-practice habit. In Anthropic's randomized trial, engineers learning a new library with AI scored 50% on a comprehension quiz against 67% for those who coded by hand, with the biggest gap in debugging. How they used AI mattered more: those who delegated averaged about 39%, those who generated code and then asked for explanations about 86% (small subgroups). Use AI to explain, not only to produce. Do some work unaided every week.
  • Read code faster than you write it. Reviewing, auditing and debugging become the core craft. Simon Willison's rule is a good floor: "I won't commit any code to my repository if I couldn't explain exactly what it does to somebody else."
  • Write specs and evals, not prompts. The spec becomes the source of truth and the test suite the contract. Learn property-based testing, contracts and, at least at reading level, a proof assistant.
  • Learn to run a fleet. Parallel agents, isolated workspaces, queues, budgets, handovers. It is a very weird form of management, in Willison's words, and it is a skill.
  • Write. Paul Graham: "writing is thinking." Specs, design docs and clear prompts are writing, and writing quality now decides output quality.
  • Measure yourself, not your feelings. METR's developers felt 20% faster while being 19% slower, and Microsoft and CMU found that "higher confidence in GenAI is associated with less critical thinking." Time real tasks and keep notes.
  • Treat AI fluency as the floor, not the edge. Shopify's memo said it in spring 2025: "Reflexive AI usage is now a baseline expectation."

My read

This part is opinion, from building with coding agents every day.

Code is becoming a commodity; correctness is becoming the product. The most valuable question in a software organization in 2030 will be "how do we know this is right?", and the people who can answer it, with tests, proofs, monitoring and judgment, will be the scarce ones.

The junior developer is not dying, but the apprenticeship is. Companies have stopped paying beginners to learn on simple tasks, because agents do the simple tasks. That is rational for each company and corrosive for the industry, which is eating the pipeline that produces its seniors. I expect new routes into the profession: apprenticeship through open source, through domain work, through small companies of one, and eventually formal programs that pay juniors to learn verification rather than syntax.

The biggest change will be who writes software, not how many engineers there are. Hundreds of millions of people will build software without calling it that. Professional engineers will be the ones who make that safe: platforms, guardrails, verification, and the systems where failure is expensive.

The best position is close to a real problem and close to the machine at the same time. Domain knowledge plus agentic engineering plus the willingness to own outcomes beats any single skill. That combination is also, not by accident, exactly what an indie founder needs.

Kent Beck saw the shape in April 2023: "The value of 90% of my skills just dropped to $0. The leverage for the remaining 10% went up 1000x." The question for each of us is which ten percent, and the evidence above says it is the part closest to judgment, verification and the problem itself.

Brooks will be right one more time. Deciding precisely what to build stays hard for a long time after building it stops being hard. Thirty years from now, the descendants of today's software engineers will mostly spend their days on that one question, and on answering for the result.

What I'd watch from here: the maintainer-merge gap and the security pass rates, which say whether verification keeps up; entry-level hiring, which says whether the pipeline survives; the share of software built by people who are not engineers; and the first regulation that requires a named human to sign for AI-built code.