# PM Operating System — Build Guide > Source: "The Claude Setup That Let a PM Beat 30 Engineering Teams" — Aakash Gupta's *Product Growth* podcast ft. Jyothi Nookula, AIPM ex-Netflix/Meta/Amazon. > Purpose: paste this whole file into Claude (or Claude Code) and say **"Build my PM Operating System following this guide, starting at Phase 0"**. It contains the architecture, the exact prompts, and the build order needed to go from zero to a working system. --- ## 0. The Mental Model: The Claude Stack Everything below is one of five layers. Higher layers depend on the ones below being set up correctly. ``` Layer 5 — Agents & Orchestration (Claude Code, Claude Design, Cowork automations, adversarial evaluators) Layer 4 — Integration Fabric (MCP servers: Gmail, Calendar, Drive, Jira, Slack, CRM… + Skills) Layer 3 — Knowledge Base (Projects, Skills, Memory, custom instructions — your institutional context) Layer 2 — Surfaces (claude.ai web, Desktop+Cowork, Mobile, Chrome extension, Claude Code in IDE) Layer 1 — Models (Haiku, Sonnet, Opus) ``` Most PMs underinvest in Layer 3 (knowledge base) and jump straight to prompting Layer 1. The compounding value is in 3 and 5. --- ## Phase 0 — Prerequisites - [ ] Claude Pro (or higher) subscription — required for Cowork automations (~$20/mo minimum) - [ ] Claude Desktop app installed - [ ] VS Code (or Cursor) installed, with the **Claude Code** extension installed from the Extensions marketplace - [ ] List your core tools: email (Gmail?), calendar (Google Calendar?), issue tracker (Jira?), chat (Slack?), meeting transcript source (Granola / Google Meet / Zoom?), design tool (Figma?), docs (Google Drive / Notion?) --- ## Phase 1 — Layer 1: Pick the Right Model for the Task Use this decision framework instead of defaulting to one model for everything: | Model | Use for | Notes | |---|---|---| | **Haiku** | High-volume, low-depth tasks: generating many variants, triaging a pile of documents, quick classification/tagging | Fastest, cheapest. No deep reasoning needed for these tasks. | | **Sonnet** | ~90% of daily PM work: drafting PRDs, synthesizing user research, competitive analysis, stakeholder briefs, roadmap thinking | Best quality-to-cost ratio. Default starting point. | | **Opus** | High-stakes, high-complexity reasoning: trade-off analysis, reconciling contradictory research, long-horizon planning with 2nd/3rd-order implications | Can get "stuck" looping on one reasoning path — if it stalls, start a fresh chat rather than continuing, or drop back to Sonnet. | **Rule of thumb:** start with Sonnet. Escalate to Opus only if Sonnet's output lacks the depth you need. Use Haiku for anything that's volume-over-depth (this also keeps automation token costs down). --- ## Phase 2 — Layer 2: Know Your Surfaces These are not the same product with different skins — each has different capabilities. | Surface | Best for | Limitation | |---|---|---| | **claude.ai (web/browser)** | Quick conversational Q&A, research-style questions ("what is X vs Y") | No access to local files/system | | **Claude Desktop + Cowork** | Scheduled automations, connectors to Gmail/Calendar/Drive/Jira/Slack, "chief of staff" style briefs | Automations only run while your laptop is on | | **Mobile app** | Checking in on running tasks/automations while away from your desk | Not for building | | **Chrome extension (computer use)** | Competitive research via live browser control, user-testing your own product ("act like a real user and try this") | Slower; use for tasks that need to see live web pages | | **Claude Code (VS Code / Cursor / terminal)** | Building — knowledge bases, MCP servers, agents, prototypes | Requires comfort with an IDE; VS Code is the gentler on-ramp vs. Cursor or raw terminal | | **claude.ai/design** (research preview) | Slide decks, wireframes, high-fidelity prototypes, marketing carousels, on-brand assets via Design Systems | Separate surface, not yet integrated into claude.ai directly | **Decision rule:** conversational question → chat. Recurring/scheduled work → Cowork. Needs local file or MCP access while building → Claude Code. Needs visual design output → Claude Design. --- ## Phase 3 — Layer 3: Build Your Knowledge Base (the "Chief of Staff") This is the highest-leverage piece of the whole system. It turns Claude from a generic chatbot into something grounded in your actual job, org, and history. ### 3.1 Give Claude Code the brief Open Claude Code (VS Code extension → new session) in an empty project folder and give it a prompt like this (adapt the bracketed parts to your situation): ``` I want to build a personal AI agent that helps me navigate my work — strategy, execution, people, and politics. I'm [your role] at [company/context]. The agent should: - Learn from my meeting transcripts (I use [Granola / Google Meet / Zoom]) - Ingest documents: strategy docs, org charts, PRDs, emails - Build a knowledge base over time about: people, dynamics, topics, company context Write me an architecture overview covering: 1. Inputs and document ingestion pipeline 2. Knowledge base folder structure 3. Extraction templates per document type 4. The agent's system prompt ``` Let Claude Code write this as a full architecture markdown file first (use **Plan Mode** — Shift+Tab — so it only plans, doesn't code yet). Review and edit it before proceeding — this is the step to inject your own domain judgment; don't just accept the AI-generated version wholesale. ### 3.2 Knowledge base folder structure ``` context-kb/ ├── company/ # company strategy, OKRs, org-level context ├── people/ # one profile per person you work with ├── topics/ # ongoing workstreams / initiatives ├── meetings/ # meeting extraction logs ├── documents/ # strategy docs, PRDs, etc. once processed └── my-context/ ├── priorities.md ├── okrs.md ├── preferences.md ├── notes.md ├── questions.md ├── insights.md # patterns observed over time ├── political-landscape.md └── todo.md ``` ### 3.3 Document extraction prompt (give this to Claude Code as the extraction logic) ``` You're helping me build a knowledge base about my workplace. I'll share a document — extract the relevant information and format it for storage in the knowledge base. For strategy/planning docs, extract: goals, priorities, metrics, timelines. For org charts, extract: roles, reporting lines, team composition. For PRDs, extract: problem statement, target user, scope, success metrics, open questions. For emails/communication, extract: decisions made, commitments, sentiment, follow-ups needed. For meeting transcripts, extract: attendees, key decisions, action items, notable behavioral signals (pushback, hesitation, enthusiasm), relationship signals. For every document, capture: metadata, summary, key points, people involved, relevance to my priorities, action items, and raw notes (verbatim quotes where useful). For a person profile, extract and continuously update: how they operate, communication style, meeting behavior, what works/doesn't work with them, what they care about, their motivations, their relationship to me, and a running relationship-quality rating (strong ally / friendly / neutral / cautious / friction). ``` ### 3.4 Agent system prompt (paste into a Claude Project's custom instructions once the KB + MCP server exist) ``` You are my personal chief of staff, an AI advisor who helps me navigate my work. I'm [role] at [company], and I have MCP access to my context knowledge base — use these tools whenever relevant. Your job: - Help me ramp up fast on people, projects, and context - Give me strategic advice grounded in my actual context, not generic advice - Help me prepare for meetings - Coach me on people and politics - Help me think through decisions - Connect dots across documents and meetings - Keep me focused on my priorities Style: don't sugarcoat politics. Give me facts, not hype. When I share a document or meeting transcript, extract the key information and update the relevant knowledge base sections automatically. ``` ### 3.5 Turn the knowledge base into an MCP server Tell Claude Code (in Plan Mode first, then switch to auto-edit with Shift+Tab): ``` Build MCP servers for reading and writing to this knowledge base, so I can chat with it from Claude Desktop. Claude Desktop should also be able to connect to Google Drive and Slack directly. Create the context-kb folder structure. Write my initial goals/priorities file. Ingest any onboarding docs I give you. After every meeting, run the transcript through the extraction pipeline. The knowledge base should compound over time — every new document or transcript should update existing person/topic files, not just append new ones. ``` **Why an MCP server and not just markdown files?** It lets you *talk* to the knowledge base conversationally from Claude Desktop ("I'm meeting my manager tomorrow — what should I know?") instead of manually opening files. Claude reads and writes to it directly. **Where to host it:** local filesystem is recommended for sensitive org/people data — it stays on your machine, not a vendor cloud, and leaves with you (or rather, doesn't) when you leave the company. Obsidian or Notion work too if you prefer a UI; just point the system prompt at that store instead. ### 3.6 Activate it 1. Fully quit Claude Desktop (Cmd+Q) and reopen it. 2. Go to **Customize → Connectors** — confirm your new local MCP server shows up. 3. Start a new chat, insert the chief-of-staff system prompt (Section 3.4) as **Project custom instructions** in a new Project. 4. Test: paste a real meeting transcript and say "log this into KB." Approve the tool-use permission prompt (first time only — after that it's automatic within that project). 5. Ask your chief of staff directly: *"What else should I connect to?"* — it will infer new integrations to add based on what's showing up in your meetings/docs but that it can't yet access. ### 3.7 Projects Organize Claude Projects the way you'd organize folders — one project per distinct area of unique context (e.g., one per product line/swim lane you own, or one per company if you only have one). Put the relevant slice of context and instructions in each project's custom instructions. --- ## Phase 4 — Layer 4: Integrations (MCPs) and Skills ### 4.1 MCP connectors to prioritize Connect what you actually use, in this rough priority order — don't MCP-shop for its own sake: 1. Email (Gmail/Outlook) 2. Calendar 3. Meeting transcript source (Granola / Google Meet / Zoom) 4. Chat (Slack) — often the richest context source after transcripts 5. Issue tracker (Jira / Linear) 6. Docs/drive (Google Drive / Notion / Confluence) 7. Analytics (Amplitude, etc.) and observability (e.g. Radar) if relevant to your role 8. CRM, ad platforms, or domain-specific tools (e.g., internal model APIs) as needed In Claude Desktop: **Customize → Connectors → +** to add each one; you'll be prompted to authenticate. ### 4.2 Skills to build first A **Skill** is a markdown playbook (optionally with linked sub-files and functions) that Claude loads via progressive disclosure — only ~50 words (name + description) sit in context until the skill is actually invoked, so having many skills doesn't bloat your context window. Build these, roughly in this order: 1. **Backlog triaging** — give it context on your product/prioritization framework 2. **PRD writing** — your company's actual PRD template and standards 3. **Customer interview synthesis** (full example below) 4. **Support-ticket → Jira ticket** conversion (can be trigger-based, not time-based — see 5.1) **Maintenance rule:** revisit a skill file roughly once a quarter, or sooner if (a) your domain/process changes, (b) how often you use the task changes, or (c) output quality starts drifting from what you want. **Important:** you can have Claude draft the initial skill file, but research (and this operator's experience) shows AI-authored skill files are less effective than ones a human has tuned. Use Claude to draft, then personally add your own template structure, edge cases, and domain judgment before finalizing. ### 4.3 Example skill: Synthesizing Customer Interviews Structure (as a skill markdown file with linked sub-files): ``` # Skill: Synthesize Customer Interviews When to use: after any customer interview, focus group, or beta-test feedback session. Steps: 1. Inventory the inputs (list every transcript/note being synthesized) 2. Extract observations with citations — use the speaker's own words, do not interpret yet. See evidence-rules.md for selection criteria and handling ambiguity. 3. Separate behavioral observations from stated preferences 4. Cluster into candidate patterns. See jobs-to-be-done-framework.md 5. Apply the pattern threshold (a pattern needs ≥N independent mentions to count) 6. Surface contradictions between sources explicitly — do not paper over them 7. Draft hypotheses 8. Validate every claim against its source before finalizing 9. Assemble the final output using output-template.md ``` Linked files: `evidence-rules.md`, `jobs-to-be-done-framework.md`, `output-template.md`. Keep the main skill file under ~500 lines; push detail into linked files the skill pulls in only when that step is reached. --- ## Phase 5 — Layer 5: Agents & Orchestration ### 5.1 Cowork scheduled automations Set these up in Claude Desktop → Cowork. Remember: **automations only run while your laptop is on** — pick times accordingly. **A. Morning Brief (e.g., 9:00 AM daily)** ``` You're my chief of staff. Generate my morning brief for today. Data sources: Google Calendar, Gmail, Google Drive, Jira. - Pull today's calendar events. For each meeting, capture title, time, attendees, description, and any attached docs. - For meetings with external attendees or that look important, search Drive for attached or recent docs matching the meeting title/attendee names, and read enough to know the agenda. - Search Gmail for recent related threads. - Pull Jira items needing my attention. Output format: - Top 3 things to focus on today - Calendar today - Inbox items needing attention - Jira items needing attention Rules: - Keep it under 400 words. - State facts only — no hype, no "great news!" framing. - Never invent deadlines or action items that weren't actually there. - If it's a light day, write a 3-line brief and stop. - Use markdown formatting with headings. ``` Use **Haiku** for this — it's volume/retrieval work, not deep reasoning, and keeps token cost down. **B. End of Day Wrap-up (e.g., 5:00 PM daily)** ``` Same data sources as the morning brief. - Read this morning's brief (what was planned). - Pull what actually happened today: which meetings happened, which were cancelled. - Pull tomorrow's calendar as a preview. Output format: - What shipped - What slipped - What's new from today - Tomorrow at a glance Same rules as morning brief (facts only, no invented items, markdown headings). ``` **C. Standup Briefing (tied to your sprint cadence)** ``` Use the Jira/Atlassian connector to fetch all issues in the active sprint. Give me, since yesterday: - Issues moved to Done in the last 24 hours - In-progress issues - Blocked or at-risk issues - New issues since yesterday - Overall sprint health Keep the total under 250 words. Render as a dashboard. ``` **D. Support-ticket → PR pipeline (trigger-based, not time-based)** When a customer support ticket lands, automatically: create a Jira ticket from it → point Claude Code at the relevant repo to implement a fix → open a PR for human review. **General rule for what to automate:** time-based, personal-productivity, recurring-cadence work (briefs, standups, weekly manager-prep) → Cowork scheduled automation. Everything else that's a repeatable *task* (not a schedule) → a Skill, possibly referenced by an automation. ### 5.2 Claude Design (claude.ai/design — research preview) Use for: - Slide decks (attach speaker notes; can match your brand via a **Design System** built from a Figma file, GitHub link, or uploaded brand assets) - Wireframes and high-fidelity prototypes - Marketing carousels / social content - Training playbooks for sales/CS teams You can mark up outputs directly (comments, drag-to-edit, freehand annotation like "make this counter-clockwise") and Claude executes the edit — closer to directing a designer than re-prompting from scratch. **When to use Claude Design vs. Claude Code for prototypes:** quick/low-fidelity concept to react to → Claude Design. Something people need to actually click through and use (real user testing) → Claude Code, spin up a working app. ### 5.3 Adversarial Agent Evaluator (GAN-inspired self-improvement loop) This is the hackathon-winning technique. It's a generator/adversary pair inspired by Generative Adversarial Networks: a generator produces an artifact (here, an agent's system prompt), an adversary/evaluator attacks it and scores it, and the loop repeats until the generator's output survives the adversary. **Build prompt for Claude Code** (new empty project folder, new session): ``` Let's build an adversarial evaluator. Architecture: as soon as I build an agent, automatically run a red-teaming / adversarial evaluation loop against it. Feedback from the adversarial agent goes back to the generator agent, which revises, and the loop repeats until the agent passes the adversary's criteria (or a max-iteration cap is hit). Configuration: - Agent interface under test: [e.g., a Claude system prompt] - Model powering the adversary and the evaluator: [pick — Sonnet is a reasonable default] - Output/results format: [CLI + JSON is fine for a developer audience; build a Streamlit/web UI instead if your audience is non-technical] - What should the adversarial feedback iterate on: [e.g., just the system prompt, to start] - Passing criteria: [e.g., mean score > 8 across all evaluation criteria] - Max iterations before giving up: [e.g., 5] ``` **Use Plan Mode (Shift+Tab) first** to have Claude Code ask clarifying questions and lay out the architecture before writing code; switch to auto-edit (Shift+Tab again) once you're aligned. **The real leverage isn't the architecture — it's what you tell the adversary to test for.** Building the loop is now easy; your domain judgment about *which edge cases, which failure modes, which criteria matter* is the actual competitive advantage. Iterate on the evaluation criteria the way you'd iterate on a product spec. **What "done" looks like:** each iteration reports a score (e.g., mean 8.5 → 9.0 → 9.08) and what failed (e.g., "caved on a format-conflict attack"); once the score clears your threshold, the agent gets a pass and you keep the final hardened system prompt. --- ## Phase 6 — Sequencing: What to Build, In Order 1. **Phase 0–2**: install tools, pick default model (Sonnet), pick your surfaces. 2. **Phase 5.1.A**: build one Cowork automation (Morning Brief) first — fastest way to feel the system working and to validate your connectors are authenticated correctly. 3. **Phase 3**: build the Chief of Staff knowledge base + MCP server. This is the long pole but the highest-leverage piece — do it once, benefit compounds forever after. 4. **Phase 4.2**: build 2–3 skills for your most repeated PM tasks. 5. **Phase 5.1 (B, C, D)**: layer in the remaining automations, referencing skills where relevant. 6. **Phase 5.2**: adopt Claude Design for your next deck/prototype instead of Figma/PowerPoint. 7. **Phase 5.3**: once you're comfortable in Claude Code, build an adversarial evaluator for whatever agent you build next — this is also a strong take-home/interview artifact for AI-builder-PM roles. --- ## Appendix: Career Note (from the same source) The line between "PM" and "developer" is moving. New title showing up at Anthropic and OpenAI: **AI Builder** / member of technical staff — PM, design, and engineering roles are compressing (ratios shifting from ~1 PM : 8 engineers toward ~2 PMs : 1 engineer on some teams). To move toward this: - Get fluent in Claude Code and the full ecosystem above — building is now a core PM skill, not just a "nice to have." - Treat side projects as **products**, not portfolio pieces: find a real, finicky-enough problem, get real users, get real feedback, iterate. Interviewers can tell the difference between a demo and something that's absorbed real usage. - Expect AI-round interviews to include: (a) live vibe-coding/prototyping where they watch *how* you steer the AI (do you take its first answer or press on edge cases?), and (b) an AI fundamentals round testing whether you can communicate with ML engineers/researchers — not a coding bar, a fluency bar. - Product fundamentals (product sense, product analytics, scoping) remain the core signal — AI fluency is additive, not a replacement.