Essay · June 2026 · 26 theses · 3 horizons

It's not about AI replacing devs. It's about who holds power inside the software production chain — and who's about to lose it.

For decades, software development was bottlenecked by one simple question: who's going to implement this? With AI agents, that question loses force. The new question is different: who guarantees the AI understood the right problem, touched the right place, executed safely, and produced real value for the business?

The core thesis

AI doesn't eliminate software — it redistributes power within the production chain. Execution tends to get cheaper; judgment, more valuable. AI solves much of the implementation, but it doesn't eliminate ambiguity, accountability, risk, legacy, messy data, or hard business decisions. That's why the programmer won't disappear — but whoever only executes loses ground, and whoever understands, directs, validates, governs, and takes responsibility gains relevance.

How to read this article

The theses below are bets, not certainties. Some carry high confidence; others are deliberately provocative. At some points, one thesis attacks another. That's intentional: almost every text about AI suffers from the same flaw — every prediction points in the same direction, as if the future were linear, clean, and inevitable.

The future will probably be more contradictory. AI may raise productivity in some contexts and create rework in others. It may shrink teams while creating new roles. It may make software cheaper while creating new, expensive dependencies. It may elevate human judgment and then automate part of that judgment.

Reading rule: don't just ask "will this happen?". Ask "in which companies does this already start to make sense?", "which part of this is inevitable?", and "which part depends on maturity, governance, data, culture, and regulation?".

Each thesis carries a confidence level: high (80%+), medium (60–79%), or low (<60%).

---

1 year — through June 2027 · execution starts being delegated

1. The programmer who only codes loses their seat at the most AI-mature companies

Confidence: 80%

Your programming job won't be destroyed by AI. It'll be destroyed by another programmer who uses AI better than you.

I'm not saying CRUD, simple integrations, and predictable fixes vanish from the market in 12 months — most companies have legacy, compliance, and inertia that keep that work alive for years. I'm saying that in the first quartile of adoption, the profile that just receives a task, writes code, and hands it to someone else to validate no longer justifies a dedicated hire. They compete with a queue of agents — and lose on price, speed, and availability.

The "Claude Code, Codex, or Copilot babysitter" who copies, pastes, accepts suggestions, and rubber-stamps pull requests is the first to become redundant: if their job is to not get in the way, they can be removed without loss. The interview question stops being "can you program?" and becomes "can you steer an AI to a correct, safe, and useful delivery?"

What would change my mind: if by June 2027 AI-mature companies are still hiring meaningful volumes of junior/mid devs focused purely on execution, with no requirement for agent operation, structured validation, or full-cycle vision.

2. Traditional junior roles shrink — and nobody has solved the problem that creates

Confidence: 85% (85% on the model's crisis; 95% on the unsolved problem)

The tasks that historically trained juniors — CRUD, screen tweaks, scripts, basic tests, documentation, small fixes — are exactly the first ones AI does well enough. Entry-level roles don't vanish, but they change in nature: the junior who learns by making mistakes on simple tasks gives way to the beginner agent-operator, who needs to review, test, question, steer prompts, interpret failures, and understand enough of the system not to approve garbage with confidence. And in smaller numbers.

If the junior disappears in 2027, who's the senior of 2032?

The industry may be eating its own seed corn. Today's senior learned technical judgment by writing a lot of bad code, fixing errors, breaking production, and maintaining legacy. If that ladder disappears, either we invent another way to build judgment, or we'll have a generation of validators who never built anything deeply — and therefore don't know how to validate.

What would change my mind: if a clear, scalable, widely adopted model of technical training quickly emerges — based on agents, simulations, labs, guided review, and deliberate practice.

Would your company hire a junior today? If the answer is no, who do you think you'll hire as a senior in 2032?

3. The backlog becomes an execution queue for agents

Confidence: 75%

Issues, known bugs, migrations, missing tests, and UI tweaks get assigned directly to specialized agents. The human prioritizes, refines, approves, resolves ambiguity, and corrects when the AI gets lost. The new skill isn't writing a ticket; it's writing a unit of work an agent can execute safely, with limits and acceptance criteria.

This changes the quality the backlog requires. A bad issue no longer confuses just one person — it triggers a sequence of bad work: bad PRs, fragile tests, and misleading documentation, at agent scale and speed.

4. The bottleneck moves away from writing code — but the gains may be smaller than they look

Confidence: 90% (90% on the bottleneck shift; genuine uncertainty on the size of the gain)

The problem stops being "who writes the code" and becomes "who guarantees the AI understood the right system, changed the right place, and didn't break something hard to see". And here lies the subtlest risk: the problem isn't just the AI being wrong. It's the AI looking right enough to be approved. A poorly done Human-in-the-Loop is just automation with a human stamp.

Now the most uncomfortable data point in this article, which I'll face instead of hiding. The METR study (July 2025), with experienced developers in repositories they knew well, showed that using AI tools they were about 19% slower — while believing they were 20% faster. Open-source studies point the same way: more apparent activity, more rework, a drop in core developers' productivity.

The uncomfortable implication: part of the gain we feel may be illusory. The cost reappears in review, rework, inconsistency, technical debt, and future maintenance — delivery volume rises while net quality falls. The counterpoint: those studies measured 2024/2025 workflows with devs who were experts in their own code; in greenfield and fragmented tasks the gains can be high. My bet is that the gains are real but concentrated, and that the metric that matters isn't "how much code was generated" but how much validated value reached production without increasing future risk. But it's a bet, not a fact.

5. The AI Builder emerges — the professional who runs the assembly line

Confidence: 85% (on the role's emergence; see thesis 8 of the 3-year horizon for the catch)

A technical-product generalist who turns business intent into working software through a network of agents. A blend of programmer, analyst, QA, DevOps, product, data, and architecture. They don't need to be the top expert in anything, but they need to know enough to challenge the AI, assemble context, interpret logs, review code, measure impact, and decide when to escalate to a human specialist.

The name will still vary: AI Software Operator, AI Builder, AI-Native Builder, Agentic Software Architect, Software Orchestrator, AI Delivery Engineer. But: it may be a transitional profession. If validation itself gets partly automated, the AI Builder will need to climb the value chain again — we'll come back to this.

6. Agentic AppOps stops being outsourcing and becomes software margin

Confidence: 70%

Companies already hire third parties to maintain and evolve software — that's nothing new; entire industries are built on it. What's new is the cost structure. In the traditional model, the client sends incomplete demands and a human team refines, develops, tests, fixes, and maintains. In the agent model, the client sends requirements of variable quality; agents refine, specify, implement, test, analyze impact, and open PRs; the contractor governs the flow and ensures quality. The service that needed 15 people now needs 2 to 4 operating agents.

Agentic AppOps is the evolution of software maintenance: less staffing of people, more orchestration of agents, governance, and outcomes. Whoever sees this first operates with SaaS margins selling what was always a service. The brutal counterpart is in the 3-year horizon, thesis 7.

7. Documentation becomes infrastructure for agents

Confidence: 85%

Documentation stops being something written only for humans and becomes part of the agents' operational infrastructure. READMEs, ADRs, runbooks, acceptance criteria, Definition of Done, security policies, and files like AGENTS.md directly guide how agents work — Thoughtworks' Technology Radar already treats AGENTS.md and Agent Skills as central techniques for this.

The line is simple: bad documentation produces bad agents. The company with organized context has an edge; the one relying on tribal knowledge gets confused, unsafe, expensive-to-run agents. Whoever treated documentation as a cost will discover they were destroying their own agents' fuel.

8. The Human-in-the-Loop becomes a bottleneck — and starts to rot

Confidence: 80%

The market starts to realize the new bottleneck isn't just the AI — it's the human validating the AI. Professionals who rubber-stamp PRs without understanding the generated code, who "review" documents without reading them, who accept fragile tests because they passed green, will generate incidents, rework, and distrust. Methods emerge for validating with discipline: structured review of AI-generated PRs, comparison between intent and implementation, risk analysis before merge.

But there's a deeper problem, known in aviation since the 1980s (Lisanne Bainbridge, "Ironies of Automation"): those who don't practice, lose the skill. The dev who spends years only reviewing generated code loses the ability to write, debug, and judge code deeply. Paradox: the human stays in the loop because they can judge; but if automation strips away the practice that built that judgment, the HITL itself loses quality. We return to this in the 6-year horizon.

---

3 years — through June 2029 · roles compressed, operations change

1. Teams of 1 to 4 deliver the operational output of squads of 10 to 20

Confidence: 75%

Your 15-person squad is becoming a sign of inefficiency, not strength.

It doesn't mean mass layoffs; it means recomposition. Fewer people executing fragmented tasks, more people deciding, validating quality, governing risk, and understanding the business. Team size stops being a sign of capacity and becomes a question: how many of these people make real decisions, and how many just pass along work agents could execute? The question becomes "what's the real validated delivery capacity of this system of humans and agents?".

2. The SDLC becomes continuous orchestration

Confidence: 80%

The lifecycle stops being a linear process with separate roles and becomes continuous operation across humans, agents, pipelines, environments, policies, tests, documentation, observability, and governance — from discovery to maintenance.

McKinsey keeps hammering this in its reports on generative AI in development: the biggest gains require rethinking workflows and operating models, not buying tools. Buying an AI license and keeping the same process is the most expensive way to change nothing. The real gain comes when the whole flow is redesigned: how the requirement comes in, how context is assembled, how the agent executes, how the PR is reviewed, and how production is protected.

3. PO, QA, DevOps, and Designer don't disappear — the boundaries between them do

Confidence: 80%

The disciplines don't end; what ends is the need for a separate person for every operational micro-activity on every project. The cut won't be by role, it'll be by quality.

The valuable professional will be less "owner of a box" and more someone able to remove blockers so the network of agents works without friction.

4. Architecture becomes an immune system against AI-generated mess

Confidence: 85%

AI without architecture doesn't accelerate software. It accelerates entropy.

The more code AI generates, the more valuable the architecture that stops it from degrading the system — from choosing paths that are technically possible but architecturally forbidden. Thoughtworks' Technology Radar already warned about "architecture drift": agents accelerate the gap between the real code and the intended architecture.

Architecture stops being a technical drawing and becomes an immune system: it defines what the AI can touch, how it must touch it, which paths are forbidden, which decisions require approval, and how to detect when the real code drifts from intent. Clear boundaries, contracts, architecture tests, ADRs, living documentation, and guardrails stop being best practices and become survival. AI-generated code without clear boundaries is technical debt on steroids — and the pragmatic architect becomes essential again because someone has to stop the AI from being too creative.

5. Context Engineering becomes a core competency

Confidence: 85%

The best professional isn't the one who knows the most syntax, but the one who assembles the best context for the AI to operate safely — domain explained, business rules organized, decisions documented, scope limited, what the AI must not do made explicit — and keeps it comprehensible to humans.

The challenge isn't adding more context; it's putting the right context, at the right moment, for the right agent. Too much context becomes a problem too: contradictory instructions, noise, and cost. Whoever masters context engineering will have better, cheaper, more reliable agents — a productive advantage that's hard to copy.

6. Traditional productivity metrics become obsolete

Confidence: 80%

Measuring productivity by commits, PRs, story points, or closed tickets gets dangerously misleading when agents produce volume at high speed. Volume isn't value — and the company that measures only apparent output will be fooled by agents very efficient at producing garbage. (Remember METR: the sense of speed already fools even the dev themselves.)

Metrics migrate toward business value, rework reduction, incidents, maintenance cost, and reliability. And the financial metric shifts too: what matters isn't cost per token, it's cost per validated outcome. The trap is spending a lot on AI without seeing the invisible cost of review, rework, and poorly governed agents.

7. Hourly billing collapses — and takes the traditional software shop with it

Confidence: 70%

If a team with agents delivers faster, billing by the hour punishes the efficient. The body shop sells exactly what AI commoditizes: human hours of fragmented execution. The shops that survive migrate to another model — less staffing and more outcomes, fewer man-hours and more governance, less bloated squad and more Agentic AppOps. Those who keep selling "a mid-level dev at $X/hour" will compete with a marginal cost trending toward zero.

And this carries a social dimension that runs deeper than any single country. Tech has been one of the great income elevators of recent decades — a path into the middle class across many economies. If AI compresses the intermediate mass and rewards only an elite of orchestrators, the conversation stops being about careers and becomes about economic policy.

8. The most uncomfortable thesis in this article: the human validator is automatable too

Confidence: 50% (and that's exactly why it matters)

Much of this article rests on a comfortable premise: code is automatable, but judgment, validation, and governance stay human. But why, exactly?

Reviewing a PR has inputs, outputs, and criteria. Validating documentation has a checklist. Checking architectural adherence can be partly automated. In many cases, an agent can review better than a tired, distracted, or deadline-pressured human. If that holds up by 2029, the AI Builder of the 1-year horizon may be a profession with an expiration date, and the HITL a transitional phase.

This doesn't mean the human disappears tomorrow: legal accountability, institutional trust, and reputational risk keep them in the circuit. But notice what that means — the human stays in the loop for legal and political reasons, not technical ones. That's a far more fragile position than "human judgment is irreplaceable".

9. Agent governance becomes mandatory — probably after the first big incident

Confidence: 90% (90% on governance; 60% on the incident as the trigger)

Agents are no longer chatbots; they've become operational actors with access to repositories, credentials, pipelines, and data. No serious company will let them operate without answering: which agent made the change, who authorized it, with which permissions, using which context, which tests ran, which risk was accepted, how to revert, how to audit. This creates a new attack surface: prompt injection, skill supply chain, malicious MCPs, and automated decisions with legitimate permission.

Extra bet: serious governance won't come from prudence, it'll come from reaction. At some point between 2026 and 2029, an autonomous agent causes an incident big enough to become a headline, a contract, an audit, and an insurance requirement. After that, governance stops being a consulting slide and becomes a mandatory clause.

---

6 years — through June 2032 · the market is reconfigured

1. A software company with very few humans becomes normal

Confidence: 70%

It'll be common for a relevant SaaS company to operate with 3 to 15 people and dozens or hundreds of specialized agents handling development, support, data analysis, documentation, monitoring, QA, security, billing, and onboarding. Humans stay in strategy, governance, relationships, legal accountability, product vision, and decisions involving risk, reputation, and ambiguity. The next unicorn may be born with fewer people than a traditional enterprise squad.

2. Software starts being generated on demand — and that opens two dangerous paths

Confidence: 65% (on generation on demand)

Instead of opening a ticket to create an admin screen, the user asks: "create a delinquency view by unit, with a weekly alert and permission for managers only". The AI generates the interface, the query, the permission, the test, the documentation, and maybe a controlled deploy. Software stops being just a project and becomes an organism continuously tended by agents. But it opens two paths: disposable software (generate, use, throw away, and regenerate when needed — maintenance dies in some layers) and instant legacy (millions of lines no human ever read, integrated into critical systems).

AI may not end legacy. It may create it at industrial speed.

My bet: we'll have both at once, in different layers of the stack — and "archaeology of AI-generated code" becomes a profitable service.

3. The differentiator stops being software and becomes operational knowledge

Confidence: 85%

Code gets cheap. What gets expensive is deeply understanding the business, the data, the processes, the constraints, the risks, the customers, the real operation, and the reasons previous decisions were made. The advantage won't be "I have devs who code"; it'll be "I have context, data, history, integrations, processes, and agents trained to operate this domain better than my competitors". In the post-AI world, operational knowledge becomes the product.

4. Teams will have more agents than people — and professionals will sell their agent networks

Confidence: 75% (75% on the first part; 55% on the second)

Each senior will have a personal network of agents — code, test, security, infrastructure, documentation, product, finance, incidents — and will be judged by their ability to assemble, coordinate, train, and audit that set. A senior with good agents will look like a mini-company, serving multiple clients at once. Recognized professionals will license their processes, templates, skills, and validation flows. Methodology becomes a product, and the résumé of the future may say not just where someone worked, but which agents they know how to operate.

5. Your production capacity becomes a vendor subscription

Confidence: 80%

This is the thesis the market prefers not to discuss. If software production comes to depend on frontier models, APIs, and closed platforms, you stop controlling part of your own productive capacity. What happens when the price triples? When an update changes the behavior of the model that powers your pipeline? When a policy blocks a use case, or a geopolitical decision restricts access?

Software was an asset: you wrote it, it was yours. AI production capacity may become rented land. Open models, local execution, multi-model routing, caching, and fine-tuning stop being cost optimization and become a strategy of operational sovereignty. AI productive capacity may be the new cloud lock-in — and whoever builds an operation 100% coupled to a single vendor will feel it at the worst possible time.

6. The return of the modular monolith

Confidence: 55% (deliberately low — the most counterintuitive bet in this article)

A prediction that goes against the last decade's consensus: AI may make modular monoliths more attractive than overly distributed architectures. Agents work better when they understand context cohesively. Systems with dozens of repositories, multiple pipelines, scattered contracts, and fragmented observability are harder for agents to understand, change, and validate.

Well-organized modular monoliths offer centralized context, clear internal boundaries, simpler tests, and lower risk of inconsistency between services. It doesn't mean abandoning microservices in every case. The provocation is different: AI may not kill the monolith — it may make it more competitive in many scenarios.

7. A "Professional Engineer" stamp for software: technical accountability signed by humans

Confidence: 60%

When agents operate production, the question "who answers when it goes wrong?" stops being philosophical. In critical systems — finance, health, government, infrastructure, payments — the figure of the human technical lead accountable for the delivery may emerge. Even if 90% of the work was done by agents, someone will have to sign off on risk, compliance, and civil liability — the equivalent of a licensed engineer stamping off on a building.

The irony: this may preserve part of human employment not for technical superiority, but for legal, insurance, and institutional necessity — someone to sue.

8. Traditional computer-science education enters open crisis

Confidence: 70%

Enrollment in computer-science programs is already falling in the US. Long curricula train people for tasks that get automated during the course itself; bootcamps that teach only CRUD lose value even faster. The diploma loses force as a sufficient signal of competence, and nothing consolidated replaces it. The question remains unanswered: how do you build technical judgment — the one thing this article says is left for humans — if automation eliminated the practice that created that judgment? (Yes, it's the same wound as the junior thesis. It doesn't heal in 6 years.)

---

Who wins and who loses

Gains ground: The AI Builder who runs agents with judgment. The pragmatic architect who defines boundaries. The risk- and systemic-validation-oriented QA. The platform, security, and cost DevOps. The PO with strategic vision and decision power. The consultancy that sells outcomes, governance, and evolution. The company with organized context, data, and documentation.

Loses ground: The coder of well-specified tasks. The dev who blindly trusts AI output. The purely executor manual QA. The repetitive operational DevOps. The bureaucratic PO who just writes stories. The body shop based on man-hours. The company of tribal knowledge and bad documentation.

---

What won't change

Despite all the transformation, AI doesn't eliminate business ambiguity, cross-team conflict, deadline pressure, badly written legacy, messy data, political decisions, production incidents, indecisive customers, external dependencies, or architecture trade-offs. It solves execution, but it doesn't eliminate responsibility.

And maybe that's the main shift: the more execution is automated, the more important it becomes to know what's worth taking responsibility for.

---

Lines for debate

Twelve statements condensed from the theses above. Agree, disagree, share the one that bothers you most:

1. Your programming job won't be destroyed by AI. It'll be destroyed by another programmer who uses AI better than you.
2. AI's biggest victim won't be the senior. It'll be the junior who still depended on simple tasks to learn.
3. Companies will want seniors who can operate agents, but won't know how to train those seniors.
4. AI's biggest bug will be looking right enough to get approved.
5. A poorly done Human-in-the-Loop is just automation with a human stamp.
6. AI without architecture doesn't accelerate software. It accelerates entropy.
7. AI-generated code without clear boundaries is technical debt on steroids.
8. Companies that treat documentation as a cost are destroying their own agents' fuel.
9. The software shop that sells hours is selling exactly what AI wants to destroy.
10. AI may not end legacy. It may create it at industrial scale.
11. The human may stay in the loop not because they're irreplaceable, but because someone has to sign the responsibility.
12. AI productive capacity may be the new cloud lock-in.

---

Where I'm probably wrong

The five fronts where this article is most likely to fail — knock them down in the comments:

1. The dates. Everything in "1 year" may take three; everything in "3 years" may take seven. Technology changes fast; organizations, contracts, regulation, culture, and budget change slowly. The history of automation is a history of correct predictions with wrong dates.

2. The capability of the models. I assume models, tools, and agents keep evolving at the 2023–2026 pace. If there's a technical plateau, prohibitive cost, or regulatory restriction, several theses slip a lot — and the 6-year scenario becomes the 15-year one.

3. Organizational adoption. Even if the technology exists, companies may not change their processes. Many will keep using AI as an expensive autocomplete inside an old SDLC, and in that case almost none of this materializes on the predicted timeline.

4. The AI Builder itself. I described it as the professional of the future. But if thesis 8 of the 3-year horizon is right, it's a transitional profession — the last human job before part of validation itself gets automated. I include myself in that risk.

5. The social and regulatory reaction. The market may slow automation out of fear, politics, unions, compliance, insurers, or legislation. Technical capability isn't the only force that defines the future.

---

The end isn't the programmer's. It's the end of execution as a comfort zone.

AI doesn't eliminate the need for software — on the contrary, it may drastically increase how much gets produced. What changes is the distribution of value within that production.

Repeatable execution gets cheaper. Code gets more abundant. PRs get easier to generate, interfaces easier to assemble, tests easier to write, documentation easier to produce.

But ambiguity stays expensive. Decisions stay hard. Risk stays real. Business stays full of conflict. Security stays a war. Legacy keeps existing. And responsibility still needs someone to own it.

The final bet: the most valuable professional of the coming years won't be the one who writes the most code, but the one who turns human ambiguity into safe, evolvable, auditable, and useful systems — using agents without being dominated by them.

And a question, for you who read this far: of the 26 theses above, which would you bet a year's salary is wrong? If none — you agree too much with a text about the future, and that should bother you as much as it bothers me.

---

Originally published at adsoares.github.io/the-end-of-the-programmer · 26 theses · 3 horizons · written to be challenged.