How AI Is Changing Software Engineering: a 2026 field report
AI hasn't replaced software engineers. It has moved the bottleneck. The cost of writing code dropped to near zero; the cost of deciding what to build, how to architect it, and when to ship became the whole job. A field report from a year of running production work in agent mode.
I have been writing software professionally for over a decade and a half. The last fifteen months of that have changed more than the previous ten years combined. This page is what I would tell a working engineer in 2026 who wants to understand what is actually happening, not what gets shouted on the conference circuit.
The headline is short and concrete:
AI has not replaced software engineers. It has moved the bottleneck.
The cost of writing code dropped to something close to zero. The cost of deciding what to build, how to architect it, and when to ship became the whole job. Everything else flows from that.
What is no longer the work
For most of my career, a meaningful share of a working week was typing. Boilerplate. Translating from a clear specification to a verbose language. Stitching API responses together. Writing tests that exercised mechanical paths through code I had just written. Updating documentation after the refactor. None of that was the hard part. It was where time went anyway.
In agent mode, a competent model handles all of it. I describe what I want at the spec level. The agent reads the codebase, proposes a change, generates the code, runs the tests, and reports back. The cycle is measured in minutes, not days. The typing portion of my work has effectively disappeared.
This is the change that gets all the noise. Yes, it is real. Yes, it is significant. But it is also the least interesting part of the shift, because typing was never the bottleneck of good engineering. Anyone who has shipped production systems for a few years knows that.
What is suddenly the work
When the typing goes away, what is left becomes louder. Specifically:
Deciding what to build. A model will happily build the wrong thing very fast. The cost of a wrong decision used to be amortized across the weeks it took to implement. Now the wrong thing arrives in an afternoon, and you have to live with it or back it out. Specification quality matters more than it ever has.
Architecture choice. Code is cheap; architecture is permanent. Module boundaries, data flow, the shape of the public surface, the integration points with the rest of the system. The agent does not have a strong opinion about any of this; it follows the lead you set. If you set a bad lead, the agent generates a lot of code very confidently in the wrong direction.
Review and judgment. I read more code now than I ever have. Most of it I did not write. The reading skill, evaluating whether a stretch of code is correct, whether it has the right error handling, whether it interacts cleanly with the rest of the system, has become the primary engineering skill. Writing code was once 60% of the job. Now it is closer to 10%. Reading code is closer to 60%.
Knowing when to stop the agent. Agents will keep working. They will refactor what does not need refactoring. They will add scaffolding for problems you do not have. They will silently make architectural decisions while you are getting coffee. The discipline to interrupt, redirect, and reject is the new craft.
Time horizon compression. What used to be a two-week project ships in two days. The implication is not that there is suddenly more leisure. The implication is that you can run ten parallel two-day projects across the same calendar. Which means you need ten times the judgment about which ones are worth running.
The shape of the work is fundamentally different. Not less, just different.
This is not vibe coding
There is a term going around: "vibe coding." It refers to typing a prompt at a model, looking at what it gives you, feeling roughly okay about it, and shipping. The vibe is right. The code went somewhere. Good enough.
That is not what disciplined AI-assisted development is, and the distinction matters. I wrote a separate essay on this: AI-Assisted Development Is Not Vibe Coding. The short version: agent mode in the hands of an experienced engineer is a force multiplier. The same tools in the hands of someone who never learned to read code carefully produce confident-looking output that nobody can confidently maintain. The market is going to discover the difference at significant expense.
Hold the line on engineering discipline. Tests still matter. Code review still matters. The architecture decisions you make at the start still determine what you can build later. The agent does not absolve you of any of that; it just removes the typing.
The skills that compound now
After fifteen months of running production work this way, here are the skills I see compounding fastest:
Specification writing. The ability to describe what you want with enough precision that a model can do the right thing on the first try. This is not a soft skill. It is the new core competence.
Code reading at speed. You will read more code than you write. The faster you can absorb an unfamiliar codebase, identify the meaningful surface, and notice what is wrong, the more leverage you have.
Architecture instincts that hold under speed. The agent moves fast. Your architecture intuitions need to be loaded into reflexes, not derived from first principles every time. The senior engineers who already had this are now five times more productive. The ones who never built the muscle are exposed.
Knowing the system you are operating in. Production infrastructure, CI/CD, observability, security. The agent will happily ship code that runs perfectly in a sandbox and explodes in production. Knowing how the real environment behaves is, if anything, more valuable now.
Stopping yourself. Restraint is engineering judgment. The temptation to do more, faster, just because you can, is the most expensive new failure mode.
The arc this site has been tracing
This is not a take I formed this month. The shift has been visible for over a year. I documented it in real time across a seven-part series:
- Part 1, The Awakening: what it felt like the first time a model produced code at machine speed.
- Part 2, The Methodology: the working pattern that emerged after the initial shock.
- Part 3, Infrastructure: when the same agent workflows moved into Dockerfiles, CDK stacks, and CI pipelines.
- Part 4, Content Pipeline: how the discipline ports from code to long-form writing.
- Part 5, Business Apps: production-grade business software built solo with AI.
- Part 6, Future Impact: the economic and professional implications.
- Part 7, Advanced Patterns: the patterns that emerged once the work had run for months.
The book-length treatment is AgentSpek, available on Amazon in paperback and Kindle, and free to read here in full. AgentSpek goes deeper on the specific working patterns, what to delegate, what to direct, and where the edges of agent mode actually are.
What this means for a working engineer in 2026
Three concrete recommendations:
Spend more time on the spec, less on the prompt. A good specification produces good code. A clever prompt produces clever-looking code. They are not the same thing. Treat the agent like a junior engineer who reads very fast but cannot read your mind. Tell it precisely what you want.
Invest in reading. Read code from other people's repos. Read it from the agent's output. Read it from your own past self. The reading muscle is the one most engineers underdeveloped because they got away with mostly writing. That window is closed.
Keep shipping things end to end. The temptation in this moment is to over-think, under-decide, and spectate the discourse. The advantage compounds for engineers who keep shipping real software in this new mode, learning what actually breaks, and adjusting. The longer you wait to actually use these tools at production stakes, the further behind the curve you fall.
The work changed. It did not get easier. It got more concentrated, more leveraged, and more dependent on judgment. The engineers who already had judgment are now operating at multiples of their previous output. The ones who were coasting on typing volume are exposed. The honest field report is: this is the best time to be a careful, disciplined, production-minded engineer that I have seen in my career.
Continue reading
- AI-Assisted Development Is Not Vibe Coding, the standalone essay on the distinction
- AgentSpek, the book-length treatment, free here and on Amazon
- The AI Development Revolution series, seven parts written in real time
- What I'm Building Right Now: May 2026, the current workstreams
- What Is People of the Stars?, the temporal framework that runs alongside the work