I recently helped ship a product built end to end with AI.
If you had told me at the beginning of this year that building a product from scratch end to end with AI would turn out to be one of the most collaborative experiences of my career, I would have scoffed.
I already knew how much fun it could be to build something on my own. You can follow an idea as far as you like without waiting for anyone. What I doubted was whether a cross-functional team trying to ship one real product together could feel that same momentum. On paper, individual speed looks liberating and team coordination looks like friction.
Building this app proved me wrong. Taking a real product from a blank slate to users’ hands turned out to be one of the most rewarding experiences of my professional life.
The models got better as we went, and we built a fair amount of our own tooling too: shared skills, review agents, and automated checks that encoded how we wanted to work. We came to think of that layer as our team operating system. Still, the technology was never the hardest part. The hardest part was the people problem.
We had to learn how to trust each other in a completely different way. Every role crossed its traditional boundary. As a product manager, I could trace existing behavior directly in the code, turn what I found into a clear specification, and contribute changes the team could test. Our designer worked directly in the working app and its visual tests rather than stopping at static mocks. Engineers focused on system architecture, interface contracts, and reviewing changes while delegating mechanical fixes to agents. Everyone could contribute to the same feature while it was taking shape, and each of us brought a different eye to what was missing.
That kind of collaboration only works if you are willing to treat process habits as disposable. The only thing worth being stubborn about is putting a high-quality product in the hands of your users. Everything else, including how long a pull request sits in review or when a design gets signed off, is open to change.
The assumption that a pull request naturally needs days of waiting, or a design review needs weeks, is false. One of the most useful agreements we made was a 24-hour review SLA across the team, paired with daily design unblocking and automated checks catching routine issues early. A 24-hour SLA forces discipline on both sides: if I want a colleague to give me a thoughtful review within a day, I have to send a change small enough to understand, and I have to verify my agent’s output before asking for their time.
That is what I mean when I say process problems are people problems. The team has to make an agreement and keep it. Once that trust is there, the feedback loop becomes addictive. You can raise a question about how something should behave in the morning, try working software together soon after, and either see the answer immediately or realize you were asking the wrong question in the first place.
We had existing product behavior to learn from, but we still had to build a new application. Having a reference helped; it didn’t make every decision for us.
That distinction led me to a broader way of thinking about where end-to-end AI-driven development works best. Halfway through the project, I wrote down a simple framework for assessing Modularity (how cleanly work can be broken into small, testable slices) and Context (how much clear reference code, API contract, or business logic already exists):
- High context, high modularity: The sweet spot. Small, verifiable slices backed by clear contracts and reference behavior.
- High context, low modularity: Can work. Agents can trace dense reference code, logs and contracts even in entangled systems.
- Low context, high modularity: Can work. Clean module boundaries let you prototype, test and learn in small slices.
- Low context, low modularity: The hardest case. Ambiguous requirements meet tightly coupled legacy code.
The takeaway is more encouraging than most teams expect. You do not need both high context and high modularity to work this way. As long as your project is high on at least one of those two axes, either modularity or context, end-to-end AI-driven development can produce great outcomes. It is really only the combination, where both modularity and context are low, that remains genuinely tough today.
Seeing the product reach users was a proud moment for our whole team. Just as important, once you have worked on a team that builds, reviews, and changes course together like this, it is very hard to go back. Anyone who believes AI only speeds up solo prototypes has not yet felt the joy of a team shipping this way together. This is how I’ll build software from now on.



