I No Longer Write Code, I Build The Systems That Do

I started programming at fourteen in pure C++. I managed memory manually, wrote every line by hand, and debugged with print statements and prayers to the sky. You understood every instruction because the computer did exactly what you told it to do, and when it failed, it was your fault. I am thirty-seven and I still write code every day, but what I do has irrevocably changed. A large part of the industry still does not understand this shift.

The model of the human as a typist

For decades, a programmer’s job was to translate an abstract intent into machine instructions. You had an idea, figured out the algorithm, typed the implementation, tested it, and shipped it. The bottleneck in this process was always human performance: how fast your brain could think and how fast your fingers could move.

Tools improved with heavy IDEs, linters, autocomplete, and frameworks, but the core loop was the same: a human writes code and a machine executes it. We relentlessly optimized this loop by building better languages and editors, but it was always a human typing endless instructions.

The shift toward systems design

Something broke in the last few years. It is not about AI helping you program faster, that is the superficial view. The shift is deeper. The job is no longer typing; the real job now is designing the system within which the code writes itself.

Think about what happens when you build with advanced assistance. First, you describe the core intent. Not the implementation, the pure intent: you need a service that processes webhooks, validates the payload against a schema, writes it to a queue, and handles retries if it fails. Then, the system generates the complete implementation. It writes the code, the tests, the error handling, and the logs. Finally, you evaluate and constrain the output. You decide if it does what you wanted, if it is secure, and if it fits into the existing architecture.

Steps one and three are the only work left. Step two is done by the machine. The only skill that matters is no longer your typing speed or your ability to memorize APIs, it is now pure systemic thinking.

What this means in practice

In my daily work, I spend most of my time building infrastructure instead of writing application code. That infrastructure defines the rigid boundaries where agents operate safely. It establishes what they can do, what is forbidden, how they communicate, and what happens when they fail. Autonomous agents write the actual code; I build the world they write it in.

This is a different skill set from manual programming. You are no longer implementing a simple feature, you are defining a space where complex features emerge naturally. You set constraints, build guardrails, and design the fundamental rules of the game instead of just playing it.

The uncomfortable truth

Here is what nobody wants to say out loud: the vast majority of what we spent decades learning to do by hand is now done by a machine in seconds. That includes spinning up basic endpoints, implementing standard algorithms, writing boilerplate, and generating unit tests.

The only thing that cannot be automated yet is deep systems work. Understanding why a specific architecture solves a particular problem. Knowing the technical tradeoffs that matter. Designing to prevent failure modes you have seen before and making the nuanced decisions that require years of scars, not just data.

That is why I am not worried about artificial intelligence replacing real engineers. I am worried about engineers who refuse to make the shift. If your only value proposition is saying you write code very fast, you are playing a losing game. If your value is designing complex systems that solve real-world problems, you are more valuable than ever.

The new craft

A new craftsmanship is emerging. It is no longer about writing elegant code, it is about designing elegant systems. Robust systems where the correct behavior is the path of least resistance. Systems where AI agents can be productive without being a danger. Systems that do not fail, not because every line was reviewed by a human, but because the foundational architecture prevents disaster.

This is much harder than manual programming. You are working at a higher level of abstraction, thinking about emergent behavior, and anticipating how a system will operate when you do not control every line of code. But it is also an infinitely more creative job with a much larger impact.

Closing the loop

I started my career building video game engines, which are nothing more than systems where the rules of the world are explicitly defined and complex behavior emerges from them. Today I spend my time building agent runtimes, which are systems where execution rules are defined so that useful behavior emerges naturally.

The more things change, the more they stay the same. The craft of programming was never about typing, it was always about systems. We just spent a few decades pretending otherwise because machines were not ready yet, but now they are. Those who will thrive in this era will not be the ones who see this as a threat, but the ones who understand that this is exactly what we were training for all along.