LogoValérian de Thézan de Gaussan

Good software stays easy to change

ValerianValerian
November 15, 2026
5 min read
Table of Contents

Oh, it feels good when a user asks for something and you already know it’s a five-minute job, tests included.

You know the system. You know where the change belongs, the boundaries are clear, and you know exactly what to tell the AI agents. You can give them a precise task and check the result without having to investigate half the application first.

That’s one of my favorite things about working this way. It’s also a pretty good indication that the software is in good shape.

I’d like it to stay that way after the next hundred requests.

The problem with locally reasonable decisions

The usual way to lose that simplicity is to keep adding things without reconsidering what’s already there.

An agent gets a feature request, reads the relevant code, and finds a way to fit it in. The change works. Then we do it again. Eventually, a business rule lives in three places, components depend on each other in unexpected ways, and every new request needs another exception.

This is exactly what happened before AI agents. People kept building on top of existing code and never made time to refactor. There was always another feature to deliver, and the awkward structure was someone else’s problem until it wasn’t.

Each change could be reasonable on its own. The trouble was that nobody was checking whether the overall structure still made sense.

We can repeat that with agents, only faster. Or we can use them to make that checking much cheaper.

Taking a system apart until I understand it

I’ve refactored countless systems, and I’ve always started the same way: taking everything apart until I understood how it worked.

Where does the data come from? What happens to it? Which component makes each decision? Why does this step exist? I’d keep digging until I could explain the whole process, including the parts that initially seemed pointless.

Before AI, I remember making a draw.io diagram with hundreds of boxes for a client, just to understand a data integration. It was ridiculously complicated for what it actually needed to do.

But I couldn’t safely simplify it based on that impression alone. I needed to work through the details and distinguish actual requirements from complexity that had accumulated over time.

Once I understood it, I replaced it with a straightforward process that still runs today.

The diagram wasn’t the deliverable I cared about. It was how I got enough understanding to know what I could remove, what I needed to preserve, and how to put the rest together.

That understanding is much cheaper now

Today, I can ask agents to work through a codebase, trace a workflow across components, map dependencies, and produce reports in very little time. Work that used to require days of reading and drawing can now have a useful first pass ready while I’m investigating a specific part.

I still need to check their conclusions. A plausible report isn’t proof that a system behaves the way it says. I ask for references to the code, follow the important paths myself, and use tests to check the behavior we’re relying on.

But it’s a much cheaper way to get an overview and decide where to look closely. I don’t need to wait until a system becomes unmanageable to justify that effort.

For a change that crosses several parts of the application, I can ask the agents to map the affected responsibilities before implementing it. If they find the same rule in several places, or need to touch unrelated components, we can investigate why. Sometimes the request genuinely requires that. Sometimes it’s a good moment to simplify the structure first.

That also gives me something better to review than a diff in isolation. I can check whether the change fits the system, whether it introduces an unnecessary dependency, and whether the next similar request will be easier or harder.

Keeping the next change simple

I don’t expect to get the architecture right forever at the start. As the product changes, some of the original boundaries will stop being useful. I’d rather adjust them than keep forcing new requirements into a structure that no longer fits.

AI makes both the investigation and the refactoring cheaper. It seems wasteful to use it only for adding code.

The five-minute change at the beginning of this article is possible because I understand the system and because its structure gives the change a sensible place to go. Keeping that understanding up to date is part of the work, especially now that we can change so much code so quickly.

That’s what I want to preserve: a user asks for something, I know where it belongs, and we can get on with it.

This is the second of four follow-up articles to Cheap to build does not mean disposable.