Bring the mess. Find the move.

Customer calls, interviews, analytics, support tickets, and Slack threads all contain product direction. The hard part is turning that mess into the next move.

pm0 helps founders and product builders turn scattered inputs into a prototype-backed product decision without losing the context behind it.

The goal is not to make every idea look finished. The goal is to find the change worth making next.

Every product team has a moment like this: a customer says something that sticks, a metric bends the wrong way, a support thread keeps repeating, and someone asks what the team should do next.

That question is still too hard to answer from memory.

Product management was shaped by one hard truth: building software was expensive.

That made the old sequence make sense. Customer feedback became summaries. Summaries became specs. Specs became designs. Designs became engineering work. Eventually the product reached users, and the team learned what was true.

The process existed for a reason. Engineering time was scarce, shipping was slow, and changing direction late was costly. Product work became a way to reduce uncertainty before a team crossed into implementation.

That world is changing.

AI is compressing the distance between an idea and a working interface. A founder, PM, designer, or engineer can now make something testable in minutes that used to require a full cycle of planning, design, and build.

When building gets faster, the bottleneck moves. The hard part is no longer only writing the spec. The hard part is knowing which change deserves one.

pm0 is built for that new loop.

pm0 is a product workspace for deciding what to change next.

You bring the messy inputs: customer calls, support tickets, Slack threads, screenshots, analytics notes, stakeholder feedback, and half-formed ideas.

pm0 helps you turn those inputs into a visible loop: the messy parts become signals, signals become proposals, proposals become prototypes, prototypes create feedback, and feedback informs the decision.

The AI does not start from a blank prompt. It works from the customer context, product context, rejected paths, and feedback already in the workspace.

That is what makes the work feel continuous. Each decision starts with memory instead of another round of reconstruction.

Most product teams still work inside a loop designed for a slower era:

This loop creates learning, but it creates it late.

By the time real users respond, the idea has already moved through summary, specification, design, planning, and implementation. The team learns something valuable, but the learning arrives after the direction has hardened and the cost of changing it has gone up.

pm0 starts earlier.

Before the spec takes over, pm0 gathers the material around the decision: customer notes, support tickets, sales calls, Slack threads, screenshots, research, analytics, and the context already living in the team's head.

From there, the work becomes visible:

The important part is not that pm0 can generate a prototype. A cold prompt can do that.

The important part is where the prototype starts from. It starts from the customer evidence already in the workspace, the signals the team accepted, the proposals the team rejected, the product context that accumulated, and the feedback from earlier versions.

Each loop carries memory forward instead of resetting.

The prototype is not the final product. It is a way to ask a better question.

Instead of asking, "Do we agree with this spec?" the team can ask, "Does this direction make sense when people actually use it?"

That is the shift. A product decision becomes something you can test before it becomes something the team commits to.

The best founders and PMs already try to work this way.

They leave a customer call with a feeling they cannot ignore.

They paste notes into Claude.

They generate a rough prototype.

They send it to someone on the team.

They collect reactions in Slack, comments, calls, and memory.

The instinct is right. The problem is that the context does not travel with the work.

The quote that started the idea lives in one place. The reasoning lives in another. The prototype lives somewhere else. The feedback comes back through a different channel.

The next time the team revisits the decision, the real story has to be rebuilt from memory.

pm0 is built for that missing continuity.

A product decision is not one artifact.

It is the evidence that raised the question, the signal that made the pattern visible, the proposal that gave the team a direction, the prototype that made the direction tangible, and the feedback that changed what the team believed.

pm0 keeps those pieces connected.

Not as a folder of documents. Not as a chat history. As a living workspace where each step knows what came before it.

The next prototype should remember the last one. The next proposal should remember what was rejected. The next decision should remember why it earned the team's attention.

In pm0, the prototype is not the final product. It is a way to ask a sharper question: does this direction make sense when someone can actually use it?

A live prototype changes the conversation. It gives people something concrete to react to. It turns vague alignment into visible behavior. It lets the team learn from clicks, hesitation, comments, confusion, completion, and silence.

The point is not to make every idea look real.

The point is to learn what deserves to become real before the team treats it like a plan.

Validation does not mean everyone liked it. It means the team learned something specific enough to move with more confidence.

All of those outcomes are useful.

The work is not to protect every idea.

The work is to let the right ones earn their way forward.

pm0 exists because a lot of people choose to build in the open.

We are building on work from the open source community across React, Tailwind CSS, Drizzle, Hono, oRPC, and many other tools that make this kind of product possible.

A special thanks to the Vercel team for releasing the AI SDK, Chat SDK, and tools like bash-tool. Those projects make it easier for small teams to build real AI product workflows without starting from zero.

pm0 is our attempt to carry that spirit forward: take the raw pieces, make the loop visible, and help more teams turn real product questions into something they can test.

pm0 is still early, and the next version should be shaped with teams doing this work for real.

If you have customer notes, support tickets, sales calls, screenshots, analytics signals, or a product direction your team keeps circling, bring one real question.

We will use it to test the loop from messy input to prototype-backed decision.

The point is not to onboard you into another tool. The point is to move one product question forward and learn what pm0 needs to become.