Your spec, your standards, your repos.
Production-ready PRs without the back-and-forth…
…while you grab lunch.
src/auth/providers.ts src/auth/oauth-config.ts src/components/LoginPage.tsx src/components/OAuthButton.tsx src/types/auth.ts You start with a product spec or an idea and end up with a set of PRs for all the repos that were touched. No chat babysitting required.
Import your spec, or brainstorm with AI to refine it. All grounded in your codebase and standards.
A specialized agent breaks your spec into phased tickets with technical contracts, acceptance criteria, and dependencies.
Engineering agents implement tickets in parallel while you watch a live ticket tree and agent activity in real-time... or grab a coffee.
QA agents run verification loops to enforce the contracts. Every acceptance criterion is checked.
Coordinated PRs are created across all repos. Review, merge, done.
p0 puts humans in control of as much product and technical detail as you can imagine. We help you create and refine specs with agents grounded in your codebase and standards.
Get started →Write specs in plain markdown. Describe what you want built, not how to prompt an AI.
AI refinement understands your existing patterns, conventions, and architecture.
Brainstorm with AI to fill gaps, then lock in the spec before any code is written.
We generate clear acceptance criteria and boundaries for each task. QA loops make sure they were adhered to. No more hoping the AI did the right thing.
Get started →Every ticket has clear, testable criteria generated from your spec.
Agents know which patterns to follow and which boundaries not to cross.
Automated checks ensure every criterion was met before PRs are created.
The architect breaks every feature into phased tickets with dependency ordering. This isn't just a plan. It breaks complex problems into smaller, context-fitting tickets and brings them back together into one cohesive implementation.
Get started →The whole harness is multi-repo aware. It maintains cross-repo context (imports, API contracts, shared types) and creates coordinated worktrees across all your repos in a single session.
Get started →Maintains imports, API contracts, and shared types across all your repositories.
Isolated Git worktrees across repos, all managed in a single session.
One feature, multiple repos, all PRs linked and ready for review together.
Other tools rely on a CLAUDE.md someone wrote three months ago. p0 generates automated codebase readiness that stays current as your code evolves. Real architecture understanding, not a stale markdown file.
Get started →All code stays on your machine on isolated worktrees. We do sync codebase documentation and workspace setup through our cloud so your teams can share those for convenience. And of course, prompts go to Anthropic's API.
Code generation happens on your machine. Files never touch our servers.
Every feature gets its own Git worktree. Your main branch stays clean.
Share codebase docs and workspace config through the cloud. Everyone stays aligned.
Prompts go to Anthropic's API. No training on your data. No third-party access.
We believe in being upfront. p0 is powerful for the right use case, but it's not the right tool for everything.
If you're used to the "chat away as you go" flow, the structured planning is a new thing to get used to. But it pays off for complex features.
Currently a Mac desktop app. Linux and Windows support are on the roadmap.
For small, quick changes you're better off with Claude's plan mode. p0 shines on complex, multi-file features.
Requires a Claude subscription or API key. Works best with high limits. Everything is fine-tuned for Claude 4.6 Opus. We plan to support other providers, but Claude is where the quality bar is.
Purple doesn't just generate code, it challenged our assumptions upfront. Those early questions significantly improved our implementation and drastically increased our engineering velocity. After a short feedback loop, we had a working, well-structured feature. What's especially impressive is that it enabled even non-coding employees to ship meaningful features with an output that is comparable to a small, well-run scrum team.
If someone came in and AI-readied our codebase, it alone would be worth the money. The standards Purple generated taught us things about our own architecture we'd never documented.
I was convinced AI couldn't handle our 800k line monorepo. Purple proved me wrong. The context management is genuinely impressive. It actually understands how our services connect.
Everything you need to know about how p0 works, what it can do, and how to get started.
The building blocks already exist. Claude Code, Cursor, subagents, plan mode, codebase indexing — the primitives for AI-powered development are here, and they work. But primitives aren't a workflow, and a workflow is what actually ships software.
In Claude Code and Cursor, you're still the orchestrator: you prompt, review, re-prompt, and stitch things together yourself. p0 is to Claude Code what Rails was to Ruby — the language was always powerful, the framework made it productive.
p0 provides the workflow layer: You and AI collaborate on a product spec, and p0 builds even the most complex things while you grab lunch or work on the next feature in parallel. It breaks your request into atomic tasks, assigns them to specialized agents, resolves dependencies, runs QA loops, and delivers production-ready PRs.
All you have to do: review the PRs.
You don't switch, you level up. We actually use Claude Code under the hood. What we built is the workflow around it: automated codebase readiness that stays current, interactive spec refinement grounded in your actual code, and opinionated orchestration that decomposes specs into parallel workstreams. If you have a great Claude Code setup, p0 takes that and makes it a repeatable process for your whole team.
Plan Mode in tools like Claude Code is an excellent way to create a brief plan to keep AI on task for smaller to medium sized changes. From our experience, it works really well as long as the scope isn't beyond that.
But when you try to implement the kind of product feature that would have taken you a week as a human team in a single shot, it almost never works. It will run out of context quickly because it does not split the work well, it'll be confident to be done without ever having tested anything, and it simply doesn't give you the ability to create specs with more details than the one-pager or so that it favors.
Give it a try. We've worked on fine-tuning our orchestration layer for a long time now and we think you'll love how much more it can build while you are getting time back thinking about the hard problems.
That really depends on how you are approaching things. p0 tries to generate code "standards" (as we call them) that are easy to search by topic, don't clutter an agent's context, and provide instructions across a multi-repo setup for a holistic understanding that can be shared across your team.
Today, do you just rely on the agent reading through your code every time? This works for small changes, but runs into problems quickly: Reading entire files clogs context windows, and your code isn't necessarily written in a way that you aspire things to be done.
Is your codebase documentation in AGENT.MD files already? Nice! Good start. But these tend to be massive and suffer from the same context clogging as the above.
Have dozens of markdown files, each documenting specific aspects of how you do things? You've done the hard work then, but you still need to somehow share them with your team and need to create a level of documentation above your multi-repo to allow agents to understand how the stacks all connect.
p0 helps with all of these: It creates a draft of standards based on templates that we have developed to work well for agent use. This way nothing gets ignored, and you get to review and change things. We then allow you to share them with all team members so they don't have to create these again.
p0 is language- and framework-agnostic. During onboarding, it analyzes your stack and generates Standards tailored to it. We've worked with Next.js, React, Python, Node, TypeScript, Go, and more. If your team codes in it, p0 can work with it.
Yes. p0 includes specialized QA agents in the pipeline. For example, a web page QA agent can use Playwright MCP to navigate around and take screenshots. An API tester agent can probe your work on endpoints. The better your test cases, the better the outcome.
Yes, via Figma MCP servers. You can also define UI directly in your product spec (layout, components, interactions) and p0 will implement it using your existing design system and component library. Mockups and other prototypes can be provided to p0 directly as well.
Both. p0 has a built-in refinement flow that transforms rough ideas into detailed product specs through guided questions. And unlike chatting in Claude or ChatGPT, it has a full picture of your codebase, so it can be smarter in its feedback.
You bring the vision; p0 helps you articulate flows, edge cases, and acceptance criteria, all within the context of your existing product. The better the spec, the better the code, that's why we help you make it as good as it can be.
p0 runs locally on your machine and works directly in your Git repositories. It creates branches, makes commits, and produces clean diffs you can review and refine. It fits into your existing PR and CI/CD workflow, and supports multiple concurrent sessions without mixing features in progress.
p0 is a native macOS app that runs locally. Your code never leaves your machine. AI model calls send only the relevant context needed for each task, and you control what gets sent. There's no cloud copy of your codebase.
Yes. You create workspaces, which can be a group of repositories or a single standalone repo. Standards are generated on top, so the documentation also covers how multiple repos interact with each other.
Purple AI is the company. p0 is the product: our native macOS app that orchestrates AI agents to ship features in your codebase. When you work with Purple, our team helps you get set up; p0 is the tool your team uses day-to-day.
Self-service gets you running your first feature in 30 minutes or less. You can also book our FDE team members: we embed with yours (onsite or remote), analyze your codebase, generate Standards, and ship the first feature together. After that, your team is self-sufficient.
We offer a subscription model per team. Token costs for AI models (Claude, etc.) are paid directly via your own Claude subscription or API keys. Reach out for specific pricing based on your team size.
p0 is currently a native macOS app. Windows and Linux support are on the roadmap, but we have no ETA yet.