The Dawn of the 10x Team
The Dawn of the 10x Team
Previously, I wrote about how debugging, whether done by humans or AI powered tools, depends on context. Without it, even the most capable systems can only tell you what code is broken, but not why it broke.
Now that AI can access the same depth of context developers rely on (stack traces, traces, logs, commits, and code), the way we build and operate software is changing. We’re moving from an era of monitoring to one of reasoning.
The idea of the “10x developer” is one that people still love to debate. How real are they? Do they exist in numbers worth striving to hire, or is that unicorn hunting? Could AI conceivably push more of us closer to that archetype?
But that’s all beside the point. The opportunity before us is not about one off superhuman contributors running free — it’s about AI unlocking the 10x team.
From Sifting to Shared Reasoning
For decades, debugging was reactive. When something would break, a single engineer (often with someone tapping their foot behind them) would dive into logs, traces, and dashboards to find the needle in the haystack. Monitoring tools told us what happened, which was and continues to be helpful, but the human would have to determine why.
Over time, the monitoring tools evolved (disclosure/flex: we played a big part in that). Instead of just raw error data, developers today expect context-rich insights: where/when the issue occurred, who was impacted, and which line of code was at the root of it. Going from saying “something’s wrong” to shining a massive spotlight and shouting “this is precisely what’s wrong” was the first meaningful shift in debugging – it gave meaning to the data and gave developers the tools they needed to fix broken code, fast.
AI is taking that shift one huge step further. Agents like Sentry’s Seer pull in everything that makes up the “what” and correlates that with the codebase and recent changes to come up with informed root cause analysis. It can reason about what happened and then explain the cause (the why) in natural language. And even does so interactively.
The process of debugging changes. Before it was one or two people giving their best guess and then communicating that to an entire organization through some ticketing process; now it’s a team sport. Now the entire team sees the same context, the same reasoning, and the same path to resolution.
The shift from manual sifting to AI-assisted reasoning doesn’t just make the individual developer faster; by giving everyone a unified “why”, it makes them all faster. Fret not about the 10x engineer; this is the first and very subtle step to forming the 10x team.
Context is the Force Multiplier
Every engineering team has experienced the impact of fragmented context/missing data. The disconnect between members of even a single large team can be huge; they use different tools, track different dashboards, have different side conversations going on in DMs — all of which lead to vastly different mental models of what is happening in production.
Having one shared context shortens feedback loops, reduces redundant work, and compounds learning over time. It turns debugging production issues from a solitary task into a collaborative rhythm – where every iteration makes the whole system, human and machine, a little smarter.
Computers now work this way too; Seer uses Sentry’s context and teams are driving to 95% root cause accuracy for issues seen in production code. Shared context in action.
This is the new “golden path.” Not a rigid set of best practices, but a living context loop that teams refine together.
The Flywheel of the 10x Team
In our world of monitoring and observing software, here’s what that looks like in motion:
An observability/monitoring tool catches a set of team wide problems.
A. Problematic updates to Frontend go live
B. A multi-service system starts seeing a slow UX experience over releases
C. A developer/s submits PR with a probable bugAI analyzes it and identifies the root cause then explains it in natural language.
A coding agent is invoked to fix, or someone writes their own
Another layer, like AI code review, reviews the fix but also surfaces related risks before code is merged.
A developer applies or approves the fix.
The system learns, and the next loop moves faster and smarter
Imagine parts or all of the flow across multiple teams in parallel.
Each cycle adds context. Each iteration improves reasoning. The more the team interacts with the system, the smarter both become.
That compounding loop is what makes a 10x team. It’s not because each developer is ten times faster, but because the team and system learn collectively from everyone’s contributions.
Reasoning: The New Runtime
Automation accelerates tasks; reasoning accelerates understanding.
The next wave of software will come from teams that blend both. These are teams supported by systems, tools, and agents that don’t just execute, but also explain.
Fully acknowledging the hyperbolic nature of this statement, our ultimate ambition is self-healing systems and self-improving teams. We want to help build organizations where insight flows freely, and decisions happen closer to the code.
We want to help teams spend less time chasing bugs and more time building with intent. We want discrete AI-assisted individual contributors to come together as a 10x team – fast because they’re aligned, and effective because they’re learning together.
We’re doing this at Sentry. The teams that bring AI reasoning into their workflows spend dramatically less time diagnosing issues and more time shaping what’s next. The 10x developer was a near-mythical figure of an individual era; the 10x team is what happens when intelligence becomes collective.
And that’s the future of software.
