■ HIGH RISK ■ Technology
Largely, if your job is turning a written ticket into working code. The typing half of programming has effectively been commoditised; what survives is the part where someone decides what should exist and takes responsibility when it breaks.
“AI writes code faster than you. But someone still has to decide what to build and debug the AI's hallucinations.”
Our AI replacement risk score — how we score jobs
Classic programmer work is implementation against a spec someone else wrote: pick up the ticket, read the surrounding code, write the function, add tests, handle the edge cases, open a pull request, address review comments, fix the bug that surfaces in staging. Around it sits a lot of glue: writing scripts, updating dependencies, converting a CSV into a database migration, patching a regex nobody understands. It is exactly the kind of well-bounded, textually expressible, heavily exampled work that large models were always going to eat first.
And they have. Code completion moved from autocompleting a line to writing whole modules, then to agents that read an issue, navigate a repository, run the test suite and open a pull request unsupervised. Boilerplate, CRUD, test scaffolding, migrations, refactors, language ports and documentation are now default-generated in a great many teams. The hiring consequences are visible: the traditional entry route, where a junior earned their keep on small well-specified tickets, is precisely the work that has the lowest marginal cost to generate. Our risk score of 72 reflects a role whose median task is squarely inside the automation frontier.
The resistant residue is real but smaller than programmers would like. Someone has to decide what to build, which means translating a vague business complaint into a system that will still make sense in two years. Someone has to debug the failure that spans four services and a misconfigured cache, where the model confidently proposes a fix that papers over the actual race condition. Someone has to own production at 3am, argue for the boring architecture, and notice when generated code quietly introduces an authorisation hole. That is judgement, context and accountability, and it accrues to engineers rather than to the generic title 'programmer', which is why the job description is dissolving upward into engineering rather than vanishing outright.
Automatability: our editorial assessment of current and near-term AI capability
This is happening now, not later. Agentic coding tools are already merging real pull requests in production repositories, and the entry-level implementation market has tightened noticeably. Through the late 2020s expect team shapes to shift toward fewer, more senior engineers supervising generated output, with the pure implementation role largely absorbed. By 2030 'programmer' as a job title distinct from engineer, product or platform work is likely to be residual in most organisations.
Yes, but for different reasons than a decade ago. Understanding systems, data and failure modes is what lets you direct and audit generated code, and that comprehension still has to be built by writing plenty yourself. What is no longer a career on its own is fluent syntax production. Learn to read code critically at least as seriously as you learn to write it.
The traditional version is under real pressure, because small, well-specified tickets are exactly what agents handle cheapest. Teams that still hire juniors increasingly expect them to arrive supervising tools rather than replacing them. The practical route in is now through demonstrable projects, systems knowledge and specialised domains rather than through a queue of starter tickets.
Specify, review, integrate and operate. The work moves toward defining requirements precisely enough for machines to execute, evaluating what comes back, wiring generated pieces into existing systems safely, and owning reliability and security in production. Volume of code written per person goes up sharply; the scarce skill becomes judgement about which code should exist at all.
Anything where the context is not in the repository: legacy systems with undocumented business rules, regulated environments where correctness must be argued, low-level and performance-critical work, security engineering, and roles that sit against real users or physical systems. Generic web application implementation is the most exposed, because it is the best-documented and most heavily exampled work in existence.