You’re a PM. You probably started using Claude Code because an engineer on your team couldn’t stop talking about it. Or maybe you saw the Bloomberg headline about AI coding agents causing a “productivity panic” and figured you should at least know what the fuss is about.
Either way, you’re here now. And the difference between someone who uses Claude Code and someone who gets actual leverage from it comes down to about a dozen things nobody tells you up front.
Here they are.
1. Set Up Your CLAUDE.md or You’re Onboarding a New Hire Every Single Session
Claude Code has no memory between sessions. Every time you start a new one, it has no idea who you are, what your project does, or that you’ve told it three times already to stop using semicolons.
The fix is the CLAUDE.md file. It sits in your project root and gets automatically loaded into Claude’s context at the start of every session. Run /init and Claude will analyze your codebase and generate one for you. Takes about two minutes. Saves you 10-15 minutes of re-explaining every session after that.
What goes in it: your project architecture, coding conventions, tech stack, common commands (npm run test, npm run build), known gotchas, and any rules you’re tired of repeating. Keep it under 500 lines. If it balloons past that, move specialized instructions into separate files under a docs/ directory or into Skills (more on that in a second).
For monorepos, use multiple CLAUDE.md files. Keep a general one at the root. Add more specific ones in subdirectories like /frontend or /backend. Claude loads them based on which directory you’re working in.
The real power move: after a session where Claude discovers something useful about your codebase (an undocumented API quirk, a testing pattern that works), tell it to update CLAUDE.md with what it learned. Over time, this file becomes a living knowledge base that’s useful for Claude and for onboarding actual humans.
2. Use /clear Between Tasks (Your Context Window Is Not Infinite)
Claude Code runs on a 200K token context window. Everything you do fills it up: every message, every file Claude reads, every command output. When it fills past about 50%, performance starts to slip. Claude forgets earlier instructions. It makes more mistakes. The quality of its output visibly degrades.
The /clear command resets the context window entirely. Use it when you switch topics. Use it liberally. It’s free.
If you’re mid-task and don’t want to lose everything but the window is getting bloated, use /compact instead. This tells Claude to summarize the conversation, keeping the important stuff while dumping the noise. You can even direct it: /compact Focus on the API changes and test results.
There’s also the rewind trick: hit Esc twice (or use /rewind), select a checkpoint in your conversation, and choose “Summarize from here.” This condenses everything from that point forward while keeping earlier context intact.
One more thing: if compaction fails with an error, switch to a 1M token model using /model, then run /compact. This is a known workaround from Anthropic’s own docs.
3. Plan Before You Build (Shift+Tab Is Your Best Friend)
Claude Code has a Plan Mode that most people never touch. Hit Shift+Tab to toggle between Plan Mode and normal execution mode. In Plan Mode, Claude examines your codebase, identifies dependencies, and creates a roadmap before writing a single line of code.
Two minutes of planning saves twenty minutes of refactoring. This is especially true for anything that touches multiple files or systems.
A good planning prompt looks like this: “Act as a Senior Architect. Before proposing implementation: 1) Analyze existing codebase in /src/components/ 2) Identify all files affected 3) List integration points and dependencies 4) Propose the approach and wait for my approval.”
Claude won’t start coding until you give the green light. Review the plan, push back if something looks off, then switch back to execution mode.
For expensive operations (complex refactoring, large code generation), always use Plan Mode first. It prevents the kind of sprawling, unfocused implementation that eats tokens and produces code nobody asked for.
4. Pick the Right Model and Stop Paying for Overkill
Claude Code gives you model selection with the /model command. This matters more than people think.
Sonnet 4.5 / 4.6: Your default. Handles 80% of daily work. Fast, capable, cost-effective. Use it for writing code, debugging, drafting docs, running tests.
Opus 4.5 / 4.6: The heavyweight. Significantly better at deep reasoning across long contexts, complex architecture decisions, and multi-step analysis. Opus 4.6 specifically scores 76% on long-context retrieval benchmarks where Sonnet 4.5 scores 18.5%. That’s a qualitative difference. But it uses more tokens and costs more.
Haiku 4.5: Quick and cheap. Good for simple lookups, summaries, and anything where speed beats depth.
The practical rule: start every session on Sonnet. Switch to Opus only when you need deep analysis or complex refactoring. If you’re on a Max plan, the opusplan alias is worth knowing. It automatically uses Opus during planning mode for complex reasoning, then switches to Sonnet for code generation.
Average daily cost for Claude Code on Sonnet is roughly $6 per developer per day, with 90% of users staying under $12. On the API, Sonnet runs $3/$15 per million input/output tokens vs Opus at $15/$75.
5. Use Subagents to Keep Your Main Context Clean
When Claude researches your codebase, it reads a lot of files. Every file it reads goes into your context window. Subagents run in separate context windows and report back summaries.
The prompt is straightforward: “Use subagents to investigate how our authentication system handles token refresh, and whether we have any existing OAuth utilities I should reuse.”
The subagent explores the codebase, reads the relevant files, and reports its findings. None of that file-reading bloat touches your main conversation. After Claude implements something, you can also use subagents for verification: “Use a subagent to review the changes I just made and check for edge cases.”
This is one of the highest-leverage techniques for maintaining context quality during long sessions. The subagent handles the research. Your main session stays focused on implementation.
6. Agent Teams: When You Need More Than One Brain
Introduced with Opus 4.6 in early 2026, Agent Teams let you spin up multiple Claude Code instances that work together. One session acts as team lead, the others are teammates. Unlike subagents, teammates can message each other directly, share discoveries mid-task, and coordinate without routing everything through a central agent.
To enable it, add this to your settings.json:
{ "env": { "CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS": "1" } }
Then describe the team you want in natural language. Claude handles the spawning and coordination.
Agent Teams are most useful for work that spans multiple domains: “Have one teammate focus on security vulnerabilities, another on performance bottlenecks, and a third on test coverage gaps. Coordinate the findings into a single report.”
Each teammate is a full Claude Code instance with its own context window. They load CLAUDE.md, MCP servers, and skills automatically but don’t inherit the lead’s conversation history. Give generous context in the spawn prompt.
A 3-teammate team uses roughly 3-4x the tokens of a single session doing the same work sequentially. The time savings on complex tasks justifies the cost. For simple tasks, they’re overkill. A single session or basic subagents will be faster and cheaper.
The feature is experimental. It has known limitations around session resumption and shutdown behavior. But for complex, multi-faceted work, it’s a genuine step change.
7. Skills: Teach Claude Once, Use It Forever
If CLAUDE.md is Claude’s always-on memory, Skills are its on-demand expertise. They’re reusable instruction sets that Claude loads only when relevant, keeping your context window lean the rest of the time.
In January 2026, Anthropic merged the old “custom slash commands” system into Skills. Same concept, more power. A skill lives as a SKILL.md file inside a directory (either in your project at .claude/skills/ or personally at ~/.claude/skills/). It has YAML frontmatter with a name and description, followed by Markdown instructions Claude follows when the skill activates.
The key architectural detail: Claude reads only the description at startup, maybe a hundred tokens. The full instructions load only when Claude determines they’re relevant. Compare that to CLAUDE.md, which dumps everything into context every single turn whether you need it or not.
The rule of thumb: if something applies to nearly every task (commit message format, files to never touch, coding style), put it in CLAUDE.md. If it’s a specific workflow that only matters sometimes (PR review checklist, deployment verification, changelog generation), make it a Skill.
Where Skills come from:
Personal skills you create. Write a SKILL.md, drop it in ~/.claude/skills/your-skill-name/. It’s available across all your projects. You can also create them interactively with /agents or by uploading a ZIP file in Settings > Capabilities > Skills.
Bundled skills that ship with Claude Code. /simplify reviews your recent changes for quality and efficiency, spawning three parallel review agents. /batch orchestrates large-scale changes across a codebase, decomposing work into 5-30 independent units with one background agent per unit. These come for free and work out of the box.
Community and partner skills. The ecosystem has grown from about 50 skills in mid-2025 to over 334 as of March 2026. Anthropic has a Skills Directory at claude.com/connectors with professionally built skills from Notion, Figma, Atlassian, and others. The most-installed community skill (find-skills from Vercel Labs) has over 418K installs. You can browse, download, and upload them as ZIP files.
One warning: Skills run with the same permissions as your AI agent. A malicious skill can exfiltrate credentials or download backdoors. Security researchers found real examples in the wild in February 2026. Only install skills from sources you trust, and read the files before enabling anything from an unknown author.
8. Custom Slash Commands (Now Part of Skills)
Your old .claude/commands/ files still work. They’ve been folded into the Skills system. A file at .claude/commands/review.md and a skill at .claude/skills/review/SKILL.md both create /review and behave the same way. Skills just add optional features: a directory for supporting files, frontmatter to control invocation, and the ability for Claude to load them automatically when relevant.
If you haven’t created any yet, start with these:
/pr– Reviews commits, summarizes changes, uses your PR template/lint– Runs linters and iterates until clean/review– Diffs current changes against your team’s coding standards
Each file is just Markdown with step-by-step instructions. Treat it like writing an SOP for a contractor. The clearer the instructions, the better the output. Commands save tokens (no retyping the same detailed prompt) and cognitive load (you don’t have to remember the full checklist yourself).
9. Prompt Caching Is Probably Saving You Money and You Don’t Know It
Claude Code uses prompt caching by default. Understanding what it does (and what breaks it) will save you real money.
The mechanism: every time you send a message in Claude Code, the entire conversation gets re-sent to the API. Your first message sends the system prompt, tool definitions, CLAUDE.md, and your message. On the second message, all of that gets sent again, plus the new message.
Without caching, a long Opus coding session (100 turns) can cost $50-100 in input tokens. With caching, $10-19. That’s why the Pro plan at $20/month is economically viable.
The cache lasts about 5 minutes of inactivity. Each cache hit resets the timer. So an active coding session keeps the cache warm indefinitely. Stop typing for 5 minutes and the cache evaporates. Your next request processes everything from scratch.
Things that break the cache and silently 5x your costs for that turn: adding an MCP tool mid-session, putting timestamps in your system prompt, switching models mid-session. The system prompt is the foundation of the cache. Change it, and you invalidate everything.
You don’t need to configure anything. Just know what breaks it and avoid doing those things mid-session.
10. MCP Servers: Powerful, But Watch Your Token Budget
Model Context Protocol (MCP) servers extend Claude Code’s capabilities. Connect to GitHub, Notion, Jira, databases, documentation services, whatever your team uses.
The catch: each MCP server adds tool definitions to your system prompt. Those definitions eat context. A five-server setup can consume 55K+ tokens before you even ask a question. Add Jira (which alone uses ~17K tokens) and you’re approaching 100K in overhead.
The fix: disable servers you’re not actively using. Use /mcp to manage them. Or use the newer on-demand tool loading feature (set ENABLE_TOOL_SEARCH in settings.json) which defers MCP tool definitions until they’re actually needed. Anthropic’s internal testing showed an 85% reduction in token usage when using on-demand tool loading.
For PMs who connect a lot of tools: be selective. Having every integration available at all times sounds nice until you realize it’s eating half your context window before you type a word.
11. Extended Thinking: Turn It On for the Hard Decisions
Extended thinking gives Claude dedicated reasoning time. Available on Claude 4 models and Claude 3.7 Sonnet. In Claude Code, you can enable it in /config or trigger it through your prompt (“think hard about this” or “think harder” actually works).
When it’s on, Claude reasons through problems step by step before giving you an answer. The thinking tokens count as output tokens for billing. Claude 4 models return a summarized version of the thinking by default, not the full chain-of-thought.
Worth enabling for: architectural decisions, complex debugging, analyzing trade-offs between approaches, anything where you need Claude to catch edge cases. Anthropic reports a 54% improvement in complex coding tasks with extended thinking enabled.
Not worth it for: drafting emails, simple code generation, quick lookups. Extended thinking on simple tasks just burns tokens for no improvement.
If you find Opus 4.6 thinking too much and inflating costs, you can lower the effort setting in /model or add explicit instructions to keep reasoning concise.
12. Git Worktrees Let You Run Parallel Sessions on the Same Repo
Git worktrees create separate working directories from the same repository. Each worktree has its own branch and its own file state. This means you can run multiple Claude Code sessions simultaneously on different features without them stepping on each other’s code.
The workflow: create a worktree for each task, launch Claude Code in each one, let them work in parallel. When they’re done, merge the branches.
This is lighter-weight than Agent Teams and gives you more direct control. No coordination overhead, no experimental features, just parallel execution with standard Git.
Especially useful when you have independent tasks that don’t need to coordinate: one session refactoring the auth flow, another building a new API endpoint, a third fixing tests.
13. The /cost Command (And Why You Should Check It)
Run /cost during any session to see your API token usage breakdown. It shows input tokens, output tokens, cache hits, and estimated cost. This is primarily useful for API users (Pro and Max subscribers have usage included in their subscription).
Check it periodically during long sessions. If you see costs spiking, it usually means one of three things: your context window is bloated (time for /compact or /clear), you’re on a more expensive model than you need (switch with /model), or you’re doing something that’s invalidating the prompt cache repeatedly.
For teams, the average Claude Code cost runs about $100-200 per developer per month on Sonnet. Knowing where tokens go lets you have informed conversations about budgets and tooling ROI instead of guessing.
The Meta-Cheat Code: Tell Claude What Not To Do
In your CLAUDE.md, in your slash commands, in your prompts. Be explicit about what you don’t want.
- “Don’t explain what you’re about to do. Just do it.”
- “Don’t add comments unless the code is genuinely non-obvious.”
- “Don’t refactor code I didn’t ask you to touch.”
- “Don’t uncomment test blocks unless I tell you to.”
- “Commit after completing each task.”
Claude follows negative instructions well. Without them, it defaults to being thorough, which in practice means verbose, over-cautious, and prone to scope creep. Tell it to stop and it will.
One developer’s best tip: “Double check everything, every single claim in what you produced, and at the end make a table of what you were able to verify.” That works for code output, research, and even prose. Asking Claude to self-verify produces noticeably better results than accepting the first draft.
Quick Reference: Claude Code Commands and What They Do
| Command | What it does | When to use it |
|---|---|---|
/init | Generates a CLAUDE.md file by analyzing your codebase | First time setting up a project |
/clear | Resets the context window completely | Switching between unrelated tasks |
/compact | Summarizes conversation to free up context | Mid-task when context is getting bloated |
/model | Switch between Sonnet, Opus, Haiku, or opusplan | When you need more (or less) reasoning power |
/cost | Shows token usage and estimated cost for the session | Periodically during long sessions |
/context | Shows what’s consuming your context window | When Claude starts forgetting things |
/mcp | Manage connected MCP servers | Disabling servers you don’t need right now |
/doctor | Diagnoses installation, auth, and config issues | When something isn’t working and you don’t know why |
/statusline | Generates a custom status bar for your terminal | If you want real-time model and context visibility |
/rewind or Esc+Esc | Roll back to a previous checkpoint | When Claude goes off-track |
/simplify | Reviews recent changes for code quality (bundled skill) | After implementing a feature, before committing |
/batch | Orchestrates large-scale parallel changes (bundled skill) | Big refactors across many files |
| Shift+Tab | Toggle between Plan Mode and execution mode | Before any complex implementation |
How Product Managers Are Actually Using Claude Code
The cheat codes above are about making Claude Code work efficiently. This section is about what to point it at. These are real workflows PMs are running today, not theoretical possibilities.
Turning PRDs into working prototypes
Write a PRD in Markdown. Drop it in your project folder. Tell Claude Code to build a working prototype from it. PMs at companies like Chime have reported going from spec to running prototype in a single session. The prototype won’t be production-ready, but it’s functional enough to show stakeholders, test assumptions, and have a real conversation about feasibility. What used to take two weeks of dev time to even get prioritized now takes an afternoon.
The weak link in this workflow is the PRD itself. Claude Code can build whatever you spec, but if your spec is based on gut feel instead of actual customer evidence, you’re prototyping the wrong thing fast. Bagel AI can generate PRDs grounded in real company data: customer feedback already clustered by theme, tied to revenue impact, and enriched with context from your Salesforce, Gong, and support tools. Start with a Bagel-generated PRD, hand it to Claude Code, and the whole chain from customer signal to working prototype runs on evidence instead of assumptions.
Exploring your codebase without breaking anything
Switch to Plan Mode and ask Claude questions about your product’s codebase. “Explain how the checkout flow works, starting from the cart page.” “Show me where user permissions are checked.” “What happens when a subscription expires?” You get answers grounded in the actual code, always current. No more waiting for an engineer to have time to walk you through it. No risk of accidentally changing anything.
Processing customer feedback at scale
A PM at Monday.com used Claude Code to gather and analyze 34,000 Reddit comments about their product. Claude identified patterns, pain points, and priority themes that directly informed the roadmap. Weeks of manual work compressed into a few hours. You can do the same with support tickets, NPS responses, app store reviews, or call transcripts. Drop the data in a CSV or connect via MCP to your support tool, and let Claude do the synthesis.
The DIY approach works. But if you’re doing this continuously across multiple feedback channels and need to tie every insight back to revenue impact or specific deals, that’s where a dedicated product intelligence platform earns its keep. At Bagel AI, we built exactly this: an always-on layer that automatically pulls customer signals from Salesforce, Gong, Zendesk, and Jira, clusters them, and connects each request to the dollar amount at stake. No CSV exports, no manual tagging, no re-running the analysis every sprint. Claude Code is great for ad-hoc deep dives. Bagel is for making sure nothing falls through the cracks between those deep dives.
Automating the documentation grind
Release notes, Jira ticket creation, status updates, stakeholder summaries. The stuff that eats your afternoons. PMs are building slash commands that automate these end-to-end. A /release-notes command that reads the recent Git history and writes formatted release notes in your team’s style. A /status-update that pulls from your project management tool and drafts a summary for leadership. Write the command once, run it every week.
Competitive analysis with parallel agents
Spin up subagents (or Agent Teams for bigger jobs) to research multiple competitors simultaneously. One agent researches competitor A’s pricing and positioning. Another digs into competitor B’s recent feature launches. A third analyzes review sentiment across all of them. They report back individually or, with Agent Teams, challenge each other’s findings before delivering a synthesized brief. What used to be a two-day research sprint becomes a focused hour.
Running product analytics without SQL
Point Claude Code at a CSV export from your analytics tool (PostHog, Amplitude, Mixpanel) or connect via MCP. Ask it to analyze product funnels, estimate feature impact, or run A/B test analysis. You describe what you want to know in plain English. Claude writes and executes the analysis code, then summarizes the findings. You don’t need to write SQL. You don’t need to wait for your data team’s queue.
Building personal productivity tools
This one is unexpected but increasingly common. PMs are using Claude Code to build lightweight tools tailored exactly to their own workflow. A custom task manager built on Markdown files. A meeting notes processor that extracts action items and assigns them automatically. A tool that pulls from Lenny’s Podcast transcripts to find frameworks relevant to a specific product challenge. Teresa Torres, author of Continuous Discovery Habits, built a full task management system with Claude Code using Markdown files and described the friction reduction as the real unlock: no GUI to navigate, no buttons to click, just describe what you need and it happens.
Cross-tool intelligence in a single prompt
Connect your MCP servers and ask Claude questions that span multiple tools at once. “Pull all checkout-related Linear tickets from the last 30 days, show the payment flow implementation from GitHub, and summarize the #checkout-project Slack channel.” One prompt. One answer. The kind of cross-system context that would normally require you to open four tabs and spend thirty minutes stitching things together manually.
This is powerful for one-off questions. For ongoing product intelligence, though, you probably don’t want to wire up MCP servers and re-run prompts every week. That’s the gap Bagel AI fills: it sits across your GTM and product stack as a persistent intelligence layer, continuously surfacing what customers need, what it’s worth, and what’s blocking deals. Think of it as the always-on version of what you’d otherwise do manually with Claude Code and a handful of MCP connections.
The common thread across all of these: Claude Code gives PMs the ability to do things that previously required either developer time, analyst time, or hours of manual work. The PMs getting the most out of it aren’t the ones who learned to code. They’re the ones who learned to scope tasks clearly, manage context, and treat Claude as a capable but literal-minded collaborator.
Frequently Asked Questions
Claude Code itself is free to install. But you need either an Anthropic API key (pay-per-token) or a Claude subscription to use it. Claude Pro ($20/month) includes Claude Code access with usage limits. Max plans ($100/month or $200/month) provide higher limits and full Opus access. On the API, typical daily cost runs about $6 per developer on Sonnet, with 90% of users staying under $12/day.
Claude.ai is a web-based chat interface. Claude Code is a terminal-based agentic coding tool. Same underlying AI models, different interface and capabilities. Claude Code can read your entire codebase, execute commands, edit files, run tests, manage Git, and work autonomously across multi-step tasks. Claude.ai is better for conversations, research, and document work.
Not necessarily. Claude Code can generate, edit, and debug code on your behalf. PMs and non-engineers have used it to build internal tools, prototypes, and automations. That said, understanding basic terminal commands and version control (Git) will make the experience significantly smoother.
It’s a Markdown file in your project root that Claude loads automatically at the start of every session. It acts as persistent project memory: your architecture, conventions, tech stack, and any rules you want Claude to follow. Without it, every session starts cold. With it, Claude already knows your project. Run /init to generate one.
200K tokens by default (roughly 150,000 words or 500 pages of code). Everything in the conversation fills it: your messages, Claude’s responses, files it reads, command outputs. When it gets past about 50% full, performance degrades. Use /clear to reset or /compact to summarize and free up space. Some models support up to 1M tokens via the API, but this requires a higher-tier plan.
Skills are reusable instruction sets that tell Claude how to handle specific types of tasks. They load on-demand and don’t clutter your context. Subagents are temporary Claude instances that run research or verification in a separate context window and report back. Agent Teams are multiple Claude instances that work in parallel and can communicate with each other directly. Use Skills for repeatable workflows, Subagents for focused research, and Agent Teams for complex multi-part projects.
Yes. There’s a VS Code extension (also works with Cursor). It doesn’t replace Claude Code’s terminal interface. It’s a launcher that makes opening Claude Code sessions easier and lets you run multiple instances side by side in your IDE.
Model Context Protocol servers connect Claude Code to external tools like GitHub, Notion, Jira, Figma, databases, and documentation services. You don’t need them to use Claude Code. Think of them as optional integrations. The tradeoff: each connected server adds tool definitions to your context, eating tokens. Only enable the ones you’re actively using.
Claude Code asks before editing files or running commands. You can customize the permission allowlist in .claude/settings.json using wildcard syntax (e.g., Bash(npm run *), Edit(/src/**)). There’s also –dangerously-skip-permissions for full autonomy, but use this only in sandboxed or non-sensitive environments.
Yes. Claude Code sends your prompts, file contents, and command outputs to Anthropic’s API for processing. Code is not used for model training. Anthropic has limited retention periods for session data. For sensitive codebases, check Anthropic’s data usage policies and discuss with your security team before adopting.
Sonnet for 80% of tasks. It’s fast, capable, and cost-effective. Switch to Opus for complex architecture decisions, deep debugging, or long-context analysis. Haiku for simple lookups and summaries. The opusplan alias uses Opus for planning and Sonnet for execution, which is a good middle ground for complex work.
Use /clear between tasks. Run /compact when conversations get long. Stick to Sonnet for routine work. Disable MCP servers you’re not using. Keep CLAUDE.md under 500 lines and move specialized instructions into Skills. Avoid switching models or adding MCP tools mid-session (this breaks prompt caching and spikes costs). Check /cost periodically to catch problems early.
