How to Use Claude as a Product Manager: The Complete Guide

Most PMs who try Claude don't get much from it. They open a chat window, paste a feature brief, get a generic PRD, and close the tab. Then they go back to writing the PRD themselves.

The problem isn't Claude. The problem is the setup. Using Claude as a product manager isn't about prompting — it's about infrastructure. When you build it right, Claude runs like a second PM on your team who already knows your product, your users, and your competitive landscape. When you skip the infrastructure, every session starts from scratch.

This guide covers the right way to set up and use Claude as a product manager: context files, PM skills, and the workflows that actually save meaningful time.

Why Claude Works Differently for PMs

Before the setup, it's worth being clear about what makes Claude useful — and what doesn't.

What doesn't work: Opening Claude.ai, pasting your feature brief, and asking for a PRD. The output will be structured and grammatically correct. It will not know your product's strategic context, your personas, your competitive differentiators, or your engineering constraints. You'll spend more time editing than you saved writing.

What works: Running structured commands against a consistent set of context files that describe your product. The PM command reads your company description, your persona files, your competitor profiles, and your current strategy. It applies a proven framework. It produces output calibrated to your actual situation.

The difference between these two approaches is context persistence. You describe your product once. Every skill reads it automatically. Your tenth PRD is as fast as your first — and better, because your context files have gotten richer over time.

Once I introduced Claude to everything about my company — the product, the customers, the competitive landscape — it stopped feeling like a tool and started feeling like a team member. Instead of reintroducing myself every morning, Claude already knew the context. That shift — from "assistant I brief every session" to "colleague who knows the business" — is what makes this approach fundamentally different from chat-based AI.

Step 1: Set Up Your Context Files

Context files are markdown files that live in your Claude project directory. Each one covers a specific dimension of your product. Claude reads them automatically before running any skill.

The five core context files:

company.md — Who you are, what problem you solve, your market, your stage, and your strategic bets. 500-1,000 words.

product.md — What your product does, how it works, current state, roadmap priorities, pricing, and metrics. Include what's live, what's in progress, and what you've explicitly decided not to build.

personas.md — Your primary and secondary user personas. Each persona includes: who they are, what they're trying to accomplish, what frustrates them, what success looks like, and how they currently solve the problem without your product.

competitors.md — Your competitive landscape. For each competitor: their positioning, their strengths, their weaknesses, where you win, and where they win. Keep this opinionated — "Competitor X wins on enterprise integrations, we win on time-to-value" is more useful than a neutral feature matrix.

goals.md — Your current quarter's objective, key results, product initiatives, what you're explicitly not prioritizing, and biggest risks. This is the file that makes every other file directional — without it, skills make implicit assumptions about your stage and priorities that may be wrong.

The fastest way to build your context files is to run the /welcome skill. Point it at your company website and it extracts a first draft of all five files in about three minutes. You'll need to review and edit everything — but starting from a populated draft is much faster than a blank document. goals.md in particular benefits from a careful review: /welcome generates it with limited source material, so enrich it with your real targets, key dates, and what you're explicitly not prioritizing.

For a step-by-step walkthrough, see How to Set Up Context Files in Claude Code.

Step 2: Understand PM Skills

Once your context files are set up, you run skills — commands that combine a structured framework with your product context to produce a specific artifact.

A skill looks like this: /prd-generator

You run it. Claude reads your context files. It applies the PRD framework. It produces a structured PRD calibrated to your product — with goals, user stories, acceptance criteria, success metrics, and edge cases filled in based on your actual product context.

This is fundamentally different from prompting. You're not writing a prompt every time — you're running a command that already encodes the right framework, the right structure, and the right questions to ask. The context files provide the product knowledge. The skill provides the methodology.

The most useful PM skills by workflow:

Step 3: Run Your First Workflow

The best first skill to run is /prd-generator. It's high-frequency, time-intensive without automation, and immediately shows whether your context files are useful.

How it works:

1. Open Claude Code in your project directory (the one that contains your context files)
2. Run /prd-generator with your feature brief: /prd-generator [one paragraph description of the feature you're speccing]
3. Review the output

If the PRD references your actual product, uses your persona names, and acknowledges your competitive context — your context files are working. If the output is generic, your context files need more detail.

Common first-run issues:

The PRD is too generic. Your context files don't have enough product specificity. Add more detail to product.md — particularly around what makes your product different and what trade-offs you've made.

The personas don't sound right. Your personas.md is either missing or underdeveloped. Run /welcome again with more source material, or manually enrich the persona descriptions.

The competitive framing is off. Your competitors.md isn't opinionated enough. Go back and add explicit "we win when..." and "they win when..." entries for each competitor.

The Four High-Leverage Workflows

After your context files are solid and you've run a few skills, these four workflows are where most PMs find the biggest time savings.

Discovery: From Raw Transcripts to Actionable Insights

The problem: You run 10 customer interviews. Synthesis takes a full day. The result captures 60% of what was said. By the time you act on it, half the team can't remember where the insights came from.

With Claude: Drop interview transcripts into your project directory. Run /research-synthesis-engine. The skill reads the transcripts alongside your persona files, applies continuous discovery frameworks, and produces thematic analysis with supporting quotes. What used to take a day runs in minutes — and the output explicitly connects insights to existing personas and flags where new signals challenge current assumptions.

Specs: From Brief to PRD Without the Blank Page

The problem: A PRD takes 4-8 hours. The format varies by PM. Engineering asks the same clarifying questions on every spec because every spec has different gaps.

With Claude: Run /prd-generator with a feature brief. Get a complete PRD — goals, user stories, acceptance criteria, success metrics, edge cases — in the structure your engineering team expects. Every time. The PM's time shifts from writing to reviewing and adding the judgment calls that require human context.

Competitive Intelligence: Profiles That Stay Fresh

The problem: A competitor profile takes 2-3 hours. The format varies. Six months later, nobody updates it because it took so long the first time.

With Claude: Run /competitive-profile-builder with the competitor name. Get a structured profile across consistent dimensions in 15 minutes. Because it's fast, profiles actually get updated when the competitive landscape shifts.

Communication: Status Updates That Don't Take Friday Afternoon

The problem: The weekly stakeholder update takes 45 minutes you don't have. You write it in a rush and communicate half the picture.

With Claude: Run /executive-update-generator. The skill reads your project context and produces a structured update covering what shipped, what's blocked, and what decisions are needed. Consistent format, every week.

The PM Operating System Model

Individual skills are useful. But the real leverage comes from treating them as a connected system — a PM OS — rather than isolated tools.

Here's what that looks like in practice: Your context files describe your product. Every skill reads them. When you update your strategy, every subsequent spec, competitive profile, and stakeholder update reflects that updated strategy automatically. The knowledge compounds across skills instead of living in separate documents.

This is why the PM OS model is different from "using AI to help with work." It's infrastructure that makes every PM on the team more effective — not just the ones who are good at prompting.

For a view of what this looks like across the full PM workflow cycle, see AI PM Workflows: Discovery, PRDs, and Roadmaps.

FAQ

How long does it take to set up context files?

There's real setup investment upfront. The /welcome skill generates drafts of all five files from your website — review and enrich them, especially goals.md. The payoff starts immediately on the first skill you run.

Do I need to update context files every time I use a skill?

No. Context files are living documents, but they don't need to be perfect on day one. Update them when something significant changes — a strategy pivot, a new persona segment, a major competitive shift. Most PM teams update them monthly.

Can multiple PMs on a team share the same context files?

Yes — this is one of the biggest benefits. When the whole team runs skills against the same context files, output quality is consistent regardless of which PM runs the command. Junior PMs produce specs at the same quality standard as senior PMs. That's hard to achieve with prompting, easy to achieve with shared infrastructure.

What's the difference between using Claude.ai and Claude Code?

Claude.ai is a chat interface — better for conversations and exploration. Claude Code is a command-line tool that runs directly in your project directory and reads your context files automatically. For PM workflows, Claude Code produces dramatically better output because every command runs with full product context. See the comparison guide for a more detailed breakdown.

Start Here

The fastest path from this article to results:

1. Set up your context files — or run /welcome to generate them from your website
2. Download the PRD Generator free — your first skill
3. Run /prd-generator on a real feature brief and evaluate the output

Real setup investment upfront — it pays back on the first skill run and compounds from there.

If you want the full PM OS — 70+ skills, all five context files, and workflow packs — the Complete PM OS is built for product teams who are done starting from scratch on every artifact.

About the Author

Ron Yang is the founder of mySecond — he builds and manages PM Operating Systems for product teams. Prior to mySecond, he led product at Aha! and is a product advisor to 25+ companies.

Browse the skills directory →

Set up Claude Code for PM work →