Aakash GuptaThe Claude Setup That Let a PM Beat 30 Engineering Teams
CHAPTERS
- 0:00 – 2:47
Why “surface selection” is a core PM superpower in the Claude era
Jyothi and Aakash set the stakes: using Claude well isn’t just about prompting—it’s about picking the right interfaces, workflows, and automations to become dramatically more effective. They preview the episode’s goal: take beginners from “chat-only” usage to a full Claude ecosystem setup.
- •Surface choice (web/desktop/mobile/Chrome/IDE) materially changes what Claude can do
- •Goal is a practical, structured path from beginner to builder-level capability
- •Preview of key topics: Claude Code, Claude Design, MCP servers, chief-of-staff setup
- •Framing: PM effectiveness comes from systems, not one-off chats
- 2:47 – 4:31
Hackathon win vs 30 engineering teams: adversarial agents as the differentiator
Jyothi explains how she used Anthropic’s ideas on long-running agents and adversarial agents to build an evaluator that tested and hardened an agent. She took the concept into Claude Code, iterated for a day, and integrated it against real company code to win the internal hackathon.
- •Inspiration: Anthropic post on harnesses/long-running agents and adversarial agents
- •Built a separate evaluator agent to test capabilities that matter to the company
- •Used Claude Code to rapidly prototype and iterate configurations
- •Integrated into production code/codebase to demonstrate real impact
- 4:31 – 7:14
The five-layer Claude stack: models → surfaces → knowledge base → integrations → agents
Jyothi introduces a layered mental model for the Claude ecosystem, emphasizing that most PMs underinvest in context/knowledge. The stack explains how to progress from raw model selection to automated agents and orchestration.
- •Layer 1: Models (Haiku/Sonnet/Opus) with different cost/intelligence profiles
- •Layer 2: Surfaces (web/desktop/mobile/Chrome/IDE) are distinct products with unique capabilities
- •Layer 3: Knowledge base (projects, memory, custom instructions) turns Claude contextual
- •Layer 4: Integration fabric (MCP/connectors) bridges external systems like Slack/Drive/Jira
- •Layer 5: Agents & orchestration (Claude Code, Cowork, Design, Channels)
- 7:14 – 9:55
Model selection framework: Haiku vs Sonnet vs Opus (and Opus ‘stuck’ behavior)
They map each Claude model to PM-relevant workloads and highlight practical tradeoffs. Sonnet is recommended as the default for most PM work, while Opus is reserved for high-stakes reasoning and Haiku for high-volume throughput.
- •Haiku: fast/cheap for volume tasks (triage, tagging, classification)
- •Sonnet: best quality-to-cost; default for PRDs, synthesis, briefs, competitive analysis
- •Opus: best for complex reasoning/trade-offs/long-horizon planning, but can get ‘stuck’
- •Practical tactic: start with Sonnet, escalate to Opus only when needed
- 9:55 – 14:52
Picking the right surface: web vs desktop vs mobile vs Chrome vs IDE for Claude Code
Jyothi explains why ‘surface’ is not just UI: it determines access to local files, scheduling, browsing/computer use, and building. They cover how each surface fits common PM workflows and where Claude Code belongs.
- •claude.ai (web): great for chat, weaker for local-system workflows
- •Desktop app: local file access + Cowork scheduled automations; best for daily workflows
- •Mobile: monitor long-running tasks and stay productive on the go
- •Chrome plugin: browser/computer use for competitive research and agent-driven user testing
- •Claude Code: used inside an IDE (VS Code/Cursor) for building and prototyping
- 14:52 – 16:05
Cowork vs Chat: turning recurring PM work into scheduled automations
They differentiate conversational Chat from automation-focused Cowork. Jyothi demonstrates how time-based runs can generate a morning brief, standup prep, and end-of-day wrap—reducing PM busywork while keeping outputs concise and reliable.
- •Chat: quick Q&A and exploration; Cowork: automation and scheduled runs
- •Core automations: morning brief, standup brief, end-of-day summary
- •Use connectors (Calendar, Gmail, Drive, Jira; optionally Slack) as data sources
- •Guardrails matter: word limits, “no hype,” “don’t invent,” aggressive filtering
- 16:05 – 20:13
Building the ‘Chief of Staff’ morning brief (connectors, formatting, guardrails)
Jyothi walks through a concrete Cowork configuration: pull calendar events, related docs, email threads, and Jira items into a daily brief. She shows how connectors are added, why markdown headings help, and why strict constraints improve usability.
- •How to add connectors: Customize → Connectors → authenticate tools (Atlassian, Gmail, etc.)
- •Prompt structure: data sources → steps → output format → rules
- •Key rules: keep under ~400 words, facts only, no invented deadlines/action items
- •Practical detail: scheduled runs only execute when the laptop is on
- 20:13 – 26:17
Standup and end-of-day summaries: dashboards, nested automations, and why NL beats ‘box’ tools
They expand from morning brief to sprint/standup briefing and EOD wrap-ups. Jyothi contrasts Cowork’s natural-language robustness with brittle node-based automation tools and suggests deeper workflows like Slack pings for stalled tickets or auto-PR creation.
- •Standup brief: fetch sprint issues, done/in-progress/blocked/new; keep under 250 words
- •EOD brief: compare plan vs what happened, note slips, preview tomorrow
- •Optional dashboards: ask Cowork to render results in a viewable dashboard
- •Nested automations: e.g., detect no-progress tickets and ping assignees on Slack
- •Why Cowork differs from Make/n8n/Gumloop/Lindy: fewer brittle dependencies; NL orchestration
- 26:17 – 34:28
Skills: progressive disclosure, multi-file playbooks, and PM skill library priorities
Jyothi explains ‘Skills’ as reusable, context-efficient playbooks that load only when relevant. She shows a customer-interview synthesis skill with citation requirements, linked frameworks, and templates—plus guidance on writing and maintaining skills over time.
- •Skills load minimally (name/description) until invoked—reduces context bloat
- •Modern skills can include multiple files, templates, and linked frameworks/functions
- •Example: interview synthesis with citations, behavioral vs stated prefs, contradictions
- •Best practice: AI drafts, humans add domain judgment, structure, and templates
- •Recommended PM skills: backlog triage, PRDs, interview synthesis, support-ticket handling
- 34:28 – 34:59
AI Chief of Staff from scratch: designing a workplace knowledge base (people, politics, decisions)
Moving beyond connectors, Jyothi designs a local knowledge base that captures meetings, documents, people profiles, and organizational dynamics. The chief-of-staff agent uses this KB to coach on relationships, sensitivities, and decision-making with real organizational context.
- •Inputs: meeting transcripts (e.g., Granola/Meet/Zoom), strategy docs, PRDs, emails
- •KB schema: people/topics/meetings/documents/company + insights (patterns/politics)
- •People profiles: motivations, comms style, meeting behavior, relationship quality over time
- •Value: post-meeting coaching (who to ally with, who to inform first, political sensitivity)
- •Key data sources: meeting transcripts, key strategy docs, Slack threads
- 34:59 – 49:52
Implementing a local KB MCP server in Claude Code (VS Code) and wiring it into Claude Desktop
Jyothi demonstrates building the KB folder structure and an MCP server (read/write tools) using Claude Code inside VS Code. They discuss why MCP makes the KB accessible from normal Claude Desktop chats, not just the IDE session, and why local storage matters for privacy.
- •VS Code setup: install Claude Code extension; start new session; use plan vs auto/edit modes
- •Build artifacts: KB folder structure + MCP server exposing tools (e.g., read/write/extract)
- •Why MCP: enables Desktop Claude to query/update the KB like a tool, not manual file browsing
- •Local-first rationale: sensitive workplace context kept on laptop vs cloud apps
- •Workflow: restart Claude Desktop to load the new local MCP server connector
- 49:52 – 59:02
Projects + ingestion workflow: logging transcripts automatically and keeping KB fresh
They show how to create a Claude Project, paste a chief-of-staff system prompt into project instructions, and then log a transcript into the KB via MCP tools. Jyothi outlines automation options to ingest new transcripts or even emails as they arrive.
- •Project organization: one per swimlane/product area; store tailored instructions/context
- •System prompt: role, objectives, style constraints, and tool usage policies
- •Demo: paste transcript → Claude requests permission → writes structured notes into KB
- •Automation idea: Cowork trigger on transcript email arrival to auto-ingest into KB
- •Tradeoff: broad ingestion (e.g., all emails) creates a richer KB but can burn tokens
- 59:02 – 1:02:06
MCPs every PM needs: practical integration priorities and ‘don’t go on a shopping spree’
They generalize MCP beyond the KB example: MCP is the integration fabric connecting Claude to core PM systems. Jyothi recommends starting with high-frequency tools, then expanding based on real needs—or even asking the chief-of-staff agent what’s missing.
- •Baseline PM MCPs: Gmail, Calendar, Slack, meeting transcripts store, Jira
- •Add product systems: analytics (Amplitude), dashboards, CRM, observability tools
- •Remote vs local MCP distinction (SaaS connectors vs local KB server)
- •Avoid random integrations; connect based on workflows and problems you’re solving
- •Use the chief-of-staff agent to suggest missing integrations referenced in meetings
- 1:02:06 – 1:08:37
Claude Design for decks and prototypes: brand-consistent visuals, carousels, and fast exec-ready slides
Jyothi tours Claude Design (research preview) for prototyping, slide decks, and brand design systems. She shows how to generate a LinkedIn carousel and edit visually with comments/drawing—then argues it can replace tools like Gamma for many PM presentation needs.
- •Access: claude.ai/design (separate from main claude.ai)
- •Capabilities: wireframes vs hi-fi prototypes; slide decks with speaker notes; templates
- •Design systems: import brand assets/figma/github to keep output on-brand
- •Visual editing: direct comments/edits/drawing gestures to instruct changes
- •Use cases: exec-ready decks, marketing/training materials, quick design artifacts
- 1:08:37 – 1:12:53
Hackathon reveal: building a GAN-inspired adversarial evaluator loop in Claude Code
Jyothi builds the adversarial evaluation tool live: a generator agent, adversary/red teamer, and evaluator with a rubric and pass thresholds. They discuss UI choices (CLI/JSON vs Streamlit), then run a smoke test that iteratively hardens system prompts until they pass.
- •Concept: GAN analogy—generator produces, adversary attacks, evaluator scores
- •Configuration choices: model selection (Sonnet), output format (CLI/JSON), iteration limits
- •Core loop: adversarial feedback fed back into the agent until passing threshold
- •Demo output: attack generation, score trajectory, and hardened final system prompt
- •Key success factor beyond code: domain taste—choosing what criteria/edge cases to test
- 1:12:53 – 1:33:20
The new ‘AI builder’ PM and the self-improving product loop: how roles and ratios change
They zoom out to career implications: PM, engineering, and design roles are collapsing into builder-like roles, and interview loops increasingly include live prototyping. They close with the vision of an end-to-end, self-improving product development loop powered by agents from intake to shipping to analytics.
- •Emerging role: AI builder / member of technical staff; PM-engineer boundaries blur
- •Claimed ratio shift: from ~1 PM:8 engineers toward more PM/build capacity
- •Interview changes: product sense remains, plus AI fundamentals + live ‘vibe coding’ rounds
- •Preparation: build products (not demos), iterate with real users, learn AI basics
- •System vision: support tickets → triage → research/prototype → code/telemetry → review → ship → analytics feedback loop
