First Round Capital has a famous framework for Product-Market Fit: four levels from Nascent to Extreme, each with clear signals that tell you where you stand. It's powerful because it gives founders a map, not just a destination.
Product teams need the same kind of map for AI adoption. Not “are you using AI?” Everyone is. The real question is how deeply AI has restructured the way your team actually builds product.
After working across US startups and European enterprise, shipping GenAI products, and rebuilding my own workflow with Claude Code, I see four distinct levels. Most teams are at Level 1. A few are approaching Level 2. Almost nobody has reached Level 3 or 4 yet. But the progression is inevitable, and knowing where you stand is the first step to getting ahead.
Level 1: Individual Copilot
AI assists individuals. Context is fragmented.
Every team member has their own AI tool. The PM uses ChatGPT or Claude chat with saved projects. The designer uses Figma MCP connectors. The engineer uses Cursor. Output quality is decent, but context never connects. You copy-paste between tools, share .md files over Slack, and the AI has zero memory of what the rest of the team is doing.
Each person is faster individually, but the team workflow hasn't changed. Same handoffs, same meetings, same sprint events. AI is a personal productivity boost, not a team transformation.
This is where most product teams sit today. And honestly, it feels productive. Until you see what Level 2 looks like.
Signals you're at Level 1
Level 2: Orchestrator
Context is shared. AI creates, humans review.
The team has centralized context. A repo, a shared knowledge base, CLAUDE.md files, design system docs. AI tools read from the same source of truth. And here's the big shift: AI is now doing the first-pass creation. The PM isn't writing specs from scratch anymore. They're reviewing and refining what the agent produces from call transcripts, user research, and product context. The engineer isn't starting from a blank file. They're directing an agent that already understands the codebase. The designer isn't wireframing from nothing. The agent generates layouts that follow the design system, component libraries, or directly the design in codebase.
Some workflows are semi-automated. Specs get generated from discovery notes, PR reviews are AI-assisted, design system checks happen automatically. But humans still validate every output at each step. The PM reviews AI-generated specs before they go to engineering. The engineer checks AI code before merging. The designer validates layouts against the design system.
Work still happens on local machines, but there are fewer handoffs and the gap between “idea” and “first draft” has collapsed from days to minutes.
Signals you're at Level 2
Level 3: Agentic Pipeline
Connected agents run multi-step workflows. Humans approve outputs, not each step.
This is where it shifts from “AI helps me work” to “I direct the system that does the work.” The difference from Level 2 isn't that AI creates. It already does. The difference is that the checkpoints between steps are also automated.
At Level 2, a human reviews the spec before it goes to engineering. At Level 3, one agent writes the spec, another validates it against product requirements, a third implements it, a fourth reviews the code. Only the final output needs human sign-off. You moved from “reviewer at every step” to “approver at the end of the pipeline.”
Agent pipelines are connected end to end. A discovery agent processes user interviews, feeds insights to a spec agent, which generates requirements that a coding agent implements. CI/CD is AI-augmented: agents write tests, review each other's PRs adversarially, catch regressions before humans ever see them.
But it's not just about chaining agents sequentially. The real unlock at Level 3 is parallel execution. The team runs multiple features simultaneously, using git worktrees or isolated branches, each with its own agent working independently. A PM kicks off three feature builds in the morning, each running in its own worktree, and reviews the outputs after lunch. An agent works on a complex implementation for 4–6 hours autonomously while the team focuses on discovery, strategy, or something else entirely.
This changes the math of product building. At Level 2, you're still bottlenecked by sequential human attention. You review one thing, then the next. At Level 3, you're running parallel pipelines. The question stops being “how fast can we build one thing” and becomes “how many things can we build at once.” The answer is limited by context quality and compute, not by team size.
The team's new core competency is building and maintaining the agentic infrastructure itself. Prompt chains, context frameworks, verification layers. I call this context engineering: designing the information architecture that makes agents produce reliable output.
Signals you're at Level 3
Level 4: Autonomous
Agents run 24/7. Humans set strategy and handle the novel.
The product building system is 80%+ automated. Agents run on cloud infrastructure (VMs, AWS, dedicated environments) not on someone's laptop. They operate continuously: monitoring production, detecting anomalies, generating fixes, deploying patches.
Self-healing pipelines handle routine bugs without anyone touching them. A monitoring agent detects an error spike, a diagnostic agent identifies the root cause, a coding agent writes the fix, a testing agent validates it, and a deployment agent ships it. All while the team sleeps.
The team's job has shifted from building product to building and maintaining the system that builds product. Humans focus on strategy, judgment calls, and genuinely novel problems that agents can't solve from existing context. The PM's role? Make sure the agents are solving the right problems. The execution loop runs itself.
Almost nobody is here yet. A handful of AI-native companies are approaching it. But this is where the trajectory leads, and the teams building toward it now will have a compounding advantage over everyone else.
Signals you're at Level 4
The Pattern
Looking across all four levels, a clear pattern emerges:
Level 1: Humans create, AI assists.
Level 2: AI creates, humans review at each step.
Level 3: AI creates and validates across steps, humans approve outputs.
Level 4: AI creates, validates, and ships. Humans set direction.
Notice that each transition isn't really about adopting better AI tools. It's about restructuring how context flows through your team. Level 1 has good tools with fragmented context. Level 4 has unified context with autonomous execution. The bottleneck at every stage is context architecture, not AI capability.
The models are already good enough for Level 3. What's missing is the infrastructure, the workflows, and honestly, the organizational courage to let agents do what they're already capable of.
Where to Start
Level 1 → Level 2: Centralize your product context. That's it. Put your architecture decisions, design system, product principles, and user research into a format AI agents can consume. A shared repo with well-maintained markdown files is worth more than any tool upgrade.
Level 2 → Level 3: Pick one end-to-end workflow and pipeline it. Bug fixing is a good starting point: error log goes in, tested fix comes out, with a second agent handling the code review step. Build one pipeline, learn from it, then expand.
Level 3 → Level 4: You're either at an AI-native company or building one. The prerequisite is Level 3 maturity across your core workflows, plus infrastructure for running agents in cloud environments with proper monitoring and rollback.
The Uncomfortable Truth
Most product teams will stall at Level 1. Not because they can't progress, but because Level 2 requires changing how the team works, not just which tools they use. Shared context, shared standards, and a willingness to let AI do the first draft of work that humans used to own.
The teams that make this transition will ship faster, with fewer people, at higher quality. The rest will keep wondering why they're falling behind despite “using AI.”
The tools don't differentiate anymore. Everyone has access to the same models. What differentiates is how you architect context and structure your workflows around them.
That's the whole game now.
This is a companion piece to The New Product World, which explores how AI is collapsing the traditional product trio and what it means for PMs, designers, and engineers.
Originally published on LinkedIn · Apr 2026