Claude Code for PMs: what you can do with it without being a developer
What a PM can do with Claude Code, how to install it, give it context and set guardrails, plus a free starter CLAUDE.md for your own project.
Guide written by Alex Dionisio, Senior Product Manager. Updated November 13, 2026.
In short
Claude Code is Anthropic’s coding agent: it reads a repository, edits files and runs commands, from the terminal, an IDE, the desktop app or the browser. A product manager can use it without being a developer to prototype, understand existing code, analyze data or prepare a pull request, as long as you approve a plan before any change, move in small steps and have every change reviewed by the team.
What is Claude Code, and how is it different from a chat?
Claude Code is a coding agent: instead of answering in a conversation, it works on your files. It reads a project, proposes a plan, writes or edits code, runs commands and checks the result, asking for your approval depending on the permission mode you choose.
In a chat such as claude.ai, you paste a snippet, get an answer and copy back what you need. Claude Code works directly inside a folder: it finds the relevant files on its own, opens them, edits them and can run commands (tests, scripts, Git). That is what makes it an AI agent rather than a chat assistant.
According to the official documentation, Claude Code runs on several surfaces that share the same engine:
- Terminal: the command-line tool, and the most complete option.
- IDE: extensions for VS Code (and Cursor) and a plugin for JetBrains IDEs.
- Desktop app: a graphical interface with visual diff review, no terminal needed.
- Web: at claude.ai/code, to run tasks on a hosted repository with nothing to install.
For a PM, the practical difference fits in one line: a chat advises you, Claude Code does the work. That is more powerful, and it is also why you need a frame around it. If you are still unsure when to use a chat, a project, deep research or an agent, the lesson Chat, project, research or agent? helps you pick the right mode for each task.
What can a product manager do with Claude Code?
A product manager can use Claude Code to prototype an idea, understand an existing repository, analyze data files, write a spec or check it against the actual code, and prepare small changes that the team reviews as a pull request.
The jobs that pay off most are the ones where you stay in control of the outcome:
- Prototype: build a clickable mock-up or a small internal tool in a separate folder, so you can test an idea with users before it reaches planning.
- Read and understand a repository: ask how a flow works, where a business rule lives, which screens use a given field. You ask, the agent reads, nothing changes.
- Analyze data: have it clean a CSV export, compute metrics, draw a chart or write a SQL query that you get reviewed before running it on a real database.
- Write and test specs: draft a spec, then ask the agent to compare it with the code to spot missing cases or wrong assumptions.
- Prepare a small contribution: fix UI copy, a translation or a label, then open a pull request for the team to review.
What these have in common: each task has a narrow scope, an outcome you can judge, and someone who signs off before anything reaches users.
What should a PM not hand over to Claude Code?
A product manager should not use Claude Code to change production code alone, touch authentication, payments, database migrations or secrets, or route around the team’s review. Those areas need a developer who owns the change and its consequences.
The agent writes plausible code quickly. The risk is not a loud failure, it is an apparent success on something you cannot evaluate. Keep these out of reach:
- deploying to production, and any command that pushes straight to the main branch;
- payments, authentication, access rights and personal data;
- database migrations and scripts that delete or rewrite data;
- configuration files that hold keys or passwords;
- broad rewrites that touch dozens of files at once.
A quieter trap: piling up prototypes that end up wired into the product as they are. A prototype is a prototype; if it has to live on, the team decides how to rebuild it, otherwise you are creating technical debt for other people to carry.
How do you install Claude Code and get started as a non-developer?
To start with Claude Code you need a paid Claude subscription or an Anthropic Console account, then either the desktop app or the command-line install. You open a project folder, sign in, and begin with questions that change nothing.
The official setup guide states that the free claude.ai plan does not include Claude Code. Two entry points suit a PM:
- No terminal: install the Claude desktop app, sign in and open the Code tab. The app ships with Claude Code, so there is nothing else to install.
- With the terminal: on macOS, Linux or WSL, run the install command from the documentation, then check it with
claude --version. Windows has its own commands for PowerShell and CMD. - Open a project: move into the folder (
cd my-project), typeclaudeand complete the sign-in in your browser. - A first, safe task: ask for an explanation of the project, the list of screens or where a piece of data comes from. Reading only, no edits.
For a first try, work on a copy of the repository or a small personal project. You will learn how the tool behaves without worrying about breaking anything.
How do you give Claude Code context with CLAUDE.md and a spec?
Each new session begins with Claude Code reading CLAUDE.md, a file kept at the root of the project. That file tells the agent what it cannot work out from the code: the goal, useful commands, conventions and off-limits areas. The spec for each task sits on top of that permanent frame.
The memory documentation describes several levels: a project CLAUDE.md shared with the team through Git, a personal ~/.claude/CLAUDE.md for all your projects, and a CLAUDE.local.md for local preferences that stay out of version control. Running /init drafts one by analyzing the code, and you refine it from there.
Two rules are enough to start well:
- Short: Anthropic advises keeping each of these files below 200 lines. A long file uses up the context window and its instructions are followed less reliably.
- Specific: “never edit the payments folder” beats “be careful with sensitive code”.
CLAUDE.md sets the frame; the spec describes the task. For each request, give the problem, the expected result, acceptance criteria and what stays out of scope. The guide Writing a spec an AI agent can execute walks through that structure, and the lesson Write a CLAUDE.md that actually helps shows where each instruction belongs.
For tasks you repeat often (a spec review, an analysis write-up), a skill saves you from rewriting the same instructions: see the Claude Skills guide.
Which working method should you follow with Claude Code?
The method that works with Claude Code has three parts: have it explore and plan before coding, move in small verifiable steps, and ask the agent how it proves the result is correct. Plan mode exists for exactly that first part.
Plan mode lets Claude Code browse the files and draft a plan without changing your code; no edit happens before you approve. To switch it on, press Shift+Tab in the terminal, or begin your request with /plan.
- Explore: “Read the files related to sign-up and explain the current flow to me.”
- Plan: “Propose a plan to add a company field, without coding. List the files involved and the risks.”
- Review the plan: check it against your spec and correct it before approving. This is the cheapest moment to change your mind.
- One step at a time: one change, one check, then the next.
- Verify: have it run the existing tests, open the screen, compare with the acceptance criteria.
The best practices page stresses one thing: the agent needs a test or check that confirms its result is right. If it drifts, Esc stops it; after two failed corrections, running /clear and writing a sharper request works better than stacking more corrections.
Which guardrails should you set before letting Claude Code act?
The essential guardrails for Claude Code are a suitable permission mode, rules that block reading secrets, a separate working branch and human review before any merge. An instruction written in CLAUDE.md is not enough for things that must never happen.
Claude Code offers several permission modes: manual mode (the default, which asks before acting), a mode that accepts file edits, plan mode, an auto mode where a classifier model screens risky actions, and a mode that skips all prompts, meant only for isolated environments. Always check which mode is shown when a session starts.
- Secrets: add
denyrules on.envfiles and key folders. According to the documentation, deny rules apply in every mode, auto included. - Branch: never work directly on the main branch; each task gets its own branch.
- Production: no deploy command and no push to the main branch run by the agent.
- Review: nothing gets merged without a developer reading it.
The distinction to remember: CLAUDE.md holds guidance the agent follows almost always, while permission rules and hooks are enforced by the tool itself, every time. The lesson Claude Code permissions explains how to choose the mode and write those rules according to the project’s risk.
How do you work with your engineering team when you use Claude Code?
A PM using Claude Code should agree with the engineering team before touching the repository: which areas are open, what a pull request should look like, who reviews. Your contributions go through the same process as the developers’ own, with no exceptions.
The tool can create a branch, commit and open a pull request. The hard part is human: a developer who finds an unexpected PR on a module they maintain will see it as an intrusion. A few habits prevent friction:
- Raise the idea in a team meeting and get agreement on the areas where you may contribute.
- Share the project CLAUDE.md: the team knows the repository better than you and will add the pitfalls that matter.
- Keep PRs short, with the product context, what was checked and what was not.
- Accept rejections: a PR closed with an explanation often teaches you more than one that gets merged.
To handle branches, commits, reviews and conflicts calmly, the lesson Put an AI coding agent to work in a team repository from the Git for PMs course shows how to fit a coding agent into the team’s flow. On the writing side, the specs course for developers and AI agents helps you produce requests both audiences can execute without guessing.
What are the limits of Claude Code for a PM?
Claude Code is limited by what it can see and by what you can judge. It can produce code that looks right but ignores a business rule, lose track in a long session or cost more than planned, and it replaces neither a developer’s judgment nor your product knowledge.
- Context: the agent only knows what is in the repository, in CLAUDE.md and in your request. Decisions made in a meeting are invisible to it.
- Judgment: if you cannot read a diff, you cannot approve a change on your own. Hence systematic review.
- Long sessions: the longer a conversation runs, the more quality drops. Start a clean session between unrelated tasks.
- Cost and limits: usage draws on your subscription or API credits; keep an eye on it during long tasks.
None of this makes the tool useless for a PM; it defines the right use: an accelerator for understanding, exploring and preparing, framed by the team. To go further on a repository that matters (context, plan mode, permissions, hooks, review), the Claude Code course on context, planning and review takes you step by step to a working setup on your own project.
Free template: a starter CLAUDE.md for a PM project
Copy this file to the root of your project (prototype, analysis or team repository), fill in the brackets and delete the lines you do not need. Keep it short, and have a developer read it if the repository is shared.
Download CLAUDE.md# CLAUDE.md
## The project
- Name: [project name]
- Goal: [one sentence: what this project is for, and for whom]
- Type: [throwaway prototype / data analysis / team repository]
- Technical contact: [name of the person who reviews my changes]
## Who I am
- I am a product manager, not a developer.
- Explain your choices in plain language, without needless jargon.
- When a technical decision is needed, give me 2 options with their risks.
## How to work with me
- Always start by exploring and proposing a plan. Wait for my go-ahead before editing any file.
- Move in small steps: one change, one check.
- At the end of each step, tell me what you verified and how.
- If the request is unclear, ask a question instead of assuming.
## Useful commands
- Run the project: [command]
- Run the tests: [command]
## What you may do
- Read the whole repository to answer my questions.
- Edit copy, labels and translations in [folder].
- Create files in [prototypes or analysis folder].
## What you never do
- Read or edit .env, keys or passwords.
- Touch [payments, authentication, migrations].
- Push to the main branch or deploy.
- Add a dependency without asking me.
## Git
- One branch per task: [prefix]/[short-topic].
- Short commit messages that say what changes and why.
- Pull requests describe the product context, what was tested and what was not.
## Product context
- Current spec: [link or file path]
- Main users: [who]
- Business rules that must not break: [short list]
Put it into practice
The “Work with Claude Code on a real project: context, planning, review” course walks you through it step by step, on your own product, all the way to the deliverable.
See the courseFrequently asked questions
Do you need to know how to code to use Claude Code?
Not to get started: you can explore a project, ask questions and prototype in plain language. Being able to read a diff and run a command makes you far more independent, though, and any change to a team repository should be reviewed by a developer.
Is Claude Code free?
No. According to Anthropic’s documentation, Claude Code requires a paid Claude subscription or an Anthropic Console account; the free claude.ai plan does not include it. Plans change, so check the official page before choosing.
What is the difference between Claude Code and Claude in the browser?
Claude on claude.ai is a chat assistant: it answers, you apply. Claude Code is an agent that works inside a project: it reads files, edits them and runs commands, with your approval depending on the permission mode.
Can you use Claude Code without a terminal?
Yes. The Claude desktop app includes Claude Code in a dedicated tab, and the web version at claude.ai/code runs in the browser on a hosted repository. The terminal remains the most complete surface.
What should a PM put in a CLAUDE.md?
The project’s goal, your profile, how you want the agent to work (plan first, small steps), the useful commands and above all the off-limits areas. Aim for a short file that you extend each time the agent repeats a mistake.
Can a PM open pull requests with Claude Code?
Yes, if the team agrees and the PR goes through the same review as any other. Start with low-risk changes such as copy or translations, and state clearly what was checked.