↓ Skip to main content

Every abstraction layer was deterministic until this one

·466 words·3 mins

We’ve worked at seven layers of abstraction in software engineering: Assembly (on punch cards), Assembly (on screens), C, C++, C#, Python, and now the agentic harness that sits between us and the code.

Each move up a layer let one engineer say more with less. The first six had one thing in common: they were deterministic. Give a compiler the same code and you get the same program, every time. Most of what we know about building software assumes that.

The seventh layer isn’t deterministic. Give an agent the same prompt twice and you can get two different results. Much of what we carried up from the first six still holds. Tests, version control, code review and CI matter more now than they ever did. But they aren’t the patterns that will help us most at this layer.

We already know how to make non-deterministic systems write great code
#

The patterns that help most are the ones engineering leaders have always used for the other messy, non-deterministic system in the building: People.

When we hire a senior engineer, we don’t give them superuser on the production database on day one. We give them context, put quality gates around their work, and widen their access as their track record earns it. Evidence before autonomy. This exact same pattern works for the new messy non-deterministic system we’re adding to our teams: Agents.

Everyone moves up two layers
#

For engineers, this year is a career change rather than the next step in the same role. We no longer build the systems. We build the systems that build the systems.

Think of it like you’ve moved two notches up the org chart. One layer up, you should still be hands-on some of the time. Two layers up, stay hands-on for your own learning, occasionally dip into individual PRs, but mostly spend your time on the work only you can do. Either way, you’re still responsible for what goes into production. What’s changed is that two kinds of messy, non-deterministic system now write the code, and your job is to give the agents underneath you the information and the quality gates they need.

The engineers I see finding this hardest have written code for a long time but never managed people. Their identity is “I write the code”. The ones who adjust quickest centre their self-image on the outcome.

If you’ve led a team of humans through ambiguity, you’ve already done most of the training for the change that 2026 brings. If you haven’t, the people-management basics are where to start, because they’re the tools and techniques you’ll be applying to your agents.

I wrote about the quality side of this in Trusting the code agents produce, and the context side in Treat your LLM like a new starter.