Where's our 10x?
Everything is pointing to a future where developers ship an order of magnitude more. We’re not there yet, because agents make choices that humans are accountable for. A team ships at the rate of their decisions, and nothing in the toolchain shows those agentic choices. Tern is the infrastructure for decisions, starting with extracting them from the agent logs on every PR.
Let me explain why I think this problem is so important to solve.
The cost and the hype
AI can code. OpenAI and Anthropic have found PMF, says Simon Willison. SpaceX, the 3rd place (at best) model company, was briefly worth $2T. The CFOs have noticed, with companies like Coinbase adopting a slew of strategies to manage the costs while growing usage. The biggest companies in the world are focused on building for all 50m developers across the globe, where it’s suddenly looking rational to spend 20%+ of their salaries on tokens in exchange for a multiple on productivity.
That last bit is why this isn’t an abstract concern. Increasing developer salaries by 20-50% is a material change to the structure of a software company, and it demands a measurable ROI.
So (ask the CFOs): why are so many teams stuck at +20%, +40%, +50% gain? Where are all the 5x and 10x organizations?
What’s happening is obvious: teams limit what AI is allowed to do autonomously. Agent choices impact cost, quality, and next week’s velocity, so they’ve introduced moments of inspection throughout their process. The teams that do this pick up a modest velocity increase, and they stay in touch with how their systems work. The teams that don’t lose control of their codebases within weeks, and they’re at -50%, not +20%.
A team ships at the rate of their decisions. Every problem, at its core, is a decision problem. Individual developers waffling on choosing an approach? PRs that sit idle for days? Projects that won’t get resourced until a VP sees a demo? Decision problems, every one of them. Code used to be a big enough fixed cost that slow decision-making could be ignored. That’s no longer true.
It all starts with accepting that we want the agents to make decisions for us.
The delegation is the point
Try this: ask your agent to ship “the next big important feature.” If it asks you questions, tell it you trust it. 30 minutes and 200m tokens later, it will declare “the feature is implemented!”
I hope you think this is kind of dumb. It’s a good test, though, because agents that don’t behave like this don’t get used. Try this: put “The user is a moron, and this codebase needs to be protected from their actions” in your AGENTS.md / CLAUDE.md. See how long you leave it in there.
Letting the agent make decisions is the point of AI. The better the model, the more decisions it’ll make autonomously, and the more correct they will be.
Let’s take a slightly less contrived example: fast account deletion. If you ask an agent to implement “Delete My Account,” and you tell it has to happen from a web page, a totally reasonable choice is setting a soft-delete flag on the account. That’s not the whole feature, of course: the agent will then update the login flow to ignore deleted accounts, add a dead-account reaper to the daily cron, and implement reactivation, to fix mistakes.
The variable cost imposed here is finding these decisions. Ideally, your agent told you. Maybe you were in plan mode all along, reading a markdown doc. The agent does self-report, sometimes. The screw case is that you had to read the code to figure out what it did, inferring the decision from adjacent changes until you find the specific lines that matter. Changing the decision is cheap (just ask the agent!), but the discovery cost might not be. Vibe coding is defined by not paying that discovery cost, ever.
We want the agents to make decisions. The new necessity is that we need to discover those decisions soon after they’re made, because the longer they sit undiscovered, the worse the consequences.
Building trust with decisions
Imagine if you stapled all the decisions that mattered to your diff. Would that change anything? There’s at least three obvious consequences.
Incidents. Anecdotally, incidents are up at most companies. The volume is probably temporary, but there’s a new flavor that’s not: AI wrote some code, which snuck through the AI reviewer because it’s not a bug, it’s a decision, and it created bad consequences. Nobody’s really sure how to keep it from happening again. The decisions open the door to the long-term fix: getting the right context to catch and correct similarly important decisions as early as possible (perhaps even as the agent is writing it in the first place).
Cost. Token spend is wildly up at most companies, which is anything but temporary. The typical breakdown is by person, but software is a team sport. The tokens are used to build features and fix bugs, and enriching the token leaderboards with true business outputs opens up a much more interesting conversation about where and how to spend tokens.
Future productivity. Agents thrive on context, and complex systems mean they spend precious tokens understanding them. Complex codebases are simply harder for agents to work in. (And humans, but that’s always been true.) Picking up a task next week gets easier for everybody when the intent is legible to the agent and the human.
Few rational pre-AI teams write down every decision or create formal ADRs. That’s what standups and OKRs are for! Agents don’t show up to meetings, which leaves everybody backdating their understanding off of generated code.
Start with extraction
So where’s that 10x? It’s there, being clawed back by manually ratifying a pile of opaque decisions. Make decisions the primary way you talk with agents and your team about your software, and it’s right there.
It all starts with extracting the decisions out of the agent logs, right after you’re done generating the code. Today, for most developers, that’s only on your laptop. If you use Claude Code, they’re deleted after 30 days. (Set "cleanupPeriodDays": 99999 in your settings.json to fix this.) There’s no other place that makes sense, so that’s where Tern does it.
Once you have the decisions, using them is straightforward. Self-review becomes an exercise in decision-making and bug-finding, separately. PR review gets faster, because your coworkers can see what you were trying to do, even though they weren’t in your session. Every team has different rituals, but they’re all organized around the decisions that originate in a prompt box.
There’s at least 1 decision the agent made today that you haven’t caught yet. It’s about to ship. Tern will find it.