Claude Code for Product Managers: The Complete Setup Guide

If you're a product manager who has heard about Claude Code but assumed it's "for developers," this guide is for you.

Claude Code for product managers isn't about writing code. It's about running structured commands that produce PRDs, competitive analyses, research syntheses, and roadmaps — all informed by persistent context about your product, your users, and your market.

This is the setup guide nobody else has written. Anthropic's docs are aimed at engineers. PM blogs haven't caught up yet. This guide walks you through every step from install to your first skill run.

No programming experience required.

One thing I see consistently: PMs want to jump straight to running skills — that's the exciting part. But the most important step is spending time on your context files. They're what Claude reads before producing any output, and the quality of everything that follows depends on what you put into them.

What Claude Code Actually Is (for PMs)

Claude Code is not ChatGPT. It's not a chat window you paste things into and copy things out of. It's an AI agent that runs in your terminal, reads files on your computer, and executes structured commands called skills.

Here's what that means in practice:

It reads your files. You create markdown files that describe your company, product, users, and competitors. Claude Code reads them automatically. No pasting, no re-explaining, no context setup at the start of every session.

It runs commands. Instead of writing a new prompt every time you need a PRD, you run /prd-generator. The command knows what format to use, what framework to apply, and where to find your product context. Same command, same quality, every time.

It remembers your product. A file called CLAUDE.md at the root of your project tells Claude Code how your product works, what matters, and how you want things done. This context persists across sessions. You set it up once.

If you've read The Copy-Paste Illusion, this is the infrastructure that replaces the copy-paste workflow. Context files replace repeated pasting. Skills replace ad hoc prompts. Persistent memory replaces starting over every morning.

What You Need Before Starting

Four things. All free.

1. An Anthropic account. Go to anthropic.com and create an account. You'll need API access, which requires adding a payment method. Claude Code charges per usage — most PMs spend a few dollars per day at most.

2. A terminal. This is the application where you'll type commands. You already have one:

• Mac: Open the Terminal app (search "Terminal" in Spotlight)
• Windows: Open Windows Terminal or PowerShell
• Any OS: The terminal built into VS Code works well too

If you've never opened a terminal before, don't worry. You'll type exactly three commands in this entire guide.

3. Node.js installed. Claude Code runs on Node.js. Go to nodejs.org and download the LTS version (the one labeled "Recommended for Most Users"). Run the installer — it takes two minutes. To verify it worked, open your terminal and type:

node --version

If you see a version number, you're good.

4. A project folder. Create a folder on your computer where your PM work will live. Call it whatever makes sense — your product name, your company name, or just my-product. This folder is where Claude Code will read your context and save its outputs.

Step 1: Install Claude Code

Open your terminal and run this command:

npm install -g @anthropic-ai/claude-code

This installs Claude Code globally on your machine. It takes about 30 seconds.

Once it's installed, navigate to your project folder and start Claude Code:

cd ~/my-product
claude

The first time you run claude, it will open a browser window asking you to authenticate with your Anthropic account. Sign in, approve the connection, and you're in.

You should see a prompt waiting for your input. That's Claude Code running. You can type plain-English requests and it will respond — but it's not very useful yet because it has no context about your product.

That's what the next steps fix.

Step 2: Create Your Project Structure

Claude Code gets dramatically more useful when your folder is organized in a way it can read. Here's the structure that works for PM work:

my-product/
├── context/              ← Product context files
│   ├── company.md
│   ├── product.md
│   ├── personas.md
│   ├── competitors.md
│   └── goals.md
├── .claude/
│   ├── skills/           ← PM skills go here
│   └── agents/           ← Reviewer agents (CTO, UX, Sales, Exec, etc.)
├── discovery/            ← User research
│   ├── inputs/           ← Interview transcripts, survey data
│   └── outputs/          ← Synthesized insights, research reports
├── workflows/            ← Multi-skill workflows
└── CLAUDE.md             ← Project instructions

You can create this in your file browser (Finder on Mac, Explorer on Windows) or in the terminal:

mkdir -p context .claude/skills .claude/agents discovery/inputs discovery/outputs workflows

Each folder serves a specific purpose:

• context/ holds the five files that tell Claude Code about your product, your users, and your market. These get read automatically every session.
• .claude/skills/ is where PM skills live — reusable commands that run specific PM tasks.
• .claude/agents/ is where reviewer agents live — specialized personas (CTO, UX lead, Sales lead, Exec) that review your work from different angles.
• discovery/ is where research flows through. Drop raw inputs (transcripts, survey exports, feedback) in inputs/ — synthesized outputs land in outputs/.
• workflows/ is where multi-skill workflows live. Each workflow has its own inputs/ and outputs/ folder.
• CLAUDE.md is the project instruction file. Claude Code reads it at the start of every session.

Step 3: Set Up Your Context Files

This is the step that separates Claude Code from every other AI tool. Context files are what make the AI actually know your product instead of generating generic output.

Create five markdown files in your context/ folder:

company.md

What your company is, what it believes, and where it fits in the market.

# Company Context

## Company Name
[Your company name]

## Mission
[One sentence: what you exist to do]

## Market Position
[Who you serve and how you're different]

## Stage
[Seed / Series A / Series B / etc.]

## Key Values
- [Value 1]
- [Value 2]
- [Value 3]

product.md

What you're building and where it stands right now.

# Product Context

## Product Name
[Name]

## What It Does
[2-3 sentences explaining the product]

## Current State
[Beta / v1 / growth stage / etc.]

## Key Features
- [Feature 1]
- [Feature 2]
- [Feature 3]

## Tech Stack
[What it's built on, if relevant]

## Key Metrics
- [Metric 1: current value]
- [Metric 2: current value]

personas.md

Who uses your product and what they're trying to do.

# User Personas

## Primary Persona: [Name/Role]
- **Job title:** [Title]
- **Company size:** [Range]
- **Key jobs-to-be-done:**
  - [JTBD 1]
  - [JTBD 2]
- **Pain points:**
  - [Pain 1]
  - [Pain 2]
- **What success looks like:** [Outcome they want]

## Secondary Persona: [Name/Role]
[Same structure]

competitors.md

Who you compete with and how you win.

# Competitive Landscape

## Direct Competitors
### [Competitor 1]
- **What they do:** [Brief description]
- **Strengths:** [What they're good at]
- **Weaknesses:** [Where they fall short]
- **How we differentiate:** [Your advantage]

### [Competitor 2]
[Same structure]

## Indirect Competitors
- [Alternative approach 1]
- [Alternative approach 2]

goals.md

What you're trying to accomplish this quarter — objectives, key results, and what product must deliver.

This is the file that makes every other file directional. Without it, Claude knows your product and your users, but not what winning looks like right now. Skills that touch prioritization, roadmaps, and PRDs will produce better output when they know whether you're in a growth quarter, a retention quarter, or a validation sprint.

# Goals Context

## This Quarter's Objective
[One sentence: what does winning look like this quarter?]

## Key Results
- [KR1: measurable outcome with a number]
- [KR2: measurable outcome with a number]
- [KR3: measurable outcome with a number]

## Product Goals (What Product Must Deliver)
- [Initiative 1] — [how it connects to the objective]
- [Initiative 2] — [how it connects to the objective]

## What We're Not Prioritizing This Quarter
- [Important thing we're deferring] — [why it's not now]

## Key Dates
- [Date]: [Milestone or deadline]

## Biggest Risks
- [Risk 1 — what could derail the objective]

Create Your CLAUDE.md

Create a CLAUDE.md file at the root of your project folder. This is the instruction file Claude Code reads at the start of every session. Start with something simple:

# CLAUDE.md

## About This Product
[One paragraph about what you're building]

## How I Work
- Read context files in /context/ before responding
- Save outputs to /docs/
- Use frameworks and best practices for PM deliverables
- Be specific to our product — don't give generic advice

## Key Terminology
- [Term 1]: [Definition]
- [Term 2]: [Definition]

You'll refine this over time. The more specific your instructions, the better Claude Code's output becomes. Think of it as onboarding a new team member — what would they need to know on day one?

Step 4: Install Your First Skills

Skills are reusable commands that run specific PM tasks. Instead of writing a new prompt every time you need a competitive analysis, you install a skill once and run it by name. Same command, same framework, same output structure — regardless of which PM on your team runs it.

A skill is a single markdown file named SKILL.md, placed in a specific folder inside .claude/skills/.

Here's how to install one:

1. Browse the skills directory. Find a skill you want — /prd-generator is a good first pick.

2. Download the SKILL.md file.

3. Place it in the right folder:

.claude/skills/prd-generator/SKILL.md

Each skill gets its own folder inside .claude/skills/. The folder name matches the skill name.

4. Run it in Claude Code:

/prd-generator

That's it. Claude Code finds the skill, reads your context files, and produces a PRD tailored to your product.

Recommended First Skills

If you're just getting started, these four give you immediate value across the core PM workflows:

• /prd-generator — Generates PRDs using Marty Cagan's framework, informed by your product context and personas
• /research-synthesis-engine — Processes interview transcripts and research data into themes and insights using Teresa Torres's continuous discovery framework
• /competitive-profile-builder — Runs structured competitive analysis across consistent dimensions
• /welcome — Automates the context setup from Step 3 by generating your context files through a guided conversation

Step 5: Run Your First Skill

Let's walk through running /prd-generator so you know what to expect.

Start Claude Code in your project folder:

claude

Then type:

/prd-generator

Claude Code will:

1. Read your context files. It pulls your product description, personas, competitive landscape, current goals, and project instructions from the files you set up. No pasting needed.

2. Ask you about the feature. It will ask what you're building, what problem it solves, and who it's for. Answer in plain English — a few sentences is enough.

3. Generate a full PRD. The output follows Marty Cagan's product spec framework: problem statement, user stories, success metrics, scope, risks, and technical considerations. All specific to your product, because it read your context.

4. Save the output. The PRD is saved as a markdown file in your project. You can open it in any text editor or convert it to whatever format your team uses.

The key difference from ChatGPT: you didn't paste your product description. You didn't explain your personas. You didn't specify a PRD format. The context was already there. The framework was already built in. You just ran the command.

Run it again next week for a different feature. Same quality, same structure, zero setup.

What Makes This Different From ChatGPT

If you've been using ChatGPT (or any chat-based AI) for PM work, Claude Code will feel different in three specific ways. These aren't subtle distinctions — they change how you work.

Context persists across sessions. In ChatGPT, every conversation starts from zero. You re-explain your product, your users, your goals. In Claude Code, your context files are always there. Tuesday's session knows everything Monday's session knew. No setup tax.

Skills run consistently. In ChatGPT, output quality depends on how good your prompt is that day. In Claude Code, a skill runs the same way every time. The analytical framework, the output structure, the level of detail — all baked into the skill. Different PM, same quality. This matters when you're running a team.

Outputs build on each other. In ChatGPT, your competitive analysis and your PRD live in separate chat windows with no connection between them. In Claude Code, both are files in the same project. The PRD can reference the competitive analysis. The launch plan can reference the PRD. Artifacts accumulate instead of scattering.

For a deeper comparison, read the full Claude Code vs ChatGPT breakdown.

Next Steps

You now have Claude Code installed, your project structured, context files created, and your first skill ready to run. Here's where to go from here:

Browse the full skills directory. There are 70+ skills covering discovery, strategy, competitive intelligence, stakeholder communication, launch planning, and more. Each one is a free download.

Take the PM Team Maturity Assessment. It takes five minutes and shows you which dimensions of your PM operation have the biggest gaps. The results map directly to skills that address each gap.

Go deeper on context files. The more detailed and specific your context files are, the better Claude Code's output becomes. Treat them like living documents — update them as your product evolves, as you learn more about your users, as the competitive landscape shifts.

Check out the PM Operating System. If you want the complete setup — all 70+ skills, pre-built context files, workflow packs, and the folder structure described in this guide — the PM OS bundles everything into a single download.

For questions about Claude Code itself — advanced features, model selection, API configuration — see Anthropic's official documentation.

This guide covered setup. The real value shows up when you're running your third skill, watching outputs reference each other, and realizing you haven't pasted a product description into a chat window in weeks. That's when Claude Code stops being a tool and starts being infrastructure.

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 →