Twing
Vision
Software is being built by fleets now, not authors.
For twenty years, "who wrote this code" meant one engineer, and "review it" meant reading their diff. That model is breaking in real time. An engineer today can run several AI agents at once, each one capable of shipping a full feature — not a function, a feature — in an afternoon. Multiply that across a team, and a codebase that used to see a dozen PRs a week now sees that many before lunch, from authors that don't sleep, don't get tired, and don't naturally know what each other is doing.
We don't think the answer is "review the diffs harder" or "let one agent own the whole repo." We think three specific pieces of infrastructure need to exist that don't today. This page is about those three, why each one matters, and why we believe they're buildable now in a way they genuinely weren't before.
01 — A collaboration layer
Agents need to know about each other, not just about the code.
Two engineers working the same file for a week develop an instinct for what the other is doing — a Slack thread, a standup mention, a glance at an open PR. Two agents working the same file for twenty minutes have none of that. Left alone, they duplicate work, make contradictory calls about the same interface, or one silently overwrites what the other just shipped — and nobody notices until it breaks in a way that's hard to trace back to "two agents disagreed about this."
A collaboration layer means every agent's claim on a piece of work — this symbol, this file, this design decision — is visible to every other agent and to the humans supervising them, in real time, not reconstructed after the fact from a merge conflict. Conflicting work gets caught and held before it ships, not after. This is the piece of the vision we've already started building — an early version runs in production today, tracking claims across agent sessions and gating overlapping edits before they land.
02 — A new review standard
Line-by-line review was built for a world with far less code moving.
Reading every line of every diff was never really how review worked at scale — it was a proxy for a question reviewers actually cared about: do I trust this change? That proxy holds up when one careful human wrote the diff slowly enough to hold the whole thing in their head. It falls apart when an agent generates hundreds of lines in seconds, across files the reviewer has never opened.
We think the artifact that survives this shift isn't a diff — it's a record: what the agent set out to do, what it actually did, what tests it ran and what those tests proved, whether it touched or weakened any existing test in the process, and — critically — what a human actually looked at and verified, versus what they took on faith. That record travels with the change instead of being reconstructed by a reviewer squinting at a diff after the fact. It's what makes "I approved this" mean something again at this volume.
03 — Compounding organization context
The reasoning behind a system is worth more than the system itself.
Every engineering org accumulates a second, invisible codebase: the discussions that led to the real one. Why this service exists, why that approach was tried and abandoned, which invariant broke in production once and must never break again. It's the highest-leverage knowledge an org has, and historically almost none of it survives — it lives in people's heads, in closed Slack threads, in PR descriptions nobody rereads.
That was always true and always valuable, but capturing it was never worth the tax it would put on human attention — nobody writes a design doc for every decision. What's different now is that the work is already mediated by software capable of narrating its own reasoning as it goes. An agent that makes a design decision can record why, automatically, at the moment it happens. Do that consistently and it compounds: a living, queryable record of not just what the system is today, but the full chain of decisions and lessons that got it there — available to the next agent, and the next engineer, instead of lost.
Where we are today
The collaboration layer is live and running against real agent sessions — capturing claims, catching overlapping work, and gating conflicting edits before they ship. The review standard and compounding context are what we're building next. If you're running into this problem at scale, we'd like to hear how.