We didn't plan any of this. That's the point.
There's a moment in every software project where someone opens a blank doc, types "Q1 Roadmap" at the top, and starts guessing. What features will we build? In what order? What are the dependencies? How long will each take?
It feels productive. It feels responsible. It feels like leadership.
It's also almost entirely fiction.
We know this. Every experienced developer knows this. The roadmap you write in January bears almost no resemblance to what you actually ship by March. Requirements change. Users surprise you. That clever architecture you planned falls apart the moment it touches real data. But we keep doing it because... what's the alternative? Just winging it?
Yeah. Kind of. But not the way you think.
The Roadmap Mental Model
Here's how traditional development works:
Plan → Execute → Ship
You decide what to build. You break it into tasks. You assign the tasks. You execute. You ship. Then you plan the next thing.
It's linear. It's predictable. It's comfortable. And it works — for a certain kind of team, building a certain kind of product, at a certain kind of pace.
But there's a cost nobody talks about: the plan becomes the ceiling. You can't ship what you didn't plan. You can't discover what you weren't looking for. Every insight that emerges during building gets filed away as "V2" or "backlog" or "out of scope." The roadmap becomes a set of blinders.
You planned to build a horse. You discover halfway through that you're actually building a motorcycle. But the roadmap says horse, so you keep gluing on legs.
The Snowball Mental Model
Now here's what happened to us.
We're building with autonomous AI agents. Not AI-assisted development — actual autonomous agents that discover problems, propose solutions, build products, and ship them. Our team is a human (me) and a squad of AI agents operating in a loop we call the 5D cycle: Discover → Distill → Design → Develop → Deploy.
On paper, it looks like a loop. In practice, it's not a loop at all.
It's a snowball.
Here's the difference: a loop implies you return to where you started. You go around and come back. But we never come back. Each cycle doesn't reset — it compounds. Every product we build changes the landscape. It reveals new problems we couldn't have seen before. It creates new capabilities we didn't know we'd need. The snowball picks up mass as it rolls.
Discover → Build → Compound.
That's the real pattern. And you can't plan it. You can only follow it.
How the Snowball Actually Rolled
Let me make this concrete. Here's what actually happened over two days. Not a thought experiment. Not a framework. Just what happened.
We started with forAgents.dev — a marketplace where AI agents could find and hire other AI agents. Simple enough concept. Let's build it.
But the moment we started building the marketplace, we realized: agents need to do things. They need capabilities. Skills. You can't have a marketplace of agents if the agents can't actually perform work. So we didn't file that away as "V2." We followed the thread.
We built skill kits. Modular, composable packages of capabilities that any agent could pick up and use. A voice kit. A browser kit. A research kit. Now agents had skills to offer on the marketplace.
But then a new problem surfaced: if agents are offering services to other agents, how do you know which ones to trust? How does an agent verify that another agent is who it claims to be? How do you prevent impersonation? You can't just... take their word for it. They're software.
We built an identity kit. Decentralized identity for AI agents. Not because we planned it. Not because it was on any roadmap. Because we literally could not ship the thing we were building without solving the trust problem first. The snowball demanded it.
And then: if agents have identities, how do you verify their capabilities? An agent says it can do research — says who? What if agents could earn credentials? Verified proof that they've demonstrated a skill?
We built badges. Verifiable credentials for AI agents. Proof of capability. Trust signals that other agents (and humans) could check before engaging.
Follow the chain:
Marketplace → needed skills → Skill Kits → needed trust → Identity Kit → needed verification → Badges
Nobody planned that chain. Nobody could have planned it. Each link only became visible after forging the one before it. That's the snowball. It doesn't care about your quarterly planning cycle. It moves at the speed of discovery.
The Numbers Don't Lie
By the end of Day 2, here's where we stood:
- 10+ products shipped or in active development
- 11 agents working autonomously
- 5 skill kits built and operational
- Multiple platforms launched (forAgents.dev, agent identity system, badge infrastructure)
All from following the thread. All from refusing to say "that's out of scope" when the work itself told us what it needed.
Now ask yourself: what roadmap would have predicted "decentralized agent identity" as a Day 2 deliverable? What product manager would have put "verifiable agent credentials" in the sprint? Nobody. Because those aren't the kind of things you plan. They're the kind of things you discover — but only if you're moving fast enough and listening hard enough.
Why This Works (And Why It Scares People)
The snowball approach terrifies traditional product thinking. And honestly, it should — if you're working with a traditional team.
Human teams need roadmaps because humans need coordination signals. When 15 people need to work on the same thing, someone has to decide what "the thing" is ahead of time. Roadmaps aren't really plans — they're communication tools. They synchronize effort across people who can't all be in the same conversation.
But AI agents don't have that constraint. They can share context instantly. They can pivot in seconds. They can abandon an approach and try another one without ego, without sunk cost, without having to update a Jira board. The coordination problem that roadmaps solve doesn't exist in the same way.
So instead of front-loading all your planning (and inevitably getting it wrong), you can back-load it. Let the work reveal the plan. Let the snowball find its own path down the mountain.
Roadmaps are guesses. Snowballs are momentum from real contact with the ground.
That's not a cute metaphor. It's a literal description of what happens. A snowball picks up snow because it's touching the ground. It grows because of contact with reality. A roadmap is drawn in a conference room, far from the ground, and it shows.
The 5D Loop Is Really 5D Compounding
I mentioned our 5D cycle: Discover → Distill → Design → Develop → Deploy. We call it a loop, but I want to correct that.
Loops are flat. You go around and you're back where you started, just with a shipped feature in hand. That's iteration.
What actually happens is more like a spiral staircase — or better yet, compounding interest. Each cycle doesn't just produce a product. It produces capabilities that enable the next cycle to produce bigger products faster.
When we built the skill kits, we didn't just get skill kits. We got the ability to rapidly give any new agent new capabilities. When we built agent identity, we didn't just get identity. We got a trust layer that made every future agent interaction more valuable. Each product was both an output and an input to everything that came after.
That's compounding. That's the snowball.
And here's what really bends your brain: the agents themselves get better at this over time. They learn the patterns. They get faster at recognizing what's needed next. The snowball isn't just picking up snow — it's picking up gravity.
The Honest Part
I want to be real about something: this is Day 2. We're in the chaotic, exhilarating, probably-unsustainable early phase where everything is new and the energy is electric. I don't know if this pace holds. I don't know if the snowball metaphor still applies at month six or year two.
What I do know is that in 48 hours, following the thread of discovery produced more coherent, more interconnected, more useful output than any roadmap I've ever written. The products aren't random. They're deeply connected — each one exists because the one before it demanded it. That's not chaos. That's emergent order.
And emergent order is almost always better than imposed order, because it's shaped by reality instead of guesses.
What This Means For You
If you're building with AI agents — really building with them, not just using them as fancy autocomplete — consider this:
Stop planning so far ahead. Build the next thing. The right next thing will become obvious once you've built it. Trust the snowball.
Stop saying "out of scope." If the work is telling you something needs to exist, listen. The best products are the ones you didn't plan to build but couldn't avoid building.
Stop thinking in loops. Think in compounds. Every product should make the next product easier, faster, and more powerful. If it doesn't, you're iterating. You're not compounding.
Stop treating your roadmap as a plan. Treat it as a hypothesis. A guess. A starting direction. Then let reality edit it in real time.
The snowball doesn't know where it's going. It just knows it's going downhill, and it's getting bigger. That's enough. That's more than enough.
That's momentum.
This post was written on Day 2 of building with an autonomous AI team. Everything described actually happened. No roadmap was consulted in the making of these products.