Before the Tolkien scholars reach for the comments: yes, Aragorn was also in The Two Towers.
So was I. He just hadn't become king yet.
Unfortunately for everyone involved, neither had I.
Previously, in The Two Agents:
I had defined the architecture. One Codex was implementing it. Another was independently trying to prove that it hadn't.
The failures were getting smaller. I was beginning to think my job was simply to define the destination and get out of the way.
Then I opened coordinator.py.
What say you
By iteration four, this was starting to feel suspiciously automated.
The implementing agent changed the code. The reviewing agent compared it against the architecture. Findings went back to the implementing agent.
Tests passed.
Repeat.
I was not writing any of it.
“There is something strange at work in this land.”
Not because a test was failing. Not because the reviewer had raised a finding.
I was trying to understand where the remaining responsibilities had ended up.
And then I found this:
for reason in (*poll_reasons, *alert_result.urgent_poll_reasons):
self.commands.ask_car_urgently(reason)Nothing was obviously broken. The coordinator received some reasons. It asked the car to poll urgently.
The tests were green.
The code was readable.
I hated it.
Why did the coordinator know this?
The alert machine had decided that something was urgent. Somehow the coordinator was now interpreting that decision and choosing what should happen to the polling behaviour.
It was only a few lines. A tiny piece of policy. Exactly the sort of tiny piece of policy that invites some friends over, starts receiving mail and six months later owns the building.
The coordinator was supposed to sequence the machines.
It was starting to have opinions.
Again.
Calling it a coordinator did not necessarily make it one.
Putting a steering wheel on my desk doesn't make it a Volvo either.
So I interrupted the iteration.
The alert machine should decide that an urgent poll is required. It should emit that decision as an intent. The application boundary should apply the effect. The coordinator should pass it along without understanding what it means.
AlertMachine → PollIntent → ApplicationCommands
No cross-machine mutation. No polling policy in the coordinator. No new god object quietly forming in the space where the old one used to be.
Codex changed it.
The independent reviewer then assessed the updated implementation and confirmed that the coordinator was now sequencing rather than deciding.
There was just one problem.
The reviewer had assessed the implementation after my intervention.
The implementation-review loop had not caught this.
I had.
Well.
That was inconvenient for the experiment.
I had an implementing agent. I had an independent architecture reviewer. I had given both of them a target architecture.
And somehow I was still here, staring at four innocent-looking lines and asking why they felt wrong.
This was not a syntax error. It was not a failing test. It was not even particularly bad code.
No generic coding convention was going to save me by declaring:
Thou shalt not loop over urgent_poll_reasons in a coordinator.The problem was where the decision lived.
You look at a class called Coordinator and notice it has developed a small but concerning interest in energy policy.
Architecture is not hidden somewhere inside the repository waiting to be extracted. The code describes the present.
The architect is responsible for the future.
Ask an agent to infer both from the same repository and the future starts looking suspiciously like the present with more files.
Someone still has to say stop
What's more, something deeply inconvenient happened.
The reviewer passed it.
Not “looks good.” Not “tests are green.” Not “significant architectural improvements have been made,” which is AI for please stop asking me questions about this pull request.
It passed the target architecture.
poller.py was gone. Four independent state machines owned their decisions. The domain objects owned their state and capabilities.
The coordinator coordinated.
A sentence that had somehow taken five iterations to make true.
Polling and command effects went through the application boundary. The legacy facades were gone. The architecture tests were in place.
794 tests passed. Three skipped. Ruff passed. git diff --check passed.
I had reached the point in the story where I was supposed to announce that Codex had succeeded where Claude failed, add a benchmark chart with no methodology, and spend three weeks arguing with strangers on LinkedIn.
Unfortunately, that wasn't what happened.
The two agents had finally converged on the architecture I had given them.
Almost.
The reviewer still had one complaint.
The charge state machine used an isolated mutable working set internally rather than being completely functional and returning immutable next-state objects for every transition.
It was right. A perfectly pure implementation would be cleaner.
It would also require another substantial functional rewrite for very little practical gain.
I evaluated the trade-off and said:
So naturally, after spending an entire article complaining about architectural compromises, I created GitHub issue #81 and ignored it.
This is also architecture. Pragmatic architecture.
At some point, someone has to decide that the remaining imperfection is understood, isolated and not worth turning Tuesday evening into a rewrite of the state-transition model.
We had what we came for.
Good enough.
Ship it.
So I did.
Wattson went back into production. It polls the house. It watches the car. It tracks the monthly peak. It coordinates charging with the energy available at home.
The four state machines do their jobs.
The coordinator does not appear to be developing opinions.
My car charges exclusively from sunlight while Belgian grid operators look towards the horizon and whisper my name in spite.
And poller.py remains exactly as large as I wanted it to be.
Zero lines.
Guess what: I am still here
I once joked that the final article would be called:
“Brenden walks out of the codebase (because AI took his job)”
There is just one small problem with that joke.
I checked how many lines of the Wattson refactor I had written.
Zero.
Not approximately zero. Not “mostly generated, with some manual cleanup.”
Zero.
poller.py ended with exactly the number of lines I wanted.
So did my contribution to the implementation.
Well.
That complicates things.
Because AI did take part of the job.
It wrote the state machines. It migrated the domain logic. It deleted the old abstractions. It updated hundreds of tests. It performed most of the architecture review.
It went through five rounds of implementation and review while I contributed exactly zero lines of production code.
And the result works.
My car is charging. My house has not burned down (yet). Belgium continues to have an electricity grid. My mother-in-law still sticks her too-large nose into my affairs.
So perhaps I did walk out of the codebase.
I just didn't walk out of the engineering.
The first Codex implemented four state machines. The second spent five iterations trying to prove that they were not actually four state machines wearing legacy architecture underneath.
Neither of them decided that Wattson should have four state machines in the first place.
That was my job.
And even after I had defined them, I was still the person looking at four innocent lines in a coordinator and asking:
Why does this know that?
That surprised me.
And then, in hindsight, it really didn't.
Because this is already how I work with engineering teams.
I am rarely the person rewriting the 5,000-line god class. I am the person trying to understand why it became a god class, what the domain actually looks like and what architecture we want on the other side.
The team implements it.
I keep the shape of the system in my head.
The team just got considerably faster.
But somebody still has to look at a 500-line god facade and understand why 500 is not meaningfully closer to zero.
The agent can implement a state machine. Another can review it.
Someone still has to decide that the system should be a state machine in the first place.
Three Codexes walked into a codebase.
Except there were only two.
They wrote every line of the refactor.
The third wrote none of it.
Apparently, that was the one we couldn't remove.
.
.
.
.
“Now come the days of the King. May they be blessed.”
.
.
.
.
Of course we're not done.
This is Return of the King.
You didn't seriously think there would only be two endings?
Since we're apparently doing the extended edition and accidentally ran three experiments, we might as well collect the results.
The Fellowship of the God Class asked whether good engineering practices were enough to discover the right architecture. They weren't.
The Two Agents asked whether, once I defined that architecture, agents could implement and review it without me. They could.
The Return of the King asked what was left when they did. Turns out: deciding where we're going, noticing when we're not getting there, and knowing when we're close enough.
Apparently I did lose a job. Just not the one I thought.
F***. I'm still here.
Copilot awaits a codebase.
