Welcome to Code for Humans and Machines!
Designing software that remains understandable for humans while also being machine-legible and transformable by agents.
In the beginning
In the beginning, there was code. Lots of it. And not all of that code was, shall we say, in the best possible shape. Then came the machines, first learning from that code, and then beginning to write it themselves.
Today, AI is transforming the software industry—and yet, we’re only getting started.
Why code still matters
Great code is no longer just readable. It must be machine-legible and transformable.
If AI cannot understand your code, you need to guide the agents with clear, structured, and concrete examples. This publication explores the principles, techniques, and refactoring patterns that shape how we should design software in the AI age.
Today, anyone can create a non-trivial software product. In fact, you can do so without knowing how to code. AI has come a long way.
However, writing the initial version of a product was never the key challenge. (That’s not to say it’s easy—there are enough infamous examples of systems that never shipped.) Most of the cost comes after the initial version is shipped, assuming you have product–market fit and customers.
The more successful your product, the stronger the pressure for new features and improved capabilities. This is where software design and architecture start to matter.
In 2026, my research colleagues and I published a paper on AI-friendly code. In short, we found that to do a good job, an AI agent demands better code quality than a human would.
Let’s repeat that, since it’s so important:
To minimize defects, keep token costs reasonable, and ensure your AI implements the right thing, you need to care about code quality.
But won’t AI become good enough to work on any code?
AI for coding has evolved at a ridiculous speed, and it’s tempting to believe that the future will be even brighter.
So instead of thinking about software design, perhaps we could all just relax and let time (and Big Tech) do its job?
I’ve been hearing that argument since early 2023. And so far, we’re not there.
It’s not an unsolvable problem, but several forces work against it:
AI reflects its training data. Coding models are trained on real codebases…and most real codebases are not great.
LLMs lack an objective measure of what “good” looks like.
Without clear structure and intent, AI becomes directionless. It can — and will —modify code, but it cannot reliably understand it.
That last point matters more than it might seem. When code does not communicate intent, every change becomes speculative, for humans and machines alike.
The software engineering renaissance
Fortunately, AI is still immensely useful even in the worst possible spaghetti code. It just needs direction.
And this is where you, the software professional, comes in.
Programming might be dead, but software design is more relevant than ever.
To perform well, agents need structure. That structure comes in the shape of:
Consistency: predictable structure, obvious places to look
Documented principles and constraints
Reusable know-how (what we might call “skills” today)
Alignment between problem and solution domains
No surprises: because surprises are expensive, for both humans and machines
At this point you might wonder: weren’t these concepts important pre-AI? Absolutely. Great software has always been built on this foundation.
The difference in the AI era is speed: mistakes, ignorance, and shortcuts compound at machine speed. We can no longer get away with sub-standard architectures, nor can we compensate for poor design by throwing more people (or agents) at the problem. Clean code is not enough—we need great software design.
What you’ll find here
This publication is about making code easier to understand, safer to change, and more predictable to evolve by both humans and agents.
Much of that work comes down to structure.
A large part of the problem with poor-quality code is a lack of modularity and a failure to communicate intent. When code hides what it does, everything becomes harder:
It is difficult to find the right place to make a change
It is risky to modify behavior without breaking something else
It is expensive for an AI to even locate the relevant logic
This publication takes on that problem. It’s all about code that machines can safely transform.
Agentic coding is harder, not easier
Sometime in late 2025, I wrote my final lines of code. I wasn’t aware of it at the time, but that day marked a transition after almost four decades of programming. I’ve created and shipped plenty of code since then, but with one key difference: that code wasn’t written by hand. It was written by AI agents that I directed.
Surprisingly, I don’t long for the old days. I find agentic coding more rewarding, and the shift isn’t as large as I would have expected. It still feels like programming, just with larger steps and faster feedback.
That said, I’m grateful for those years of manual coding. Without that experience, I wouldn’t have been able to steer coding agents in the right direction, nor would I have known what and how to correct in the resulting software design (those corrections being agentic too, of course).
Why this publication exists
The short answer is that I simply love to write, and I enjoy developing software. Hopefully that shines through.
So what to I have to share? I’ve spent decades working with software systems across domains, paradigms, and organizations. Over time, certain patterns keep appearing. Some of those patterns transform a solution to make the code easier to work with, while others make the design more fragile.
In the AI era, those patterns matter even more.
In my next posts, I’ll share:
refactoring patterns that improve structure and intent
design principles that make code easier to evolve
and occasional reflections on topics that interest me, for example what the developer role is becoming
Because one thing is clear: The future of software development is not less engineering. It is engineering at a higher level of abstraction.