Teams are writing more code with AI than ever, and trusting less of it. Here's why, and what we built about it.
This is written for lean teams shipping with AI, small and scaling, because that is who we built Superpositional for and who feels this first. Start with the good news, because it's real. 80% of developers now write code with AI tools. 78% say they're more productive, and some say 10x. The Linux Foundation finds AI roughly halves open-source coding time. Small teams are shipping volumes of code that would have needed twice the headcount two years ago.
Now the part that doesn't make the pitch deck. Trust in AI output has fallen to 29%. 45% of developers name "almost right, but not quite" as their top frustration, and 66% say they spend more time fixing that almost-right code. 96% don't fully trust AI-generated code; only 48% always verify it. The Linux Foundation counts a quarter of incoming open-source PRs as slop. More code arrives, more of it needs checking, and the checking lands on whoever knows the codebase best.
We think the cause is specific, and fixable. Spend ten minutes on r/cursor or r/ClaudeAI and the same words come up: "not following CLAUDE.md at all", "ignores rules even with alwaysApply: true", "it just does what it wants to do", "a one-file patch becomes a 20-file diff you never authorized". Two in three developers say their AI misses context, and 44% of those who've watched AI make their code worse blame that rather than the model. The agent isn't wrong because it's dumb. It's wrong because the memory it works from is old. Superpositional was built for that.
The problem: context goes stale the moment someone pushes
Agents in Cursor and Claude Code are only as good as the context they are given. Most teams give them a rules file, a CLAUDE.md, a few architecture notes. All of it was accurate the day it was written. None of it knows about the push that landed an hour ago. The agent still trusts it, writes a change that looks right, and something downstream breaks that nobody told it about.
Context files are a maintenance job nobody owns. A 10-line change can rename a shared helper, shift an API contract or move a failure path, and the rules file says nothing about it. On a lean team there is no platform team to own the file, which is why the context problem lands on small and scaling teams first.
Review then inherits the blind spot. A reviewer, human or AI, who sees only the diff cannot tell what else depends on the changed line, what tends to change with it, or whether the change undoes an assumption three files away. On a lean team with agents, PRs arrive faster than anyone can hold that picture in their head, so one senior holds it and everything queues behind them.
The result is the "wait, what else did that touch?" message after merge, the regression nobody can trace to a PR, and a growing habit of reading agent output more carefully than the agent reads the codebase. That is the trust gap, and it is a stale rules file wearing a different name.
Superpositional keeps a map of your codebase that re-builds on every push, gives the map to your agents over MCP, and reviews every pull request against the same map before it ships. The code your agents write gets checked against how the codebase fits together today, not how it fitted together when someone last updated the docs.
Building the context once, then keeping it current
Superpositional assembles a case file about your codebase and keeps it up to date for you. Here is what goes into it and where each part shows up.
1. A map of the codebase, re-built on every push
A GitHub App maps each repo: symbols, dependencies, what calls what, plus the architecture and direction docs you already keep. Every push re-maps it. There is nothing to write and nothing to maintain.
Why this helps: the context your agents read is never older than the last commit.
Seeing it in action: an agent asked to change a shared function is told, before it writes anything, which modules call it and which of them have changed in the last week.
2. The same map, given to every agent over MCP
Superpositional runs as an MCP server, so Cursor, VS Code, Kiro, Windsurf, Claude Code and Claude Desktop all read the same map. One entry in your MCP config. Every agent on the team works from the same picture of the codebase.
Why this helps: no per-editor rules files, no drift between what one engineer's agent knows and another's.
Seeing it in action: two engineers on different editors ask about the same payment module and get the same dependency list and the same architecture notes.
3. Eight guards that review the PR against the map
Every pull request is checked against the map by eight guards: security, failure handling, and data consistency. Each finding names the file, shows the evidence and says why it matters.
Why this helps: review covers what the diff touches elsewhere, not just the lines that changed.
Seeing it in action: a change to a retry helper is flagged because two callers assume it never raises, with both call sites linked in the finding.
4. Blast radius that is computed, not guessed
Blast radius comes from the dependency graph, not from a model's opinion. The same change always gets the same answer.
Why this helps: findings are consistent, so the team can act on them without second-guessing.
Seeing it in action: a one-line change to a shared type lists the 14 files it reaches, grouped by service, before review starts.
5. The same checks on your machine, before the PR exists
The guards run locally too. Engineers see what review will say before anyone else does.
Why this helps: issues get fixed at the desk, not in a comment thread.
Seeing it in action: the local check reports the same two findings the PR review would, and the engineer fixes both before opening the PR.
Built for small teams shipping with agents
Superpositional is built for lean teams shipping with AI, small and scaling. Setup is a GitHub App installed by a human on the repos you choose, plus one MCP entry per editor. Findings land in GitHub and Slack, where the team already works. Pricing is usage-based with a hard spend cap, so cost tracks activity and cannot run away.
5 teams have been running it for 3 months.
“As a solo dev using multiple agents, it gives me an in depth view of the whole codebase and also gives me the confidence that an agent-raised PR isn’t going to mess things up.” - Tim Kreger
What it does not do yet
GitHub only for now.
Superpositional: context that keeps itself current
The approach is not a single trick. Map what the codebase is today, give that map to every agent, check every change against it, show the evidence. The map does the remembering, so the team does not have to.