Why I Let the AI Make Mistakes on Purpose
I built my AI agents so they're allowed to make mistakes, and I did it on purpose. A mistake I can reverse, sitting behind a person's approval, costs me almost nothing. A perfect system I never ship costs me something every day, because shipping speed compounds and polish doesn't.
I built my AI agents so they're allowed to make mistakes, and I did it by design rather than by accident.
For most of my career, that sentence would have horrified me. The operator to builder transition changed what I'm willing to tolerate far more than it changed my job title, and this was the hardest belief I had to give up.
Where the Instinct Came From
For fourteen years I ran operations inside large businesses, some of them doing Rs.200 Cr to over Rs.1000 Cr in revenue. In that setting a mistake was rarely small. A wrong number on a dispatch sheet stopped a production line, a missed compliance step could shut a plant, and a careless commitment to a client meant a weekend of firefighting for forty people.
So I built a reflex: nothing goes out until it can't fail. Check twice, then check again. For me, zero defects was a survival rule rather than a slogan.
When I started building my own systems, first for MetMov and then for the AI work under anjanipandey.com, I brought that reflex with me. It felt like discipline, and it turned out to be the thing holding me back.
The System That Never Shipped
My first serious AI project was a content agent. It was supposed to take a topic, write a full set of posts and hand them to a person to publish.
I spent weeks hardening it. I added guards for cases that had never happened and wrote handling for inputs I would never receive. Every time it got close, I found one more way it could embarrass me, and I went back in. In all those weeks it produced nothing, and the reason was my refusal to let it run until it was perfect, a day that never came, rather than any flaw that stopped it working.
One evening I did the arithmetic that changed how I build.
The Number I Was Ignoring
I had been optimising the wrong quantity. I was trying to push the probability of a mistake down to zero, when what matters is the cost of a mistake. That cost has three parts: how big the error is, how hard it is to reverse and whether a person sees it before it acts.
A mistake that is small, reversible and caught before it does anything costs close to nothing. The one that hurts is large, permanent and invisible. I'd been paying a huge hidden price to avoid the cheap kind of error, while the expensive thing, a system that never ran, cost me something every single day.
What I Changed
I stopped designing for zero mistakes and started designing for reversible ones. My agents are now allowed to be wrong in specific, limited ways: an agent can mis-tag a task, draft the wrong reply or put a file in the wrong folder. I treat these as the normal wear of a system that ships, and I don't count them as design failures.
Three conditions make this safe, and I hold all three without exception.
The first is that the mistake must be reversible. Anything an agent does on its own has to be something I can undo in seconds, like renaming, tagging, drafting, sorting or summarising. Those are the safe verbs. The dangerous verbs are sending, paying, posting, deleting and committing to a person outside the company, and no agent gets to use those alone.
The second is that a person approves anything irreversible. The moment an action reaches the real world, whether it's a message to a client, a payment, a published post or a deleted record, it stops and waits for me. The agent proposes the action and a person decides. In a normal week I click through roughly forty of these approvals, most of them take a second, and that second is what it costs never to wake up to a mistake I can't take back.
The third is that every failure gets logged loudly. A silent failure is the one kind I refuse to accept, because a mistake I can see is a mistake I can fix, while a mistake that hides in July has become the standard by September.
A Concrete Example
Last week one of my agents tagged a personal reflection as a MetMov business post. On paper it was a small error. In practice the two brands are meant to stay separate, and mixing them is exactly the kind of thing I care about.
The approval step caught it before anything was published. I saw the wrong tag, changed it and moved on, and the whole thing cost one click and about five seconds.
Now take the other version. Suppose I'd chased zero defects and, once the agent seemed reliable, let it post on its own. The same small error would have gone out in public, on the wrong brand, with nobody checking. The size of the mistake was the same in both versions; what changed was when it got caught, and that decided everything.
The Exception Becomes the Standard
There's a second reason I make failures loud: a quiet exception doesn't stay an exception for long. The mis-tag the system gets away with once, because it was minor, is the mis-tag the system treats as acceptable from then on. The workaround allowed in July is the default by September, and that's as true of teams as it is of software.
Loud logging is how I stop small tolerances from hardening into permanent behaviour. When every deviation announces itself, I decide on purpose whether it becomes a rule, and nothing slips in just because nobody mentioned it.
The Same Lesson Applies to People
What surprised me is how well this carries over to people. When a capable person joins a growing business, founders often expect them to be flawless from day one and then get frustrated when they aren't. That's the same zero-defect reflex, pointed at a human being.
The better design is the one I use for agents. The firm gives the new person reversible responsibility first, meaning work that can be undone. It puts a review step on the irreversible actions, such as client commitments and spending. And it makes problems cheap to raise out loud instead of expensive to admit, because people, like systems, improve by doing the work rather than by waiting on the bench until they're perfect.
Why This Is the Builder Mindset
The operator protects the current operation, which is the right instinct when a mistake can stop a line. The builder protects the rate of learning. Nobody learns anything from a system that never runs, or from a person who is never allowed to act.
Shipping speed compounds, because every day a system runs it teaches me something the perfect version on my laptop never could. Polish doesn't compound; it only delays the first lesson. No course taught me this, and fourteen years of operations taught me the opposite reflex, so building my own systems is where I had to unlearn it.
That's the shift underneath the operator to builder transition. The builder stops asking how to make sure something never fails and starts asking how to make failure cheap, visible and safe enough to ship today.
The Principle
I no longer try to build a system that can't make mistakes. I build one where every mistake can be undone, every irreversible action needs a person's approval and nothing fails silently. Then I ship it before it's perfect, because it never will be, and the waiting is the most expensive thing I own. A reversible mistake I can see costs me less than a perfect system I never ship.
Where in your business are you still paying for a system you're waiting to perfect, instead of running one that's allowed to fail safely?