The next IDE is for the whole team
AI made each person on a product team faster. The next IDE has to make the team faster, and that means one shared surface for the spec, the prototype, the code and QA.
The problem
Every discipline on a product team adopted AI in its own silo. PMs draft specs with a chat assistant. Designers generate prototypes in a prototyping tool. Engineers build in an AI coding tool. Each person became much faster.
The team did not become faster. AI can draft in six minutes what still takes six weeks to ship. The bottleneck moved from making to coordinating.
AI made your people 10x. Your team is still 1x.
The cause is the handoff. A feature starts as a conversation. It becomes a ticket, then a design file, then a design document, then code, then a test plan. A different person re-translates it in a different tool at every step. The context that an AI session built up is thrown away at each hop. That context includes the reasons, the constraints and the decisions.
The result is three artifacts that disagree with each other: the spec, the design and the code. The rest of the truth sits in chat threads that nobody will read again.
I see one more cost as a product leader. Development is a black box to everyone outside engineering. The team learns what was built at the end of the sprint, when changing it is expensive.
What I built
I built a prototype called OneSurface to test a different shape for the tool.
The core unit is the Build. There is one Build for each feature. It holds the conversation, the spec, the prototype, the engineering design, the code work and the QA state. The feature moves through stages inside the same container: Concept, Define, Design, Development and QA.
Three design choices matter most.
The work happens in the Build. OneSurface is not a coordination layer over other tools. The spec is written there. The prototype is generated there. The code work runs there against the real repository, and pull requests come out the other side.
The conversation is structured as it happens. Any message can be marked as a decision. Any message can become an open question with a named owner. A person can select messages and ask an agent to reconcile them with the spec. In the prototype, an agent notices that the spec says a hold expires after 15 minutes and the code uses 10. It flags the drift before QA starts.
Everyone can watch. A PM or a designer can observe a development session while it runs. They see the agent’s actions and the decisions as they are made. Transparency is a property of the work, and nobody has to write a status report to create it.
What I learned
Building the prototype made three things clear to me.
The conversation layer is the most valuable part. Spec writing, prototype generation and AI coding already exist as separate products. Nobody captures decisions and open questions at the moment they are made and keeps them attached to the feature. Six months later, the question “why did we build it this way?” should have an answer with a history. This layer deserves the most depth.
Engineers decide whether the idea works. The surface must be credible enough that engineers choose to work in it. If they stay in their own tool, development becomes a black box again and the main benefit disappears. The surface has to be native to repositories and pull requests from the first day. It also has to repay engineers directly, with fewer status meetings and fewer questions about the spec.
The scope is a trap. The smallest end-to-end version spans five product categories. Each slice must be useful on its own and cannot be a demo. I do not yet know how much of the coding experience belongs in a first version. That question is still open.
What this means for product teams
You do not need a new tool to act on this idea. You can start with three changes.
- Measure the team, not the individual. Individual AI productivity is easy to see and easy to celebrate. Track the time from idea to shipped feature. That number shows whether AI is helping the team.
- Count your handoffs. List every point where a feature changes tool and owner. Each one is a place where context is lost. Remove the ones you can.
- Record decisions where the work is. Mark decisions and open questions in the same place as the spec, with an owner. Do not leave them in chat.
The tools will follow. The first generation of AI tools made each discipline faster alone. I believe the next generation will be built for the whole team from the start.