What Breaks When You Build With AI Agents for Six Months

I started building LaudBot in March 2026. It is an invite-only AI agent that answers questions about my background: a recruiter gets a link, asks what they want, and it answers from approved sources only.

The plan was to build it almost entirely with AI coding agents. That part worked. What did not work was everything around it, and the failures were not the ones I had been warned about.

The failures I expected did not show up

I expected hallucinated APIs and confidently wrong code. Those happened occasionally, and they were easy: code that does not exist does not compile, and code that is wrong fails a test. The feedback loop is tight and the damage is contained to the session.

The expensive failures were slower and quieter.

Decisions evaporated. Early on I settled how auth would work: two roles, strictly separated, visitor and admin. Weeks later a session proposed a third role because it made a feature simpler. It was not wrong given what it could see. It just could not see the decision. I re-litigated that one more than once before I understood the shape of the problem.

Conventions drifted. Not dramatically: a slightly different error-handling pattern here, a different file layout there. Each one defensible in isolation. After enough sessions the codebase read like several different people had written it, because in a meaningful sense several different people had.

Nothing left a trail. At some point I found a workaround in the payment path with no comment, no useful commit message, and no memory of why it was there. I had to reconstruct my own reasoning from the code. The commit was mine. The reasoning was gone.

The common thread: agents are stateless and session-local, and I was treating them like colleagues who remembered yesterday.

Prompting harder does not fix it

My first instinct was better instructions. Longer preamble, more context, explicit reminders about conventions. It helped a little and then stopped helping.

The reason is structural. A prompt is a request. Nothing enforces it, nothing checks it afterward, and the agent is not being negligent when it drifts. It genuinely does not have the information. Asking more nicely does not create a memory it does not have.

What I actually needed was for the environment to carry the state, so that being right was the default rather than something re-derived every session.

So I built the thing underneath

That became The Rig. Started 8 April 2026, two and a half weeks after LaudBot began, because by then I could see the shape of what was missing. It is MIT-licensed and past 450 commits.

Structured memory that survives the session. Not a transcript dump: a small set of files with defined jobs. Decisions with their reasoning. A progress log. An errors file so the same wrong turn is not taken twice. A context snapshot written before the session ends, so the next one starts oriented instead of cold.

Hooks that enforce rather than request. Ten of them across the session lifecycle, plus an adapter so the same contracts work under Codex as well as Claude Code. They fire on session start, before and after tool calls, before compaction, and on stop. A commit without secret scanning does not happen. A write to a protected path does not happen. The difference between "please do not" and "you cannot" turns out to be most of the value.

A task lifecycle. Work has to exist as a task file before it becomes code, and the task file carries the goal, the approach, and afterward what actually happened versus what was planned. That last field is the one I would keep if I could only keep one.

Commit discipline in the hook layer, not the guidelines. Conventional commits, enforced. Secret scanning, enforced. History rewrites on published branches, blocked.

There is a bats suite in CI, because a framework that enforces discipline while having none itself is a joke with a long setup.

What I would tell you if you are about to do this

Write down decisions the moment you make them, not at the end. By the end you are reconstructing, and reconstructed reasoning drifts toward whatever you now believe. This is the single highest-value habit and it costs almost nothing.

Fix the class, not the instance. When an agent violates a convention, the fix is not correcting that file. It is asking why the convention was not visible at the moment of writing. I lost weeks to instance-fixing before this landed.

Enforce mechanically wherever you can. Anything checkable by a script should be checked by a script. Guidelines are a request; hooks are a guarantee.

Keep something you built by hand. I still maintain a CRM I wrote in 2019, before any of this existed. It is the reference point that tells me whether a thing is hard or whether I have just forgotten how to do it myself.

The part that surprised me

The Rig is now under the projects I work on most often. I did not set out to build a tool. I set out to build a chatbot, hit a wall, and discovered the wall was more interesting than the thing I had been building, because the wall was general and the chatbot was not.

That is not a story about AI being bad at coding. The code was mostly fine. It is a story about a working process that was implicit in my head and needed to become explicit in the repository, which is a problem software teams have been solving for decades. The agents just made it impossible to keep ignoring.