The Theme
Over-engineering in agentic programming. That is the theme for this week.
This is Week 98 of building Shokken, my restaurant waitlist management tool. It is on Google Play and the iOS App Store, and it is usable in the US now. The app itself is in decent shape. What I want to write about is the development process around it, because something has changed in the way I work, and I do not think the change is entirely good.
How Code Used to Get Written
Two years ago the problem was the opposite of what it is now. When humans were still the ones touching the code, the failure mode was under-implementation. A product manager would ask for a submit button with five acceptance criteria, and the engineer would do exactly those five things. No less, because the acceptance criteria had to be met. No more, because why write more code than the ticket asked for?
That put a lot of weight on the product owner. If the ticket was not exhaustive, the engineer was not going to fill in the gaps. Corner cases, tests, the awkward paths through a feature — somebody had to ask for them in writing, or they did not happen.
What Agentic Programming Changed
Now the engineer mostly relays. A spec comes in, I translate it for the agents, and the agents write the code. The engineer is no longer the bottleneck on scope, and the failure mode flips with it: instead of doing too little, the system does far too much.
My own example is a daily email. Hermes sends me a message every day with the backend quota and usage limits for the model providers I use. That is all it is. Check the numbers, put them in an email, send the email. It stopped arriving one day, and the cause was not a broken backend, a broken model, or a broken script. One of the tests the agent had written for itself failed — a test that should not have existed in the first place — and because every test was fail-closed, the email did not go out.
Close to six hundred runtime tests. Not deployment tests, runtime tests that run every single day before the email is allowed to send. All of them sources of a reason not to send.
Six Hundred Tests for an Informational Email
I could not remember which test actually failed. That is part of the point. I did not need six hundred tests, I needed one number from each provider, formatted, once a day. And this is not mission-critical information. It is a status email for me. If it cannot reach one provider, the right behaviour is to send the email with a warning about the part that failed, not to hold the whole thing.
Fail-open with a warning would have cost me nothing. Fail-closed cost me the email for a day and a small investigation into a test nobody needed.
The Part That Is My Fault
The agent wrote the tests, but I let it. Part of this came from getting too comfortable with assistants: I stopped reading what they tell me before they do it. The workflow was always the same. I have an idea, I discuss it with the agent, and as soon as the task stops being trivial the agent starts describing every eventuality and every path it wants to handle, and the wall of text begins.
On one session that is survivable. Across several parallel sessions, the wall of text is exactly where the important warning is hiding, and it is the last defence between what the agent says it intends and what actually gets built. I skipped it because the agent usually gets it right. That is the failure: the guard is me, and I stopped standing guard.
Where Over-Engineering Comes From
Diagnosing it is harder than it looks, because there are several places to turn the dial.
The model. Is it quantized, is it strong enough, and what thinking level is it running at? A high thinking level on a simple task is the definition of overthinking: tokens churning on a decision that should be quick.
The harness. Hermes sends a lot with every request — MCP servers, skills, memory, the whole context. A more complicated request invites a more complicated answer.
The configuration. The SOUL file that describes what the agent is and how it likes to work, the skills that Hermes writes from past interactions, and the memories of what I said before. Any sentence in there that encourages thoroughness can end up encouraging a six-hundred-test email.
Why the Fix Is Not One Switch
The model may not be mine to choose, and the models are trained to be careful: over-engineering is the safer failure mode from their point of view. The harness is more complicated than it looks. The files are the part I control, so the fix has to be multi-pronged rather than a single setting.
Review rounds are the interesting trap. Every reviewer I add can find a way to strengthen the thing I am building, and strengthening it is how the complexity gets in. I do not have the answer yet, and I do not think the community has converged on a Goldilocks zone between over-engineering and under-engineering. It is an evolving field.
The Weekly Videos
The other thing I have been fighting is the two weekly videos, Tuesday and Thursday. The first one came out well and the ones after it did not come out right at all. Somewhere in the automated production pipeline inside Hermes, the output keeps drifting from what we already agreed on, and I have not yet found the point in the process where it diverges.
This is the biggest lie we tell ourselves about agents: that with agentic assistance everything becomes trivial. It does not. It is a tool, and using a tool well still takes skill, experience and judgement. That the video pipeline is the place where I cannot yet reproduce my own results is a useful reminder of that.
What I Am Watching
I do not have a clean ending for this one. The email will be simplified, the configuration will get shorter, and I will keep watching for the point where review starts adding weight instead of value. If I get the video pipeline to behave, that is probably next week’s topic.