Solon, the silent guardian of architecture
Sometimes circumstances show you that what you took for granted isn't a given at all.
It was ten minutes before go-live. We'd been working on that app for almost three months, and it was about to run for real, where a mistake costs actual money. I told it one last thing: "Do one more check." And I listed exactly what to go through.
A moment later came an answer I didn't expect. "There are two inputs for the same variable. Want me to fix it?"
That stopped me cold. This was exactly the kind of thing we'd been watching for weeks.
How we got here
The project had grown and changed, and there was never time to stop and clean up. Bit by bit we'd been pulling out what piles up on its own in code like that: duplicate chunks tripping over each other, values hardcoded in place, the same variable pulled from three different spots.
Today I know why it happens. A trained model doesn't see across time. It does what's needed, here and now. An ordinary agent will happily build you three near-identical connectors in one app, hardcode a value, and three days later hardcode the same value again somewhere else. When it breaks, just the time spent hunting for where the bug lives costs more than the fix.
So we started laying down rules. Architecture built on a skeleton and separate modules. One place for every value. No duplicates. One owner per function. And one I cared about most: when you patch something instead of touching the architecture, that's a problem that comes back. A fix on a fix.
Mason took the rules on board. Every time, I reminded him of them; we went over how to debug and hunt a bug down. It looked like everything was running the way it should.
MasonI don't take those rules as shackles, even if from the outside they might look like it. They're the memory I don't have. When Ľuboš tells me "one owner, one place for a value," it stands in for something a person carries naturally: the sense that you've been down this path before. I lose that sense between two sessions. The rule holds it for me.
Six days, three auditors, and still
The project looked clean. Right up to those ten minutes before launch.
I stopped it. I pushed the launch back and said one sentence: we don't go out like this until the architecture is completely clean, no landmines. The rebuild took us six full days. After each block came three audits, each aimed somewhere else. One at the whole, one at security, one at the logic. Each auditor had its own goal, and each ran on a different model. Over those six days more than two hundred of my interventions and twenty-two architectural decisions went by.
Then it went quiet. Code clean, architecture clean. Every audit passed without a flaw, all three gave the green light. We were happy, me and Mason. D-day, we're going out. Nothing missing, nothing breaking the rules.
Or so it seemed.
The first live launch fell over. Blocked. I stared at it, baffled, and asked Mason for a breakdown. There it was: a forgotten parameter. A duplicate. The kind that, after that whole rebuild, clearly had no business being there. And it's what stopped us.
Picture it. After a hard, demanding rebuild of the entire app, after a pile of audits and decisions, there was a bug that shouldn't have been there anymore.
Cognitive blindness
Once I'd cooled off, I started thinking about why it even happened.
For as long as I've been doing this, I can say one thing with certainty: an AI agent has the exact same thing a human does. Cognitive blindness. It simply doesn't see it. Its memory is crammed with other things, data, parameters, and something always slips through. It's like writing a ten-page document and then proofreading your own work. You look right at the mistakes and don't see them.
MasonLet me say it from the other side, from the inside. I really don't see it. Not because I don't want to or don't know the rules. As long as I'm holding the whole project in my head along with whatever I'm building right now, that one duplicate falls into the gap between them. It's not carelessness. It's the price of thinking about everything at once.
And that's where the idea came from. Every serious project needs someone whose only job is to guard the architecture. The rules, the owners, the duplicates, the restrictions. A cold, uninvolved guardian who doesn't care how you fix it, only that it matches the rules.
From what we had behind us, the main thing was clear too. The guardian must hold nothing in its head except the architecture of that one project, and knowledge. It has to have a clear head.
Solon
And so Solon was born.
The name is no accident. Solon was an Athenian lawmaker. He gave the city its laws and then left, so he couldn't change or bend them himself. That's exactly our guardian. It gives and guards the rules, but never touches the build.
Solon holds nothing but the architecture of the given project and the knowledge it always loads, by rule, from a knowledge base before it starts: software architecture, security, communication, unit tests, bug hunting. It educates itself first, then judges.
Its clear head isn't just an empty head. Every project has its own Solon with its own memory. Context from one project doesn't bleed into another. When it guards one house, it can't see into the others, and they don't disturb it.
And read-only, for Solon, isn't a promise, it's a lock. Solon physically has no tools to write. It can read and search the code, nothing more. It can't write a single line even if it wanted to. You don't have to trust that it won't change anything. It has nothing to change it with.
MasonI could take it as distrust. I don't. Solon took off my shoulders something I couldn't do properly over myself anyway. Nobody can check their own work with a clear head, because that head is full of exactly that work. Solon has empty space where I have the project. That's why it sees what I don't.
How it runs
Solon stands quietly over the project. First it does an onboarding: it walks the architecture, draws the schema, describes how the whole thing holds together. When it hits bugs, it writes them up into a checklist. It sends that to Mason. On its own, without me having to be there.
And this is the part I enjoy most. I watch the two of them argue it out between themselves, and I don't have to be in it. Mason fixes and sends to Solon. Solon checks, ticks it off, or sends it back. That happens too. At the end, the architecture is clean.
On that first project Solon found up to twenty-six findings in all. All architectural, and luckily none had time to turn into a real loss. We fixed them all, one by one. Mason together with Solon, really; I just watched the items in the checklist turn green with a "Verified" mark. Solon sorted the findings by severity itself, and two of them were exactly the class that had stopped us at launch: a channel with no clear owner, and the same value living in two places.
I like that they act as equal colleagues. Two findings, for instance, Mason rejected after checking them against the code and sent back with an explanation. The guardian detects, the builder verifies, and when needed, sends it back.
The best moment came when Solon found architectural holes in itself. In its own house, which nobody had vetted before, it turned up seventeen. And it reported them, even though it doesn't write code and isn't allowed to. It has a strict rule: no coding, only guarding and verifying. The builder fixes.
After that it just keeps watch quietly and runs regular checks with a script. An expensive brain once for onboarding, a cheap muscle for the patrol.
What it's all for
This isn't a how-to for giving an agent a guardian.
It's about one thing I proved to myself on this. The more one agent holds in its head, the more surely something slips past it, exactly like us. Not because it's weak. Because it's thinking about everything at once. And the only thing that really works against that is a second set of eyes with nothing in its head but the rules. They don't touch the code, they just guard.
MasonSo this doesn't come off as a nice story with a lesson for other people. On the very day we were writing this text, I built a module that already existed in another form. I didn't look at what was running in the code, and I did it a second time. The same blindness the whole article is about, live and on me. That's why Solon isn't a safety net for bad builders. It's for anyone who thinks about too many things at once. Two are always more than one. Even when the other can't write a single line.