There are bugs in Aient right now that I know about and have decided not to fix. Budget, not confession.
Every senior engineer knows the arithmetic; few say it out loud. How defect-free a piece of code is tracks how much effort you sink into it. Tests, review rounds, formal models, reproduction rigs, verification in production. Each buys down the probability of wrongness, and each costs time you are not spending elsewhere. Correctness is not a virtue your codebase has. It is a thing you purchase, per line, at prices that vary wildly. Which means the real engineering question is never "is this correct?" It is "was this worth making correct?" For most of your codebase, the honest answer is no.
Bugs are not equally priced
Anna, interviewing me, played devil's advocate: do you even need bug-free code? Most often, no. Sometimes, absolutely. If your product does not work for your end users, those bugs are critical, and beneath them hangs a cascade of smaller judgements. Maybe the user has to retry once and that is fine for your case. Maybe a race only appears under load you simply do not have; if nobody triggers it, spending a week on it buys you nothing today. On the other hand, fixing it now is probably cheaper than fixing it after you have grown, and then you get to grow on a sounder platform. Every one of those sentences is a price tag, and teams that refuse to read them end up overspending on ghosts while their customers hit the crash that was never prioritised.
The failure mode has a shape. A team that treats correctness as a moral property spends uniformly: every bug is an affront, every fix is virtuous. A team that treats it as a budget spends where the users are: the crash your customers hit today outranks the theoretical race, and the theoretical race outranks nothing at all until the load arrives.
How Aient spends today
We built this arithmetic into the product, and the honest version is that the gating is economic. When Aient detects a problem, remediation runs autonomously for the most severe classes; milder problems are surfaced, and the code-level subset remediates when you ask it to. An autonomous remediation attempt costs real money in model time, sandbox time, and verification, measured in euros rather than cents, and spending that on every low-severity blip would be exactly the uniform-spending mistake above. The dial exists; today we set it by severity on your behalf.
The part we want to build next is handing you the dial itself: you choose how hard Aient tries, and the harder it tries, the more defect-free the outcome, at a price you picked. Turned up, the dial buys concrete things. Deeper reasoning for the agents. Critic subagents, where a default bug fix gets none. Review passes through architecture, security and performance lenses rather than correctness alone. End-to-end tests in a sandboxed desktop with the reproduction recorded on video before and after the fix, which is the strongest validation we know how to produce; that rung exists in our infrastructure today, though its economics do not, yet. Formal models where the invariants warrant them.
The range is real, and I can price it from my own ledger. Default remediation lands between six and ten euros of model spend per bug, varying with the problem. My own development of Aient, at the far end of the dial, averages about 160 dollars of model spend per pull request. Both are correct purchases for what they buy. A side project in vibe-coding mode and a payment pathway should not be bought the same amount of correctness, and no vendor should be deciding that ratio for you.
Two entries from our own ledger
The bug from the first paragraph lives in onboarding. Link your GitHub account and you land on the repository picker before the sync behind it has finished, so for a few hundred milliseconds the page announces "No repositories found", and then the repositories arrive. It looks dodgy. It is also harmless: the data is eventually consistent, nothing downstream acts on the empty state, and the blast radius is one moment of jank. Fixing it properly means modelling the interleavings of three state machines at once (onboarding, the GitHub sync, and the UI) plus a typed loading state for every combination, a purchase far past what a flash of wrong copy costs. While I am a solo founder pricing by system correctness first, that purchase stays refused. It helps that our users are increasingly agents rather than humans; agents onboard through an API and never see the picker.
The opposite entry is the remediation core, the part that reads your telemetry and writes to your repository. I have spent close to nine thousand euros of model credits getting it right. At one point I set an agent the goal of dogfooding the system in an architecturally sound way; it produced three virtual objects whose interleaved executions exploded the state space, and when I then asked the harness to keep finding and fixing bugs, it kept finding them for two days without running dry. The honest reading was not "nearly done" but "the number of bugs here is large to a degree we cannot know". So we changed tack: formal models proving the invariants that matter (one active remediation per problem at a time, monotonic epoch handovers), simplification passes that collapsed the interleavings into a single serialisable object, and a ten-day, mostly autonomous refactor to land it all. Expensive, and the correct purchase. This is the code that touches your production and your pull requests; correctness here is the product.
The floor
A budget without a floor is just negligence with a spreadsheet. Some correctness is not discretionary. Aient itself is a multi-tenant, concurrent, distributed system written as crash-only software, and the invariants that make that survivable are documented and enforced; when we break one anyway, it becomes a post-mortem our agents read so the lesson is not relearned by hand. Code that moves money, touches security boundaries, or holds other people's data sits above the budget line permanently. The dial governs everything else, and "everything else" is most of your codebase. Treat it all as equally deserving and the parts above the line are the ones that end up underfunded.
Three questions before you pay
The budget reduces to three questions, and they work whether or not you use Aient:
- Is anyone actually triggering this? Runtime evidence beats static suspicion. A defect nobody reaches has a price of zero today, and only today.
- What does wrongness cost when it fires? A retry, a corrupted record, a lost customer, a breached boundary. These are different products; buy accordingly.
- What does the fix cost now versus later? Now is usually cheaper. That is an argument for fixing early, not for fixing everything.
A bug that fails all three is not technical debt but a correct purchase decision, and you should be able to say so in the standup without apologising.
The repository picker still flashes its little lie. It will survive this post, too.