
Debloating does not make a system simpler. It moves the complexity to where a person never has to look at it. With AI agents building around the clock, that holds only when the ceiling is stated as a number or a rule, because taste does not survive that much output.
Thirty-five destinations, collapsed to nine
The clearest example is a navigation restructure. One of our apps had grown to thirty-five peer destinations in its sidebar. Every capability the product had ever shipped had its own place to click. My instruction for fixing it was one sentence: this is a very large app, but the complexity must not be passed to the user.
The plan that came back collapsed thirty-five destinations to about nine. It rests on a principle the whole product now follows: capabilities are not destinations. An agent uses memories, schedules and datasets constantly. A person almost never goes to look at them directly. Giving every capability a sidebar entry confused what exists with what a person needs to navigate to.
The other twenty-six are still there, and the agent is the one navigating them, which is the point of Agents are the primary users.
The same rule applies one level down. Weeks later a project selector and an agent selector had each collected scrollbar bugs, redundant options and visual noise. That needed no redesign meeting. It needed the same question asked of a single component: does a person need to see this every time, or does the system only need it to exist somewhere?
Why is debloating a repeatable operation?
I run it the way I would run a linter, against anything that has started to put on weight. One evening I sent the same cleanup instruction to three unrelated internal business apps, three seconds apart: debloat this, simplify it, make it useful for finishing the one job it exists to do. If a debloat pass works on only one app, it was never a rule.
It has since become tooling. A set of design passes runs separately against polish, distillation, visual noise, typesetting and interaction states: five or six narrow passes instead of one vague instruction to make it look nicer. I can call it by name when a product starts to drift.
The word also covers decoration and language. A design pass through the product removed arbitrary drop shadows, flattened depth that carried no information, and moved the palette from a busy slate to a calmer neutral. A billing screen that described a signup bonus in dollars was rewritten so the product only ever talks about credits, its own unit. Two ways of describing one mechanic is one more concept the reader has to translate every time.
Ceilings stated as numbers
None of this can stay a matter of taste. Left alone, agents will add a fourth navigation item, a second way to configure the same setting, a dropdown for an edge case that affects one percent of users. Each addition looks reasonable on its own.
Bloat is never one bad decision; it is a thousand locally reasonable ones with nobody adding them up.
So the discipline rests on hard limits, the kind described in Hard limits are governance:
- Every file stays under seven hundred lines, and a monolith gets split into thin modules with clear owners.
- The interface’s block registry is capped at a fixed number of runtime types.
- Two languages must reach exact feature parity before either ships, enforced by the type system.
A cap does not limit what the product can do. It limits how many ways the product may describe the same idea. That is the sprawl that becomes thirty-five sidebar items when nobody puts a number on it. None of these rules is interesting to write down. They are written down because a fleet of agents would otherwise find a plausible reason to break each one, one at a time.
The version of debloating people resist most is deletion. A cross-project coordination panel on one of the product’s hub pages had its own logic, its own state and its own edge cases, and almost nobody used it the way it was designed. We removed the panel and put a plain list of the last few projects in its place, sorted by recency, click to open. A feature nobody asked to keep is bloat with a name and a maintainer.
Where does the complexity go?
It has to go somewhere, and choosing where is the design decision. Our layout engine is one example. The model emits a semantic layout, flat blocks and sections on a grid, and never raw pixel coordinates. A deterministic placement engine on the other side resolves the coordinates. The model reasons about structure, the engine does the placement, and neither has to hold the whole problem at once.
I usually say three words together: elegant, scalable, debloated. They are one discipline seen from three sides. Elegant means the code keeps the promise the product makes. My whole feedback on one piece of routing logic was to ask why it was locked to a single model provider when the product’s premise is provider flexibility. Scalable means the cleanup does not make next month’s feature harder to add. Without those two, debloating produces an interface with fewer buttons and the same assumptions sitting one layer down.


