CHAPTERS
- 0:00 – 3:27
Why PM scope is exploding—and why a shared AI context system matters
Aakash frames the problem: PMs are increasingly supporting larger, cross-functional teams while roles blur across engineering, design, analytics, and ops. Hannah argues the winning approach is to centralize context so everyone can make better decisions faster.
- •PMs now support 10+ engineers plus many non-engineering stakeholders
- •Functional boundaries are blending; everyone makes product decisions
- •PMs increasingly do analysis, prototyping, and design-like work
- •Teams need shared, accessible context to move quickly
- 3:27 – 3:57
Defining “Team OS”: a repo-based knowledge system for the whole team
Hannah introduces Team OS as a single repository that stores a team’s shared knowledge and operating context. She outlines the three major areas and what the root CLAUDE.md is responsible for.
- •Team OS = team-wide knowledge base optimized for an AI coding agent
- •Top-level structure: .claude, product development, and team folders
- •Root CLAUDE.md provides global guidance for agent navigation
- •Designed for cross-functional use, not just PMs or engineers
- 3:57 – 5:59
Root CLAUDE.md essentials: doc index + people + channels for action
The root CLAUDE.md is intentionally lightweight and focuses on what’s needed frequently. Hannah explains why including team roster, handles, and Slack channels enables natural-language actions via MCP integrations.
- •Keep root CLAUDE.md lean—avoid dumping lots of instructions
- •Doc index teaches the agent where to find different information
- •Include team members + tool handles to reduce repeated re-explaining
- •Include Slack channels/DM groups so prompts like “send to eng channel” work
- 5:59 – 8:27
Context management 101: windows, compaction, and preserving thinking room
Hannah explains the theory behind the repo design: context is finite, compaction reduces fidelity, and too much context kills reasoning space. The system is built to load only what’s needed, when it’s needed, and she monitors context usage live.
- •Context = information available to the LLM in-session
- •Context window is large but still smaller than total company docs
- •Compaction compresses and loses detail when context fills up
- •“Thinking room” shrinks as more irrelevant context is loaded
- •A status bar helps track context consumption in real time
- 8:27 – 10:13
Nested CLAUDE.md files as doc indexes: fast routing without waste
They dig into how nested CLAUDE.md files act like folder-level indexes. Hannah demonstrates how Claude navigates directly to relevant files for a query instead of exploring the whole repo.
- •Folder-level CLAUDE.md files primarily contain doc indexes
- •Indexes prevent expensive “explore agents” searching blindly
- •Demo: asking “Who are my top customers?” loads only customer-related context
- •Minimizing irrelevant reads preserves context and reasoning capacity
- 10:13 – 13:24
Structuring customer research: summaries-first and account-level indexing
Hannah shows how structured customer folders enable quick synthesis across many calls. The system prefers summary files and only drills into transcripts if required, enabling high-fidelity insights at speed.
- •One file per customer account with its own CLAUDE.md and index
- •Store key contacts/segment/context that’s needed frequently
- •Use summaries as the default retrieval surface; transcripts are fallback
- •Natural-language queries can generate meeting recaps and theme analysis quickly
- 13:24 – 17:13
Shared skills, commands, and consistent templates to scale quality
Hannah explains that consistency is leverage: standardized call summaries make cross-customer synthesis easy. Shared “skills” enforce structure so many contributors produce outputs Claude can reliably interpret.
- •LLMs can handle unstructured text, but standardized structure is faster and safer
- •Create shared “customer call summary” skills/templates
- •Consistency enables synthesis across hundreds of calls taken by many people
- •Skills turn messy human inputs into predictable, reusable artifacts
- 17:13 – 20:15
Scaling analytics: metrics, dashboards, SQL queries, and schemas as first-class artifacts
The Team OS includes an analytics area designed to let PMs and engineers do correct analysis without reinventing logic. Hannah shows how to organize by product/topic and retrieve metric definitions, queries, and schemas on demand.
- •Analytics folder includes dashboards, experiment results, investigations
- •Core structure: metrics definitions, SQL queries, and table schemas
- •Organize by topic/product area to keep retrieval targeted
- •Demo query returns metric definition + SQL + schema for correct computation
- 20:15 – 23:20
Reducing hallucinations: verified playbooks owned by analysts/data scientists
Hannah emphasizes governance: analysts own the analytics folder and audit playbooks, join keys, and definitions. This makes self-serve analysis safer and supports on-call debugging without waiting for specialists.
- •Analyst/data scientist curates and validates definitions and queries
- •Playbooks teach correct methods (e.g., funnel/drop-off analysis)
- •Verified repo context reduces incorrect analysis and hallucinations
- •Feature launch checklist includes updating the repo before rollout
- 23:20 – 25:49
Engineering and cross-functional knowledge: bug investigations, RFCs, and shared ownership
The repo extends beyond product and analytics into engineering knowledge like RFCs and bug investigation writeups. Hannah stresses that everyone contributes and functional leads coordinate structure, enabling AI-native team performance.
- •Store bug investigations with scope, root cause, fixes, queries, examples
- •Reuse historical investigations to speed future incident response
- •Functional leads guide structure, but everyone contributes and updates
- •Shared automations can synthesize weekly learnings and post to Slack
- 25:49 – 33:43
Day-to-day workflow: write in Claude, commit to GitHub, review via PRs (even for non-technical roles)
Hannah describes operating almost entirely inside Claude Code: drafting documents, committing changes, opening PRs, and notifying reviewers via Slack automation. She argues this is accessible to non-technical partners and becomes the team’s collaboration hub.
- •Docs are drafted in Claude and checked into the repo for review
- •Use branches, commits, and PRs; tag the right reviewer per artifact
- •Claude can drive GitHub CLI/MCP workflows via natural language
- •Automated PR creation and Slack posting standardize coordination
- •Non-technical ops/strategy partners can learn GitHub and contribute daily
- 33:43 – 48:20
Plan mode for better docs: clearing context, planning phases, and verification
They demonstrate why Plan mode yields higher-quality outputs than basic prompting by removing the model’s bias for immediate action. Hannah shares advanced planning tactics: phased work, checkpoints, citations/verification, and plan persistence.
- •Clear context when switching tasks to avoid contamination
- •Plan mode (Shift+Tab twice) focuses on planning instead of acting
- •Add phases, parallelized research, and checkpoints before drafting
- •Define verification: citations, URLs, or automated checks (e.g., Playwright)
- •Tune effort levels; high effort works best for reasoning/writing
- 48:20 – 59:45
Parallel agents and plan artifacts: prompts, temporary files, and reviewable work chunks
Hannah explains how to scale complex writing and research by splitting tasks across agents with controlled inputs. She recommends storing plan files in the repo, reviewing agent prompts, and writing outputs to temp files to avoid context crashes.
- •Ask Claude to show the prompts it will send to sub-agents
- •Ensure each agent gets the right context (writing guides, source files)
- •Have agents write to temporary files; parent agent synthesizes later
- •Avoid context overload when multiple agents return large outputs at once
- •Save plan files in the repo since ephemeral plans are wiped after 24–72 hours
- 59:45 – 1:10:10
The learning flywheel: beginner mindset, iterating skills, and choosing the right AI tool
Hannah and Aakash close with habits that compound: ask Claude to teach you why things work, regularly audit your setup against new releases, and don’t quit early. They discuss when to use chat vs coding agents, how to free time to learn, and why “Claude Code” is a misleading name.
- •Beginner mindset: ask Claude to explain structures (e.g., YAML feature index)
- •Create a personal upgrade loop by researching recent releases and best practices
- •Biggest mistake: giving up too early; mastery requires iteration
- •Under-hyped: curiosity and going deep on one area; avoid shallow breadth
- •Tool choice: quick chat for low-context, coding agents for advanced PM work
- •Automate to free learning time; connect MCPs/CLIs across your tool stack
