Operating notes · Note 04
June 3, 2026 · 6 min read
Agentic practice
Agentic

When fat controllers
stop working

The pattern fixed a context-window failure. The same essay that argues for it writes the exit. Steller has not published a claim that it has already left.

↓ What they were for
01
Context window

They were a design
for the window, not the org chart.

The unit of architecture in Built From the Rubble is the context window, not the service boundary. Steller’s earlier shape split the order flow across services an agent could not hold at once. The order service published an event. The wallet service subscribed. A fix in the file on screen left the consumer, the wallet debit, the Bamboo call, and the webhook invisible.

Fat controllers were the repair for that specific failure. The golden flow — wallet debit, Bamboo vendor call, PIN return, webhook dispatch — lives in one controller, readable top to bottom. Hangfire carries background work as a named class. PlaceBambooOrderJob can be grepped, opened, and read, including the wallet rollback when Bamboo fails. One repo. One docker compose up -d, which the rubble essay treats as the deploy. The backend AGENTS.md adds the limit on that command: do not treat compose success as application readiness. Its where-to-look table names OrderService.cs for order financial logic, BambooApiClient.cs for the vendor, and Steller.Infrastructure/Jobs/ for background jobs. The rubble essay’s line remains that AGENTS.md says which file to open first.

The front end moved with the same motive: two Vue.js 2.6 dashboards became React 18, TypeScript, and Vite. A mandatory API response envelope and flattened permission tables removed shapes the agent had to rediscover. None of that is a claim that a fat controller is elegant. It is a claim that an agent can trace the path that moves the order.

“Every time I asked the agent to fix an order flow bug, it changed the right service — but broke two others it couldn’t see.”
Built From the Rubble
02
What they fixed

Four costs dropped
because the path was visible.

The scorecard in that essay is the list of what the pattern was for. Context went from a fragment of the system to a single repo whose golden flow is one file. Orientation went from fifteen to twenty minutes of “which service handles this?” to about two minutes. Debugging a flow went from tracing a message through three or more services to reading the controller top to bottom. Rollback went from saga choreography to explicit code in the same path. Deploy went from N services to one command and one log stream.

Background work changed category. Implicit event names became named classes. The infrastructure around RabbitMQ — exchanges, bindings, dead-letters — stopped filling the window before the business logic did. Hangfire, in the scorecard’s words, is a package and a Postgres table.

Those are the fixes. They are fixes for an agent-operated golden flow of one product: a B2B middleware between partners and gift card vendors. The pivot that installed them took 27 days and $672 in Cursor spend, and the rebuild shipped with zero critical defects in production. The defect-counting method is not published. The duration and the spend are.

The Complete Story’s correction still applies. This was a redesign that made the platform rescuable by AI. A fat controller is not a reward for using a model. It is the condition under which the model can see the flow.

03
Exit

Three exit conditions
are already written.

The limits chapter does not wait for a sequel. It states when fat controllers stop working.

01
The team grows
Past a handful of engineers, several people editing the same controller create the merge conflicts microservices were designed to avoid. The context-window argument fades when humans can hold the context themselves.
02
Paths must scale apart
If the Bamboo integration needs many times the resources of catalog sync, one controller cannot scale those paths apart. Independent scaling becomes impossible.
03
The domain gets large
A controller that handles dozens of flows is not readable to a human or an agent. The essay’s line for Steller is specific: one golden flow, not forty.

I am not announcing that any of those three has arrived. Steller’s published position is the opposite of an exit: one golden flow, zero full-time developers, a team of one human and several AI agents. Writing “we outgrew fat controllers” would contradict the essay that defined the pattern. The exit conditions are constraints to watch, not a migration I have dated.

There is also no published queue SLA, no published request-volume chart, and no second golden flow in the essays. Those would be the sorts of measurements that could show an exit. They are not in the record, so they are not in this argument.

04
Not a ban

Microservices were
not the villain.

The lesson, as published, is that microservices are wrong for a team of one human and several AI agents. For a large human team, the essay calls that shape a feature. Separate services, a queue as the contract, a saga for rollback: those are ordinary designs. They became hostile when the only engineer in the session could not see past the file it had loaded.

The replacement the limits chapter offers, if the system grows, is not “more RabbitMQ.” It is domain-bounded services with explicit, synchronous interfaces. Not event-driven, and not invisible. The agent still has to hold the relevant flow. The boundary is allowed to return when a human team can hold it, or when one file would hide dozens of flows. The boundary is not allowed to return as a hidden consumer.

Greppable jobs stay on the near side of that line. PlaceBambooOrderJob is a name. An event with no type an agent can search is not. Even a future split should keep the forward path and the compensating path readable together. The scorecard’s rollback row is the requirement: explicit rollback in the same file as the forward path, for as long as that file is the design. A synchronous call across a domain boundary can be read. A binding in a broker cannot, not by the agent that only opened the publisher.

Decision rule, from the essay. Design the architecture so an AI agent can hold the entire relevant flow in a single context window. For Steller at the published stage, that meant fat controllers. For a larger system, it might mean domain-bounded services with explicit, synchronous interfaces.
05
Back to the window

Stop when the window
can no longer hold the flow.

Fat controllers stop working when the reason they were introduced is gone or overwhelmed. The reason was a context window that could not see a distributed order flow. They stop when several engineers need to edit that controller without colliding, when one integration must scale apart from another, or when “the flow” has become dozens of flows. They do not stop because a diagram looks cleaner with more boxes.

Until one of those conditions is true in the published system, the operating rule stays the one the principles chapter prints. Keep the golden flow in one file. If the agent has to cross a service boundary to read the path from request to response, merge the services. Name the job. Point AGENTS.md at the file. Ship with one command.

I will update this when Steller publishes a second flow or a team past a handful of engineers. I will not update it to sound ahead of the product. The pattern is a constraint that fit a B2B gift card path operated from Mississauga with agents. It is not a law, and it is not a phase Steller has claimed to finish.

Next in the series
Note 05 · Operating notes
Why Explicit Jobs Beat Invisible Events for AI
Named Hangfire work, and the Bamboo locks around it.
Read the essay →