My AI Agents Have Two Problems: They Think Too Small and Build Too Big
My AI coding agents are remarkably good at making two completely opposite mistakes.
The first thinks too small. It reads a few files, finds something that looks like an established pattern, and copies it. The change works. The tests pass. Repeat that a thousand times and you’ve accumulated a mountain of technical debt.
The second thinks too big. Ask it to fix a bug and suddenly we need three database tables, four abstractions, and a thousand lines of unit tests to prevent something that might happen once in a billion operations, with consequences nobody would notice.
Both agents are trying to write good software. Neither is necessarily exercising good engineering judgment.
After years of experimenting with AI at Terros, I’ve come to believe that teaching agents to navigate between those extremes is one of the most important parts of AI-assisted software development.
We call our approach #TABE, short for:
Think Ambitiously. Build Economically.
Coding with AI
We’ve been coding with AI at Terros since 2023, starting with GitHub Copilot. We’ve seen several generations of tools come and go, and we’ve kept adopting the ones that let us give agents more responsibility. In 2024, we adopted Cursor and Windsurf. In 2025, Claude became part of our development workflow. In 2026, we experimented with OpenClaw and Firstmate. Today, we’re using Sergeant, our own system for coordinating autonomous engineering work, and Grok Bot.
At first, we were happy when AI finished a line of code or suggested a function. Then we wanted it to handle an entire ticket. Now we want agents to investigate, implement, test, and review work without a human guiding every decision.
For years, we’ve been pushing toward the same goal: less babysitting. Not just faster code generation, but useful engineering work that doesn’t require constant supervision.
Yet each time we give agents more independence, the same two mistakes surface. Left alone, they either repeat the nearest familiar pattern without questioning it or build far more machinery than the problem deserves.
The bottleneck isn’t generating code. It’s knowing what should be built.
The thousand-paper-cut engineer
An agent gets a task, searches the codebase, reads a handful of nearby files, and copies a pattern. The trouble is that the pattern might be a workaround from years ago, not something we’d choose today.
The agent doesn’t always distinguish what exists from what should exist.
Imagine a slow dashboard. The ticket suggests adding a cache. The agent finds our caching utilities and adds one, complete with invalidation logic and tests. The dashboard gets faster.
But what if the real problem is one database query per team member? A single batched query might solve it without a cache at all.
The cache is a plausible patch. The batched query is a better design.
Each small patch can look reasonable. A thousand of them can leave you with an architecture nobody would deliberately choose.
The cost of a thousand individually reasonable decisions.
We don’t want agents merely reproducing the codebase we have. We want them helping us build the one we should have.
The billion-dollar solution to a ten-dollar problem
The opposite agent sees an edge case and sets out to eliminate it. A reviewer finds a rarer race. Another reviewer proposes another safeguard. Every objection is technically valid, and the solution keeps growing.
We recently saw a deletion fix reach 39 files, including a new table, a background function, and an event stream. Each review round had uncovered another possible race, and each race acquired more code.
Then someone asked whether an index on the existing table and a change to the existing workflow could do the job.
It could, with one accepted trade-off: a record written in a roughly one-second window might survive until its normal expiration. We understood the probability and impact, documented the gap, and kept the simpler design.
We’ve seen similar excess with tests: an agent can produce a thousand lines of coverage for trivial business logic without meaningfully reducing risk. Tests are valuable when they protect something that matters; volume isn’t the objective.
Reliability matters. But reliability isn’t free, and not every conceivable failure deserves a new subsystem.
Think ambitiously
I’ve been writing software for about 30 years. Over that time, one habit has helped me make difficult design decisions: first, imagine the ideal solution.
What would I build with unlimited time, money, and engineering resources? What if I weren’t constrained by the code that’s already there?
What would the system know? Where would responsibilities belong? Which categories of bugs would simply disappear?
That’s the moonshot. I’m not trying to produce a plan to build it. I’m trying to understand the direction we ought to travel.
Thinking is cheap. I can spend a few minutes imagining a system that would take years to implement, and that exercise can still change what I decide to build today.
For example, suppose an update API lets someone change a record’s owning company. The obvious patch is a new validation check that rejects a company change.
But in the ideal model, ownership may not be editable at all. Remove it from the update input, derive it from the stored record, and an entire class of bugs becomes impossible. You might change more code than the tiny patch would require, yet leave behind a simpler system.
Understand the direction we ought to travel.
That’s what I mean by thinking ambitiously: look for a better model, not merely a smaller edit.
Build economically
Once I understand the ideal, I return to reality and ask: What’s the nearest valuable step we can take in that direction today?
A good step solves today’s problem completely, pays for itself even if the larger vision never happens, and keeps our options open.
- Imagining a general rules engine doesn’t justify building one for a single notification.
- Imagining a plugin ecosystem doesn’t justify a plugin framework for one integration.
- Imagining perfect reliability doesn’t justify an elaborate defense against every theoretical race condition.
But the smallest diff isn’t always the economical choice, either. Five lines that add another special case may cost more over time than a larger change that removes the underlying confusion.
I judge a change by the complexity it leaves behind, not the number of lines in the pull request.
That’s how we improve the system: through thousands of small changes that each earn their keep.
Teaching agents to do both
A slogan won’t magically give an AI agent good judgment. We continue to find better ways to make TABE a repeatable habit in our engineering instructions, in Sergeant’s implementation, and in our review workflows.
One practical change is to separate a ticket into three things:
- The intended outcome. What must be true when this is finished?
- The binding constraints. Security, authorization, compatibility, and product decisions that cannot quietly change.
- The proposed implementation. Useful context, but sometimes only an educated guess at the best approach.
The first two are requirements. The third deserves investigation.
The best designs make a hard problem look simple. Photo: Cody Hiscox on Unsplash.
If the code reveals a materially better approach, I want the agent to take it and explain why. But it can’t decide to deliver less than we asked for, change a product behavior, or relax a security requirement just because that would be easier.
Reviewers need the same discipline. It’s not enough to examine whether each line is correct. We need them to ask whether the whole change is the simplest correct design.
Could we fix the cause rather than the symptom? Can a concept disappear instead of acquiring another layer? Is an edge case likely and consequential enough to justify the permanent complexity of defending against it?
Independent reviews can accidentally become an engine for overengineering. One reviewer discovers a rare possibility, the agent adds a defense, and the next reviewer discovers a still rarer one introduced by that defense. Someone has to ask whether the entire solution still makes economic sense.
We’re learning. Sometimes an agent needs encouragement to question the existing architecture. Sometimes it needs someone to say the solution is already good enough.
The ideal is a direction, not a bar every change must clear.
The best code might be the code we don’t write
AI has made it dramatically cheaper to produce software. An agent can generate a thousand lines in minutes.
But those lines still have to be understood, reviewed, operated, debugged, and eventually changed or removed.
I don’t want our productivity measured by how much code we produce. I want us solving important problems with systems that remain understandable and adaptable.
Sometimes that requires thinking beyond the immediate ticket. Sometimes it means accepting a well-understood limitation instead of building elaborate defenses against it. Sometimes it means deleting code instead of adding more.
While AI coding agents pushed me to put this philosophy into words, I think it applies well beyond software. Whether you’re making a product decision, shaping a team, or tackling an everyday problem, imagine the ideal outcome first. Then choose the smallest worthwhile step toward it.
That’s TABE: Think ambitiously enough to recognize the right solution. Build economically enough to avoid implementing everything you imagined.
Hero image source: Unsplash.