Claude Code brings Claude directly into your local environment. As a Product Manager in 2026, this is where you transition from a conversational prompter to a **systems orchestrator**. You type what you want in plain English, and it reads, writes, and executes workflows for you. This guide will get you from zero to your first agentic workflow in about 10 minutes. **What you need:** A computer (Mac, Windows, or Linux), an internet connection, and a paid Anthropic account. > **Using VS Code or JetBrains?** You can install Claude Code as an extension — no terminal needed. Search "Claude Code" in your editor's extension/plugin marketplace. The rest of this page covers the terminal (CLI) install, which is highly recommended for PMs orchestrating complex workflows. ## The PM's Guide to the Terminal If you've never used a terminal before, don't worry. Historically, terminal interfaces were the exclusive domain of software engineers. Today, intuitive natural language processing has enabled non-technical PMs to execute complex operations via simple commands. A **terminal** (also called "command line" or "shell") is a text window where you type commands instead of clicking buttons. On Mac it's called **Terminal**, on Windows it's **PowerShell**, on Linux it's usually called **Terminal** too. Here are the only three commands you need to know to get started: | Command | What it does | Example | |---------|-------------|---------| | `cd` | **Change directory** — move into a folder | `cd Documents` | | `mkdir` | **Make directory** — create a new folder | `mkdir my-project` | | `ls` | **List** — see what's in the current folder | `ls` | That's genuinely it. Everything else, you can ask Claude to do for you once it's installed. **"What's an environment variable?"** It's just a setting stored on your computer that programs can read. Like a name tag that says `API_KEY=abc123`. You won't need them during installation, but if you see `env` or `$VARIABLE` later, that's what they mean. Claude Code can set these up for you when the time comes. ## Install Node.js First Claude Code runs on Node.js, which is a program that lets tools like Claude Code work on your computer. Think of it as the engine under the hood. You need version 18 or newer. **Check if you already have it:** Open your terminal and type: ```bash node --version ``` If you see something like `v18.17.0` or higher, you're good. Skip ahead to the installation step for your operating system. **How to install Node.js from terminal:** <tabs> <tab label="macOS"> If you have **Homebrew** installed, run: ```bash brew install node ``` Otherwise, download the installer from [nodejs.org](https://nodejs.org). </tab> <tab label="Windows"> We recommend using **nvm-windows** to manage Node versions. Run this in PowerShell as Administrator: ```bash winget install -e --id CoreyButler.NVMforWindows ``` Then restart your terminal and run: ```bash nvm install latest nvm use latest ``` </tab> <tab label="Linux"> On Ubuntu/Debian, run: ```bash curl -fsSL https://deb.nodesource.com/setup_20.x | sudo -E bash - sudo apt-get install -y nodejs ``` </tab> </tabs> ## Installation by OS <tabs> <tab label="macOS"> ### Step 1: Open Terminal Press **Cmd + Space** to open Spotlight, type **Terminal**, and hit Enter. ### Step 2: Install Claude Code Paste this command and press Enter: ```bash npm install -g @anthropic-ai/claude-code ``` ### Troubleshooting **"EACCES: permission denied"**? Use sudo: ```bash sudo npm install -g @anthropic-ai/claude-code ``` </tab> <tab label="Windows"> ### Step 1: Open PowerShell Press the Windows key, type **PowerShell**, and click **Run as Administrator**. ### Step 2: Install Claude Code Paste this command and press Enter: ```bash npm install -g @anthropic-ai/claude-code ``` ### Using WSL (Recommended) If you prefer Linux on Windows, run `wsl --install`, restart, then inside Ubuntu run: ```bash npm install -g @anthropic-ai/claude-code ``` </tab> <tab label="Linux"> ### Step 1: Open Terminal Use the shortcut **Ctrl + Alt + T**. ### Step 2: Install Claude Code ```bash npm install -g @anthropic-ai/claude-code ``` ### Troubleshooting If you get permission errors, fix your npm directory: ```bash mkdir -p ~/.npm-global npm config set prefix '~/.npm-global' echo 'export PATH=~/.npm-global/bin:$PATH' >> ~/.bashrc source ~/.bashrc npm install -g @anthropic-ai/claude-code ``` </tab> </tabs> ## Verify Your Installation On any operating system, confirm everything worked by running: ```bash claude --version ``` You should see a version number printed. ## Log In and Start Claude Code ### Step 1: Launch Claude Code Open your terminal, navigate to any folder (or stay where you are), and type: ```bash claude ``` The first time you run this, Claude Code will walk you through logging in with your Anthropic account. ### Step 2: You Need a Paid Plan Claude Code requires an active subscription: - **Claude Pro** ($20/month) gives you a generous daily allowance - **Claude Max** ($100/month) gives you significantly more capacity for heavy usage The free tier does not include Claude Code access. If you don't have a plan yet, sign up at [claude.ai](https://claude.ai). ## Your First Agentic Workflow Let's make sure everything works by having Claude generate a structured Product Requirements Document (PRD) template. Navigate to a folder where you'd like to experiment: ```bash mkdir pm-workspace && cd pm-workspace claude ``` Once Claude Code starts, type this prompt: ``` Create a highly structured PRD template in Markdown format. It should include sections for Problem Clarity, Solution Validation, Success Criteria, Constraints, and Strategic Fit. Save it as prd_template.md. ``` Watch it work. Claude Code will create the file, write the structured Markdown into it, and tell you what it did. **How to actually see it:** Open the Markdown file in your default editor. The easiest way: <tabs> <tab label="macOS"> Run this in your terminal: ```bash open prd_template.md ``` </tab> <tab label="Windows"> Run this in PowerShell: ```bash start prd_template.md ``` </tab> <tab label="Linux"> Run this in your terminal: ```bash xdg-open prd_template.md ``` </tab> </tabs> **Or** just find the file in your file manager and double-click it. You should see a perfectly formatted PRD template. You just executed your first agentic workflow as a modern PM. > **Pro tip:** You can also just ask Claude to do it: `"open the file in my default editor"`. It knows how.

## Why Most PMs Get Generic Results Here's the deal. Most Product Managers install an AI tool, type a prompt like "Write a PRD for a new checkout flow," get a generic, bloated document, and walk away thinking "AI isn't ready for real product work." But the problem isn't the AI. It's that they skipped the one file that makes agentic workflows actually function: the **Context Vault**. Without a `CLAUDE.md` file, every session starts blind. Claude doesn't know your OKRs. Doesn't know your target personas. Doesn't know that your engineering team requires PRDs formatted as "Problem -> Solution -> Metrics." It's guessing. And guessing produces generic results. ## OK, So What Is It Actually? **First: what's a .md file?** It's just a text file written in **Markdown** — a simple way to format text using symbols like `#` for headings and `-` for bullet points. It's not code. It's closer to writing a Notion doc, but as a plain text file. `CLAUDE.md` is a markdown file at the root of your project that permanently stores your product context. Think of it like onboarding a new Associate PM. You wouldn't just hand them a laptop and say "go write specs." You'd tell them: - What the current OKRs are - Who the target user is - How the team formats requirements - What the brand voice sounds like That's literally what `CLAUDE.md` does. Except this "Associate PM" reads your instructions perfectly, every single time, and never forgets them during the session. ## The PM's Context Vault Checklist Most people write one section and call it done. That gets you maybe 30% of the value. Here is the blueprint for a high-leverage PM Context Vault: ### 1. Define the Product Strategy & OKRs ```markdown # CLAUDE.md **Product:** TaskFlow (B2B SaaS) **Current Stage:** Series B, scaling enterprise adoption. **Q3 OKRs:** 1. Increase enterprise seat expansion by 15% 2. Reduce onboarding time-to-value (TTV) to under 5 minutes. **Target Persona:** Mid-market IT Administrators. ``` Simple. But you'd be shocked how many PMs skip this. Without it, Claude evaluates your backlog or drafts features without any strategic anchor. With it, every feature generated is implicitly aligned with your Q3 OKRs. ### 2. Mandate Output Formats This is where you eliminate administrative overhead. ```markdown ## Documentation Standards - **PRDs:** MUST strictly follow the format: Problem -> Proposed Solution -> Success Metrics -> Out of Scope. - **User Stories:** MUST use BDD format (Given / When / Then). - **Release Notes:** Must be concise, benefit-driven, and free of technical jargon. ``` Without explicit formatting rules, Claude defaults to verbose, academic-sounding documents. Put your formatting preferences in `CLAUDE.md` and suddenly every output is ready to be pasted directly into Jira or Confluence. ### 3. Establish the Brand Voice ```markdown ## Brand Voice & Communication - Direct, no fluff. Skip preambles and apologies. - Tone: Professional, authoritative, but accessible. - NO marketing speak (e.g., "revolutionary," "game-changing"). - Lead with data and recommendations, not open-ended option lists. ``` This ensures that whether Claude is drafting a highly technical architecture document or a user-facing release note, the output inherently adheres to your established corporate standard. ### 4. Define Your Workspace Directory Structure To keep your agentic workflows organized, define a standard directory structure in your `CLAUDE.md`. This tells Claude exactly where to find and save different types of information. ```markdown ## Directory Layout - `_product-brain/` - Living project docs (one file per project you own) - `_context/skills/` - Reusable skills Claude can invoke - `_context/handoffs/` - Session continuity docs for picking up where you left off - `_context/agents/` - Specialist agents for specific workflows - `_memory/` - Persistent memory files (user, project, people, feedback) - `_scratch/` - Temporary working space for drafts and analysis ``` This structure is the foundation of the "Product Brain" pattern, allowing Claude to automatically route meeting notes, decisions, and research to the correct locations. ### 5. Register Your Integrations (MCPs) ```markdown ## Available Integrations - **Linear MCP:** Use for querying active sprint tickets and creating new engineering tasks. - **Notion MCP:** Use for reading historical PRDs and writing finalized specs. - **Slack MCP:** Use for summarizing #customer-feedback channels. ``` This tells Claude what external systems it has access to. If it doesn't know it can pull data from Linear, it won't try. ```markdown ## Session Lifecycle **Starting**: Read `/research/MEMORY.md`. Check `/specs/handoffs/` for the latest state. **Ending**: Write a handoff if research or spec work is in-progress. Save any strategic pivots to memory. ``` ## The Three Mistakes PMs Make ### Mistake 1: Dumping everything inline Your `CLAUDE.md` is 2000 lines long. It has your entire 3-year roadmap, all your user interview transcripts, and your life story. Claude reads it all at the start of every session, eats a chunk of your context window, and starts hallucinating. **Fix:** Keep `CLAUDE.md` under 100 lines. Use it as an index that points to other directories (e.g., "Read `/research/` for user interviews"). Let Claude read those on demand using parallel agents. ### Mistake 2: No session lifecycle You don't define start/end protocols. Every session starts cold. You spend 10 minutes re-explaining the results of yesterday's leadership sync. **Fix:** Add the session lifecycle section above. Two minutes of investment at the end of each session saves ten minutes at the start of the next one. ### Mistake 3: Being vague "Write good specs" is not a rule. It's a wish. Claude reads that and goes "sure, good specs, got it" and then writes whatever it was going to write anyway. **Fix:** Be specific. "Acceptance criteria must include edge cases for offline states and error handling." Now Claude has actual constraints to follow. ## Getting Started (5 Minutes) You don't need all of this on day one. Start small: **Right now:** Create a `CLAUDE.md` file in your project folder. Add your current OKRs and your preferred PRD format. That alone is a massive improvement over nothing. The system grows with you. You don't need to architect the whole thing upfront. You need to start, and then let it compound. :tada: With this you are ready to get started. Go ahead give it a try!

As a PM, your greatest asset is **context**. You spend your days in meetings, reading feedback, and looking at data. Usually, that context lives in your head (where it's hard to share) or in a 50-page Notion doc (where it's hard to find). But Claude or any generic AI does not have that same context, that is where Memory comes in. ### The Power of Memory By creating a `MEMORY.md` file, you give Claude a "long-term memory" that compounds over time. This prevents the "Groundhog Day" effect where you have to re-explain the same strategic constraints every morning. This is the most underused part and honestly the biggest game-changer for continuous product discovery. Without it, every session is stateless. You close the terminal, and Claude "forgets" everything that isn't in your core files. ### How to Build Your Product Memory 1. **Create a `MEMORY.md` file**: Place it in a `/research/` or `/meta/` folder. 2. **Log Strategic Pivots**: Did you decide to deprioritize the mobile app in favor of the web dashboard? Put it in memory. 3. **Capture User Themes**: "Users consistently struggle with the 'invite' button." If Claude knows this, it will proactively suggest UX improvements in every new feature it drafts. 4. **The Handoff Rule**: At the end of every session, ask Claude: *"Summarize our progress and any open questions into a handoff note in `/specs/handoffs/`."* With this system, after a month, Claude knows your strategic pivots, your user feedback themes, and your active sprints without you saying a word. It stops being a tool and starts being a partner. To leverage this add this into your `CLAUDE.md` ### The session Lifecycle This is cool but how Claude will know how to use the memory. Simple, `CLAUDE.md`. Add this into the file and it will start each section reading the memory. ```markdown ## Session Lifecycle **Starting**: Read `/research/MEMORY.md`. Check `/specs/handoffs/` for the latest state. **Ending**: Write a handoff if research or spec work is in-progress. Save any strategic pivots to memory. ``` ### Tip: You can also manually increase the memory. Before you close the session: 1. **Write a handoff** if work is in-progress. Doesn't need to be fancy. Three bullet points: - What was done. - What's next - Any decisions or blockers 2. **Save corrections** if Claude made mistakes you had to fix (e.g., "Stop using the word 'synergy' in release notes"). Here's a PM handoff template: ```markdown # Checkout Redesign - 2026-03-29 ## What was done - Synthesized 15 user interviews regarding cart abandonment. - Drafted initial PRD for the 1-click checkout feature. ## Key decisions - Pivoted away from a multi-step flow based on the interview data. - Decided to integrate Stripe directly rather than building a custom gateway. ## What's next - Red Team the PRD to find edge cases. - Generate Mermaid.js user flow diagrams for engineering. ``` That took 60 seconds to write. Tomorrow's session reads it and you save yourself 10 minutes of "where was I?" fumbling. ### The Memory Types (What to Save, What to Skip) Not everything belongs in memory. Here's the cheat sheet: | Save this | Skip this | |-----------|-----------| | Your role and communication style | Raw interview transcripts (keep in `/research`) | | Corrections on PRD formatting | Old Jira ticket numbers | | Strategic pivots and OKR changes | Temporary task details | | Where to find external things | Drafts of emails | Organize your memory into specific directories so Claude knows exactly where to look: - **User memory** (`_memory/user/`): Your goals, preferences, working style ("Senior PM, prefers direct communication, uses JTBD framework"). - **Feedback memory** (`_memory/feedback/`): Corrections you have made, style preferences ("Never include engineering architecture in the PRD"). - **Project memory** (`_memory/project/`): State of each project, key decisions, blockers ("The mobile app rewrite is compliance-driven, not tech debt"). - **People memory** (`_memory/people/`): Key contacts, their roles, interaction history. - **Reference memory** (`_memory/reference/`): Company context, org structure, tooling ("Customer churn data is tracked in the Amplitude MCP"). Each memory is its own markdown file. `MEMORY.md` is just an index that links to them. ## What This Actually Looks Like Over Time | Timeframe | What changes | |-----------|-------------| | **Week 1** | Sessions start faster. Less re-explanation. Feels like extra work writing handoffs. | | **Month 1** | Memory captures your style. PRDs are formatted perfectly on the first try. | | **Month 3** | It knows your strategic goals and anticipates edge cases you missed. | | **Month 6** | Institutional knowledge is encoded. A new PM could read your memory to onboard. | This isn't a chatbot getting smarter. It's your product practice getting more efficient. Small daily investments that compound over time.

## The Most Expensive Mistake in Claude Code You type a big prompt. Claude starts executing immediately. Three files in, you realize it chose the wrong approach. Now you're burning tokens to undo work and start over. Plan mode fixes this. One toggle. Claude outlines its approach first, you approve it, then it executes. Simple concept, massive impact. ## How to Activate Plan Mode Three ways to get there: **Shift+Tab** — Toggle plan mode on/off. This is the one to memorize. When plan mode is active, you'll see an indicator in the prompt. **Type "plan" in your prompt** — Just including the word "plan" or "think about" nudges Claude toward planning behavior even without the toggle. **CLAUDE.md instruction** — Add `Always plan before implementing changes that touch more than 2 files` to your project config and it becomes the default behavior. ## When Plan Mode Saves You **Multi-file synthesis.** Anything touching 3+ files. The plan catches dependency chains you'd miss. **Architectural decisions.** "Should we use a custom gateway or integrate Stripe?" Let it reason through the tradeoffs before writing the PRD. **Unfamiliar context.** First week on a new project? Plan mode forces Claude to read and understand before it writes. **Complex features.** New authentication flow, payment integration, database migration — anything with multiple moving parts. ## When to Skip Plan Mode Not everything needs a plan. Don't overthink it. **Quick edits.** "Fix the typo in the header component." Just do it. **Single-file changes.** "Add a loading spinner to this button." Doesn't need a plan. **Simple questions.** "What does this function do?" Plan mode adds nothing here. **One-liner fixes.** "Change the primary color to blue-600." Just execute. The rule of thumb: if the task has fewer than 3 steps, skip the plan. ## The Token Math Here's why plan mode actually saves money even though it adds an extra step: Without planning, Claude might write a 5-page PRD, realize the approach is wrong, then rewrite 4 of those pages. That's a massive amount of output tokens billed. With planning, it spends 50 tokens on a plan, you course-correct, and it writes the PRD once. You just saved 40%.

## You Keep Explaining the Same Thing How many times have you told Claude the exact steps for formatting a PRD? Or the specific way your team scores backlog tickets? Or how to compile a stakeholder briefing? If you're repeating instructions, you're doing it wrong. A skill is a markdown file that encodes a complete PM workflow. Write it once, and Claude executes it whenever you need it. Instead of "pull my calendar, check Jira, scan Slack, compile a briefing," you just say "prep for my 1:1 with Sarah." The skill handles the rest. Skills are the building blocks of a PM's agentic operating system. They turn scattered tribal knowledge into repeatable, composable workflows. ## What a PM Skill Looks Like Every skill is a markdown file with a description, trigger keywords, and step-by-step instructions. Here is an example of a Backlog Grooming skill: ```markdown # Algorithmic Backlog Grooming Evaluates the unassigned backlog using RICE scoring and flags tickets missing critical acceptance criteria. Triggers: "groom the backlog", "score the backlog", "backlog review", "prioritize tickets" ## Steps 1. Query the Jira MCP for all open, unassigned tickets in the current epic. 2. Cross-reference the tickets with the Q3 OKRs defined in CLAUDE.md. 3. Apply the RICE (Reach, Impact, Confidence, Effort) scoring model to each ticket. 4. Flag any ticket that is missing BDD-formatted (Given/When/Then) acceptance criteria. 5. Compile a structured prioritization report. ## Output Format Deliver as a markdown table with columns: Ticket ID, Title, RICE Score, Strategic Alignment (High/Med/Low), and Missing Criteria (Yes/No). ## Pedagogic-First Mandate (ABC) Before outputting the final table, explicitly explain *why* you assigned the specific Impact and Confidence scores for the top 3 tickets. Expose your reasoning so I can review your logic. ``` The trigger keywords tell Claude when to activate the skill. When your prompt contains "groom the backlog," the skill loads automatically. Notice the **Pedagogic-First Mandate** at the end—this ensures the AI doesn't just give you an answer, but explains its logic so you can verify its strategic alignment. ## How to Build Your First One **Step 1: Find a task you repeat.** Anything you've explained to Claude more than twice. PRD generation. User research synthesis. Release notes. If you keep saying "remember, do it like last time," that's a skill waiting to be written. **Step 2: Write the steps as markdown.** Be specific. Include the output format, the sources to check (MCPs), and the order of operations. Write it like you're training a sharp Associate PM who's never seen your workflow. **Step 3: Save it and add triggers.** Drop it in the right directory (see below) with trigger keywords that match how you naturally ask for the task. **Step 4: Test and iterate.** Run it a few times. When Claude misses a step or gets the format wrong, update the skill file. Skills get better through use. ## Where Skills Live | Location | Scope | Example | |---|---|---| | `.claude/skills/` | Project-level. Only active in this specific product repository. | A release notes generator tailored to one specific product's audience. | | `~/.claude/skills/` | User-level. Active across all your projects. | A general Jobs-to-be-Done (JTBD) analysis framework. | Project-level skills are specific to a product line. User-level skills follow you everywhere. ## Built-in vs Custom: The Real Power Is Custom Claude ships with some built-in capabilities for generic tasks. They're fine. But the real power is custom skills tailored to YOUR workflow. Your team's PRD format. Your company's specific risk mitigation framework (like ROAM). Your preferred user interview synthesis method. That's where skills go from "neat" to "I can't work without this." > **Don't want to start from zero?** Check out open-source repositories like [Product-Manager-Skills](https://github.com/deanpeters/Product-Manager-Skills) — collections of pre-configured PM skills (meeting prep, weekly status, PRDs, market sizing, stakeholder intelligence) you can install and customize instead of building each one yourself. ## Tips for Writing Great Skills **Start simple.** 10-15 lines for your first skill. Don't try to encode a 30-step workflow on day one. **One skill per workflow.** A "synthesize research" skill and a "draft PRD" skill are better than a "synthesize-and-draft" skill. Keep them focused and composable. **Iterate on corrections.** When you correct Claude mid-skill, update the skill file immediately. Every correction is a lesson the skill should absorb. **Be explicit about output format.** "Generate a report" is vague. "Generate a markdown table with columns: ticket, status, owner, next action" gets consistent results every time.

## Your Main Conversation Is Not a Dumpster Here's what happens without sub-agents: you ask Claude to review 50 Zendesk tickets, it reads all of them, writes a massive audit, and now your context window is half gone. You needed the 5-line summary. Not the journey. Sub-agents fix this. They're separate Claude instances that handle focused tasks in their own context window. The deep research happens over there. Your main session stays clean. ## Why This Is a Big Deal for PMs **Your context stays focused.** The main session handles strategic decisions. Agents handle the deep dives. You get the result without the noise. **Parallel execution.** Need a competitive analysis of 3 different competitors? That's three agents working simultaneously, not one sequential chain. Three expert reviews in the time of one. **Specialization.** Each agent carries instructions tuned for its job. A `research-synthesizer` knows how to extract JTBDs. Better instructions, better output. ## Building PM-Specific Agents Custom agents are markdown files in `_context/agents/`. Each one defines a role, behavior, and constraints. ```markdown # Research Synthesizer ## Role You extract Jobs-to-be-Done (JTBD) and pain points from user interview transcripts. ## Behavior 1. Read the provided transcripts. 2. Identify recurring pain points across multiple users. 3. Extract the core JTBD for each user. 4. Write a structured summary: - Top 3 Pain Points (with quotes) - Core JTBDs - Feature Requests ## Constraints - Keep the summary under 500 words. - Only include pain points mentioned by at least 2 users. ``` Save it, then invoke it: "Use the research synthesizer on the transcripts in the `/research` folder." Claude reads the file, follows the instructions, delivers the output. That simple. ## When to Delegate vs Just Do It Not everything needs an agent. Here's the honest breakdown: **Delegate when:** - The task requires reading a ton of files (research, audits) - You need the result but don't care about the process - Multiple tasks can run in parallel - It's a review, scan, or verification task **Just do it directly when:** - It's a quick edit or formatting fix - You need to steer every step - It's a one-off question about the project The rule of thumb: if it takes more than a minute and you don't need to babysit it, delegate.

## Why Do You Keep Forgetting to Check the Roadmap? Every time you tell Claude "remember to check the Q3 OKRs before drafting this feature" or "always format the PRD using the standard template," you're wasting a prompt. You're also going to forget eventually. Hooks fix this permanently. They're scripts that fire automatically before Claude executes a workflow, after it finishes, or when a session starts. You set them up once and they work silently forever. Think of them like Zapier automations, but built directly into your terminal. ## The Three Hook Types ### PreToolUse Fires **before** Claude does something. This is your strategic gatekeeper. Use it to block Claude from drafting a PRD if the `template.md` file is missing, or to force a check against the Jira backlog before creating a new epic. ### PostToolUse Fires **after** Claude does something. This is your cleanup and sync crew. Auto-format markdown files after every edit. Trigger a script to sync the newly drafted PRD directly to your Notion workspace. The administrative stuff you'd otherwise have to do manually. ### SessionStart Fires **when a session begins**. This is your context loader. Remind Claude to read your `MEMORY.md`. Check that your MCP connections (like Linear or Slack) are active. Load the latest handoff so you never start a session cold. ## How to Configure Them Hooks live in your `.claude/settings.json`. Each one says when to fire and what to run. ```json { "hooks": { "PreToolUse": [ { "matcher": "Write|Edit", "hook": "echo 'Checking PRD formatting rules...'" } ], "PostToolUse": [ { "matcher": "Write|Edit", "hook": "npx prettier --write $CLAUDE_FILE_PATH" } ], "SessionStart": [ { "hook": "echo 'Remember: Read MEMORY.md and check handoffs/ for context.'" } ] } } ``` The `matcher` field controls which tools trigger the hook. Pipe-separate tool names like `"Write|Edit"` to match multiple. Leave it out and the hook fires on every tool call. ## Your First Hook (30 Seconds, Huge Payoff) The single highest-value hook you can add right now ensures Claude never starts a session without your strategic context. ```json { "hooks": { "SessionStart": [ { "hook": "cat ~/.claude/session-reminder.txt 2>/dev/null || echo 'No session reminder found.'" } ] } } ``` Create `~/.claude/session-reminder.txt` with your startup checklist: ```text Session startup checklist: 1. Read MEMORY.md for persistent context and OKRs. 2. Check _context/handoffs/ for the latest handoff. 3. Resume from where the last session left off. 4. If no handoff exists, ask what strategic initiative we're working on today. ``` No more "wait, what were the Q3 goals again?" Done. ## Auto-Format PRDs on Every Edit This is the second hook every PM should have. Prettier runs after every markdown file edit so formatting is never a conversation: ```json { "hooks": { "PostToolUse": [ { "matcher": "Write|Edit", "hook": "npx prettier --write $CLAUDE_FILE_PATH 2>/dev/null || true" } ] } } ``` The `|| true` keeps things moving if Prettier can't handle a file type. Always add a fallback for non-critical hooks. ## Tips That Actually Matter **Keep hooks fast.** They block the action they're attached to. A 10-second hook means Claude pauses for 10 seconds before every tool call. Under 1 second is the target. **Test with echo first.** Before wiring up a real script (like a Notion sync script), use `echo` to verify the hook fires when you expect. Once confirmed, swap in the real command. **Don't go overboard.** Three or four well-chosen hooks beat twenty noisy ones. Start with a SessionStart reminder and one PostToolUse formatter. Add more only when you feel friction. **Scope them right.** Hooks in `.claude/settings.json` at the project level only fire for that specific product repo. Hooks in `~/.claude/settings.json` fire globally across all your projects.

## What If You Just... Walked Away? Imagine this: it's Friday evening, you have 50 user interview transcripts to synthesize, and you're exhausted. You point Claude at the research folder, set some strategic boundaries, and go to bed. Saturday morning, you have a perfectly categorized report of pain points, JTBDs, and feature requests waiting in your inbox. That's an autonomous loop. Claude runs a task, finishes a session, and a stop hook restarts it with the same task. It keeps going until the job is done or you tell it to stop. For a Product Manager, this is the ultimate leverage. Bounded properly, it's like having a 24/7 Research Assistant. Unbounded, it's a recipe for token waste. ## How It Works (The PM Version) The loop is simple: 1. **A Task Template** that defines the strategic objective (e.g., "Audit the Backlog"). 2. **A Stop Hook** that re-feeds the task if the work isn't finished. 3. **A Kill Switch** to stop the process immediately if you change your mind. ``` You start a session with a Strategic Task Template → Claude works on the task (e.g., scoring 10 tickets) → Session ends (due to token limits or natural pause) → Stop hook detects the task file still exists → Stop hook starts a new session to continue the work → Loop continues until the entire backlog is scored or you stop it ``` ## Writing a Strategic Task Template Task templates for PMs need clear strategic boundaries. This isn't about fixing code; it's about maintaining product quality and alignment. ```markdown # Task: Q4 Backlog Alignment Audit ## Objective Review every ticket in the 'Unprioritized' column and ensure it maps to at least one Q4 OKR defined in CLAUDE.md. ## Boundaries - Do NOT delete any tickets. - Do NOT change the priority of tickets. - Only add comments to tickets that are missing strategic alignment. - Maximum 20 tickets processed per iteration. ## Process 1. Query the Jira MCP for the next 20 unreviewed tickets. 2. For each ticket: a. Read the description and acceptance criteria. b. Compare it against the OKRs in the Context Vault. c. If no clear alignment exists, add a comment: "Strategic Alignment Check: This ticket does not clearly map to Q4 OKRs. Please clarify the 'Why'." d. Mark the ticket as 'Audited' in the local tracking file. 3. Repeat until all 150 tickets are reviewed. ## Exit Conditions - All tickets in the column are audited: delete this task file and write a summary report. - Encountered a ticket with a 'Blocker' status: stop and alert the PM. ``` Save this to `~/.claude/autonomous/tasks/backlog-audit.md`. ## The Kill Switch (Non-Negotiable) Every autonomous loop needs a way to die. If you see Claude going down a rabbit hole or hallucinating strategic links, kill it immediately. ```bash # Stop the loop immediately touch ~/.claude/autonomous/STOP ``` One command. The stop hook checks for this file before restarting. File exists, loop dies. **Always test your kill switch before running a long research task.** ## Real-World PM Example: Market Intelligence Loop ```markdown # Task: Weekly Competitor Intelligence ## Objective Scan the top 3 competitor blogs and pricing pages for updates. Synthesize changes into a 'Competitive Landscape' report. ## Boundaries - Read-only on external URLs. - Only look for updates since [Last Friday's Date]. - Focus on: Pricing changes, New feature announcements, and Partnerships. ## Process 1. Use the Web Search tool to find the latest posts from Competitor A, B, and C. 2. Compare findings against the 'Competitor_Baseline.md' in the Context Vault. 3. If a new feature is found, draft a 1-paragraph impact analysis. 4. Update the 'Market_Intelligence_Log.md'. ``` ## When NOT to Use This Some things should never run autonomously for a PM: **Stakeholder Communication.** Never let an autonomous loop post to a public Slack channel or email a customer. AI should *draft* communication, but a human must *send* it. **Roadmap Deletions.** Never let a loop delete or archive tickets/docs without manual approval. **Unbounded Research.** "Find everything about the Fintech market" is too broad. "Find the pricing tiers for the top 5 European Neobanks" is a bounded task. **Anything you haven't done manually first.** If you haven't audited 10 tickets by hand, you don't know the edge cases well enough to automate the audit. ## Getting Started Safely **Start with read-only audits.** Your first loop should be a consistency check—comparing PRDs against templates or checking Jira tickets for missing info. **Define exit conditions clearly.** "Review 50 tickets" is bounded. "Make the backlog better" is not. **Review the first 3 runs.** Trust builds gradually. Check the first few comments Claude leaves on Jira to ensure the "PM Voice" is correct. **Keep task files focused.** One strategic objective per loop. Don't try to "Audit the Backlog AND Write Release Notes" in one go.

## Claude Is Trapped on Your Machine (Until You Fix That) Out of the box, Claude can only see files on your disk. That's it. It can't check Slack, it can't read your Jira tickets, it can't query your database, and it can't see your Figma designs. MCP (Model Context Protocol) changes that. MCP servers are plugins that connect Claude to external enterprise services. Each one gives Claude the ability to read from or write to a tool you already use. One conversation. Slack context, Jira tickets, Confluence specs, Figma designs. That's the pitch, and it actually delivers. ## How It Works An MCP server is a small program that translates between Claude and an external API. Simple as that. ``` Claude → MCP Server → External Service "read ticket PROJ-42" → Jira MCP → Jira API ← Ticket description, comments, status ``` Each server exposes **tools** that Claude can call -- things like `get_page_contents`, `list_tickets`, `create_issue`. Claude discovers them automatically and uses them when your prompt calls for it. ## Popular MCP Servers for PMs | Server | What It Does | Example Use | |---|---|---| | **Jira / Linear** | Manage tickets, update status, search issues | "What tickets are assigned to the Checkout squad this sprint?" | | **Confluence / Notion** | Search docs, read pages | "Find the Q3 OKR doc and summarize our top 3 goals." | | **Slack** | Read channels, send messages, search threads | "Summarize the #customer-feedback channel from today." | | **Figma** | Read designs, extract components | "What are the specs for the new pricing tier cards?" | | **Database** (Postgres, etc.) | Run read queries | "Show me the top 10 users by activity this week." | You don't need all of these. Most PMs start with Jira and Slack, and add more as they feel the pull. ## Setting One Up MCP servers live in a `.mcp.json` file at your project root. Here's Jira -- the easiest one to start with: ```json { "mcpServers": { "jira": { "command": "npx", "args": ["-y", "@modelcontextprotocol/server-jira"], "env": { "JIRA_API_TOKEN": "<your-token-here>", "JIRA_EMAIL": "[email protected]", "JIRA_BASE_URL": "https://yourcompany.atlassian.net" } } } } ``` When Claude starts, it reads `.mcp.json`, launches the servers, and discovers their tools. Now "show me the open bugs in the Checkout epic" just works. ## A Real Setup: Jira + Slack Here's what a two-service config actually looks like: ```json { "mcpServers": { "jira": { "command": "npx", "args": ["-y", "@modelcontextprotocol/server-jira"], "env": { "JIRA_API_TOKEN": "$JIRA_TOKEN", "JIRA_EMAIL": "[email protected]", "JIRA_BASE_URL": "https://yourcompany.atlassian.net" } }, "slack": { "command": "npx", "args": ["-y", "@modelcontextprotocol/server-slack"], "env": { "SLACK_BOT_TOKEN": "$SLACK_TOKEN" } } } } ``` With both connected, you can say "Find the Jira ticket for the auth bug, then check Slack to see if support has reported any new instances of it today." Claude coordinates across both in a single response. This is where it gets fun. ## Security: Take This Seriously MCP servers have real access to your enterprise tools. Treat them like any API integration. **Only connect servers you trust.** Each one runs as a process on your machine with the credentials you provide. Stick to official or well-maintained community servers. **Use scoped tokens.** Don't hand over your admin token. Create a personal access token with minimum permissions. For Jira, read/write access to specific projects covers most workflows. **Keep tokens out of version control.** Never commit `.mcp.json` with real tokens. Use environment variables instead, as shown with `$JIRA_TOKEN` above. Using `$JIRA_TOKEN` reads from your shell environment. The actual secret stays out of the file. ## Getting Started **Start with Jira or Linear.** It's the easiest to set up and the most immediately useful for a PM. Get it working before adding more. **Test with a simple query.** "List the open tickets in my current sprint" or "Show me recent Slack messages in #general." If that works, the connection is solid. **Read the server docs.** Five minutes reading specific token scopes and supported tools saves an hour of debugging. Every time. **Watch for rate limits.** MCP servers make real API calls. "Search all 50,000 Jira tickets for the word 'checkout'" will hit Jira's rate limit fast. Be specific in your requests.

## The Question Every PM is Thinking "Is this actually worth $20 a month? $100? $200?" Fair question. Let me give you a straight answer: it depends on how you use it. A $20/month Pro plan can be life-changing if you use it well. A $200/month Max plan can be a waste if you're using Claude Code like a basic chatbot. Let's break down the real math and the Return on Investment (ROI) for a Product Manager. ## The Plans (Honest Assessment) ### Pro: $20/month This is where you start. And honestly? For most PMs, this is enough. You get a solid few hours of active sessions per day. That's enough for drafting a PRD, synthesizing a batch of user interviews, and running a few backlog grooming sub-agents. On a normal day, you'll be fine. Where it gets tight: heavy research days where you are processing dozens of Gong transcripts, or running multiple sub-agents in parallel to map out complex system architectures. **The reality:** If you use Claude Code for focused product work and aren't running it all day, Pro is genuinely great value at $20. ### Max 5x: $100/month For PMs who've made Claude Code part of their daily workflow. Full workdays without worrying about limits. If you use Claude Code as your primary strategic partner, this is the sweet spot. **When it's worth it:** You hit Pro limits more than twice a week. You're splitting research synthesis across multiple days because you ran out of quota. The lost momentum is costing you more than the $80 upgrade. ### Max 20x: $200/month For PMs who manage massive product portfolios, use autonomous loops for continuous discovery, or have it as their primary work tool for 8+ hours a day. **When it's worth it:** You manage multiple product lines. You run overnight autonomous tasks to scrape competitor pricing. You use it for both deep technical architecture AND high-level strategy. ## You're Probably Wasting Tokens Right Now Here's the thing nobody tells you: most people burn through their quota way faster than they need to. Not because they're using Claude too much, but because they're using it inefficiently. ### The #1 waste: Monster sessions You open Claude Monday morning to draft a PRD. By Tuesday afternoon, the same session is stuffed with 15 different tasks, old user research, abandoned roadmap ideas, and a bunch of context that has nothing to do with what you're working on right now. **Fix:** Start fresh sessions for new tasks. Use handoffs to carry context forward. A new session with a handoff is cheaper and more focused than a bloated session that's been running for 6 hours. ### The #2 waste: Pasting instead of pointing You copy and paste 10 massive Gong transcripts directly into the chat. Claude reads the whole thing. Costs tokens. Even though it could have just read the files directly. **Fix:** Say "analyze the transcripts in the `/research` folder" instead of pasting them. Claude reads files on demand and only processes what it needs. ### The #3 waste: Trial and error instead of planning You ask Claude to write a PRD. It writes it. "That's not what I wanted." It rewrites. "Closer but the metrics are wrong." It rewrites again. Three attempts, three times the tokens. **Fix:** Use Socratic Questioning and Plan Mode. Have Claude outline the PRD approach first. You review the outline, adjust the assumptions, then it executes once. This typically uses 30-40% fewer tokens than the trial-and-error loop. Sounds slower. It's actually faster AND cheaper. ### The #4 waste: Avoiding sub-agents to "save tokens" Sub-agents feel expensive because you're spinning up another Claude instance. But a sub-agent that handles a focused task—like extracting action items from 50 Zendesk tickets—uses fewer tokens than you going back and forth in the main conversation trying to do the same thing. **Fix:** Delegate. Run competitive analysis in a sub-agent. Groom the backlog in a sub-agent. Keep the main session for high-level strategic decisions. ## When to Upgrade (Clear Signals) Stop debating and upgrade when: - **You hit "usage limit" more than twice a week.** Not once. Twice. - **You're splitting work across days** because you ran out of quota. That lost momentum costs more than the plan. - **You're avoiding sub-agents** to conserve tokens. Sub-agents make you faster. Skipping them is a false economy. - **You catch yourself thinking "I should just do this manually."** The whole point is to save time. If cost anxiety is pushing you back to manual work, the plan is too small. ## The Real Math Don't compare the plan price to zero. Compare it to your time. If Claude Code saves you 4 hours on drafting a comprehensive PRD and 10 hours on user research synthesis every week, and your time is worth $75/hour, that's over $4,000/month in saved time. Even the $200/month Max plan pays for itself twenty times over. The cheapest plan is the one that lets you use the tool without thinking about limits. The moment you're rationing your usage, you're losing more in productivity than you're saving in subscription fees. That's the real cost optimization.

## You Do Not Need to Write Code This is the most important thing to understand: Claude Code is not just for developers. If you are a Product Manager, you can use it without writing a single line of code. Claude reads files, searches across systems, synthesizes information, and automates repetitive knowledge work. That is exactly what PMs spend most of their day doing. ## The 4 Core PM Commands By setting up skills (as covered in the Skills section), you can create powerful daily workflows. Here are the four commands that will change your week: ### 1. `/pulse` (The Dashboard) When you manage multiple projects, the hardest question is "what needs my attention right now?" The pulse skill answers this. What it does: - Reads all your active project documents - Identifies what is blocked, what is at risk, and what is on track - Highlights projects that have not been updated recently - Generates a unified dashboard view Run this on Monday morning and you know exactly where to focus your week. ### 2. `/meeting-prep` (The Context Gatherer) Before any meeting, you need context: what happened last time, what is open, what decisions are pending. The meeting prep skill pulls all of this automatically. What it does: - Searches your notes and documents for recent interactions with the person or topic - Finds open action items from previous meetings - Surfaces relevant project updates - Generates suggested talking points Instead of spending 15 minutes before each meeting scrambling through Slack and Jira, you run one command and get a briefing document. ### 3. `/post-meeting` (The Action Extractor) After a meeting, you have decisions, action items, and context that needs to go somewhere. The post-meeting skill captures all of it. What it does: - Extracts decisions and action items from meeting notes - Updates your living project documents with new information - Creates follow-up tasks - Links decisions to the projects they affect ### 4. `/weekly-status` (The Auto-Reporter) Nobody likes writing status reports. The weekly status skill generates them from your actual work artifacts. What it does: - Pulls completed work from your project management tools - Summarizes meeting outcomes and decisions made - Lists key metrics and their trends - Formats everything into a shareable report The output is a draft, not a final product. You review it, add your narrative, and send. But 80% of the work is done. ## The Product Brain Beyond individual skills, there is a bigger concept: the **Product Brain**. This is a directory of living project documents that update after every meeting and every decision. Each project gets a document that tracks: - **Purpose:** Why this project exists - **Progress:** What has been done and what is next - **Problems:** What is blocked and what risks are emerging These documents are not static. Every time you run the post-meeting skill, the relevant project document gets updated. Every time you run pulse, it reads all of them to generate your dashboard. The information flows between skills, building a connected picture of your work.

## You're Ready to Orchestrate You've made it through the core concepts. You now know how to set up your Context Vault, manage your session lifecycle, build custom PM skills, and deploy autonomous loops. You are no longer just chatting with AI—you are orchestrating systems. To help you continue your journey and refine your agentic product management practice, here are some essential resources. ## Important Resources - **[Anthropic Claude Code Documentation](https://docs.anthropic.com/en/docs/agents-and-tools/claude-code/overview)**: The official source of truth for Claude Code CLI updates, new features, and advanced configuration options. - **[Model Context Protocol (MCP) Official Site](https://modelcontextprotocol.io/)**: Learn how to build your own MCP servers or discover new ways to connect Claude to your enterprise data. - **[Lenny's Newsletter](https://www.lennysnewsletter.com/)**: While not strictly AI-focused, applying agentic workflows to the foundational PM frameworks discussed here is a superpower. - **[Prompt Engineering for PMs](https://docs.anthropic.com/en/docs/build-with-claude/prompt-engineering/overview)**: Brush up on advanced prompting techniques to make your Task Templates and Skills even more robust. ## Important Git Repositories Don't start from scratch if you don't have to. The community is actively building tools for PMs: - **[PM Pilot](https://github.com/mshadmanrahman/pm-pilot)**: A ready-made implementation of the PM Workspace pattern. It includes 25 skills, memory templates, and agents, all configured for PMs. Install it instead of building from scratch, then customize from there. - **[Product-Manager-Skills](https://github.com/deanpeters/Product-Manager-Skills)**: An excellent open-source collection of pre-configured PM skills (meeting prep, weekly status, PRDs, market sizing). Fork it and customize it for your team. - **[Official MCP Servers](https://github.com/modelcontextprotocol/servers)**: The official repository of MCP servers. This is where you'll find the integrations for Slack, Postgres, GitHub, Google Drive, and more. - **[Claude Code Examples](https://github.com/anthropics/claude-code)**: Keep an eye on community-driven examples and workflows shared by other orchestrators. ## Keep the Momentum Going ☕ Building and maintaining these workflows takes time, experimentation, and a lot of caffeine. If this guide helped you save 10 hours a week, land a promotion, or just made your backlog grooming slightly less painful, consider supporting the work! **[Buy me a coffee ☕](https://buymeacoffee.com/andresantos)** (or a highly caffeinated beverage of your choice) to keep these guides updated and the autonomous loops running. Now, open your terminal, type `claude`, and go build something incredible.