Podcast Summary: The Growth Podcast

Episode: How to Build a Team OS in Claude Code

Host: Aakash Gupta
Guest: Hannah Stulberg (PM at DoorDash, ex-Google APM)
Date: April 7, 2026

Episode Overview

This episode is an in-depth masterclass on how to build a “Team OS” (Operating System) using Claude Code — Anthropic’s coding agent platform — shared by DoorDash PM Hannah Stulberg, one of the most advanced Claude practitioners in product management. The conversation covers everything from structuring a high-context knowledge repository for high-leverage teamwork, through advanced prompting and planning techniques, to fostering a growth and beginner’s mindset with AI tools. While coding agents like Claude Code and ChatGPT are at the center, the episode stretches the traditional notion of AI “coding”—showing how these tools can drive cross-functional work and culture for entire product organizations.

Key Discussion Points & Insights

1. The Evolving Role of PMs and Team Context [02:19–05:50]

• PMs are supporting more people and functions than ever before; roles are merging (engineering & design making product decisions, PMs doing analysis and prototyping).
• Hannah: “Everyone kind of needs to have the best context that used to be isolated within different roles on the team.” [02:38]

The Solution: “Team OS”

• Hannah’s “Team OS” is a knowledge base—a version-controlled repository that centralizes product and team context, accessible and actionable for all.
• Three Main Parts:
  • Claude folder: For shared agents, commands, and skills.
  • Product development folder: With subfolders for various functions (analytics, engineering, strategy, etc.)
  • Team folder: Onboarding guides, retros, team-level docs.
  • Claude MD at root: The guiding file for Claude, with a doc index, team roster, and key communication channels; allows Claude to route queries naturally for the whole team. [03:27–05:50]

2. Structuring the Repository & Context Management [05:50–14:58]

Principles of Context Management (“Context 101”) [05:58–09:50]

• Context: Info available to the LLM in a session.
• Context window: Capacity (now up to a million tokens ≈ 7–8 novels).
• Compaction: Info needs to be compressed as window fills; leads to lower fidelity.
• Thinking Room: The “space” for reasoning drops as loaded context goes up; structuring context helps the model think better.

Doc Indexes & Nested Claude.md Files

• Hannah demos using hierarchical doc indexes so Claude navigates only necessary info—resulting in extremely efficient, high-fidelity responses.
• Akash: “So the art of having good Claude MD files is actually minimizing the amount of context that Claude needs…” [09:50]

Structuring for Repeatable, Structured Outputs

• Teams should standardize doc summaries and formats (e.g., customer call summaries) to allow Claude to synthesize across multiple sources with ease.
• Shared “skills” (e.g., customer call summary format) multiply leverage.
• Hannah: “All of your summaries come out with the exact same format, even if…different account managers…would all synthesize things differently.” [14:48]

3. Cross-functional Leverage: Analytics, Eng, & More [15:21–24:52]

Analytics Folder [16:57–23:10]

• Houses links to dashboards, experiment results, and—critically—metrics, queries, and schemas, enabling any team member to perform robust, self-serve analysis.
• Data scientists/analysts co-own and audit this folder.
• Queries can be performed with confidence; no hallucinations, faster investigations.
• Split out metrics vs. queries vs. schemas to avoid unnecessary context consumption.

“The feature is not rolled out until the repository is updated. Because that’s how we know we’re continuing to create that shared context so that everyone has what they need…” [23:10]

Engineering Folder [23:37–24:52]

• Bug investigations, technical docs (RFCs), and more—documented for future reference by anyone.
• All functional leads own their folder and agree on structure for optimal agent performance.
• Automations (e.g. weekly synthesized customer research updates in Slack) further boost team velocity.

4. Teamwide Participation – Not Just for “Techies” [26:17–30:07]

• Everyone (design, engineering, data science, business ops, etc.) writes docs in Claude and checks them into the repo; full participation and shared ownership is a core principle.
• Even non-technical stakeholders quickly learn basic GitHub PR workflows.
  • Hannah: “My strategy partner had never opened GitHub in her life two months ago and now she is putting out PRs every single day.” [29:24]

5. Tactical Workflow for Repo Contribution [27:17–31:27]

• Documents are drafted in Claude, organized by function and quarter inside the repository, and submitted via pull requests (PRs) for targeted review.
• Shared automations for PRs (e.g., Slack notifications) further streamline collaboration.

“You don’t just have a code base, you essentially have a code base of your team’s context for Claude and you are push pulling and sending PRs for that context. And it’s not just PMs doing it, it’s analysts, designers, engineers…” — Akash [28:59]

6. Advanced Prompting and Planning in Claude [34:00–58:24]

Writing High-Quality Docs: The Power of “Plan Mode” [34:00–41:52]

• Compare basic prompt (no direction) vs. planning prompt (outline plan before writing).
  • Use plan mode to get structured plans, prevent wasted tokens, and ensure alignment.
  • Hannah likens Claude to “a really talented, eager junior employee”—success depends on the clarity of your instructions.

Planning Best Practices [42:23–54:56]

• Verification: Plans should specify how output is checked/verified for quality.
• Parallelization: Break down plans so multiple agents/threads can work independently and efficiently.
• Storing Plans: Save plan files in the repository as first-class artifacts for future reference and team learning (inspired by OpenAI-harnessed engineering).
• Orchestrating agent: Specify agent prompts and context for each agent in complex plans—avoids context collisions and crashing.
• Hannah: “I usually keep [progress tracking] all in the plan file because the plan file gets reloaded after compaction.” [57:47]

Using Claude as a Thinking Partner [52:57–56:35]

• Invite Claude to question, push, and interview you before any work begins—surface blind spots, get broader perspectives, iterate on strategy, and refine plans.

“Now Claude and I are getting very crisp on what is going to be done here. And now it’s asking me more questions…it’s pushing my thinking. Right? It’s catching gaps in my reasoning, pushing me to consider, did I intentionally leave something out?” — Hannah [53:35]

Planning: When & How Much? [58:24–59:17]

• Match the depth of planning to level of complexity and ambiguity: “The higher the complexity and ambiguity—the more time and effort you should be investing in the plan.” [59:17]
• For straightforward tasks, lightweight alignment (“What’s your plan?”) is usually enough.

7. Growth Mindset & Continuous Iteration [60:08–62:05]

• Embrace a beginner’s mind—ask Claude to explain why things are structured as they are; use every unfamiliar file or tool as a learning opportunity.
• Don’t blindly clone/download others’ skills—ask Claude to explain and iterate for deeper understanding and innovation.
• Akash’s prompt: Ask Claude to compare your setup to the latest features and top influencer advice to “10x your setup.” [61:17]

8. Rapid Fire – Myths, Mistakes, and Advice [63:26–69:04]

Notable Mistakes

• Biggest error: People give up too quickly. Mastery takes time and iteration. [63:56]

Which Coding Agent?

• No one “right” answer; for advanced PM work, use a coding agent and a context repo; chatbots fine for quick, low-context asks.

Fast Start for PMs

• Take 2 hours to automate something that will free 6 hours next week for learning/experimentation.

What’s Under- or Overhyped?

• Underhyped: “Following your curiosity” and going deep, not just chasing latest news. [66:02]
• Overhyped: Shallow expertise; be willing to spend time to truly master a topic.

Claude Code: A Misleading Name?

• “It’s not just for coding…most of my time is spent writing docs, doing analysis, building prototypes…” [67:05]

Advice for the “Terminal-Scared”

• “Don’t be afraid to be a beginner again…there’s not a big difference between typing into a chatbot and typing into the terminal…” — Hannah [68:10]

On Integrations (MCPs/CLIs)

• “Every single MCP you can access. The limit does not exist. Any core software you use day-to-day should be hooked up.” [68:32]

Notable Quotes & Moments (with timestamps)

• “The biggest mistake is that people give up too early.”
  — Hannah Stulberg [00:36, 63:56]

• “I think the future looks like…a singular PM is going to be supporting a broader set of functional roles and at a much higher number than in…previous team sizes.”
  — Hannah Stulberg [02:19]

• “What you want in a Claude MD is things that you need on 80% of sessions.”
  — Hannah Stulberg [10:13]

• “All of your work should be on a branch…when a given item is done…you’re going to open a pull request…tag a reviewer…and then merge it into the main branch.”
  — Hannah Stulberg [30:42]

• “If you’re going to send someone off to burn a bunch of your tokens…you probably want to know what your employee is going to do. And so I will always actually read through the plan…”
  — Hannah Stulberg [42:30]

• “Invite Claude to push my thinking and help me consider other angles that we might want to pull into this document…”
  — Hannah Stulberg [52:57]

• “I really view [Team OS] as a way for everyone on the team to scale themselves and help everyone to leverage what’s best about all of their teammates.”
  — Hannah Stulberg [16:57]

• “I don’t view the team OS as something to help everyone become a better PM…I really view it as a way for everyone on the team to scale themselves…”
  — Hannah Stulberg [16:57]

• “I have spent now like 1500 hours in Claude and I am still iterating on my setup and improving it literally every single day.”
  — Hannah Stulberg [00:00, 63:56]

• “Claude code is the most misleading name in AI…It’s not just for coding…most of my time is not spent coding. It’s spent writing docs or doing analysis or building prototypes…”
  — Hannah Stulberg [67:05]

Important Timestamps

• 02:19 – Shift in PM/team structure; Team OS concept
• 03:27–05:50 – Detailed walkthrough of Team OS repo structure
• 05:50–09:50 – Context management in LLMs explained
• 13:15–14:58 – Importance of structured summaries and skill files
• 16:57–23:10 – Analytics folder & empowering cross-functional ownership
• 23:37–24:52 – Eng/bug investigation & team-owned repo principles
• 27:17–31:27 – Pull requests, team collaboration, GitHub basics for non-technical contributors
• 34:00–41:52 – Plan mode, planning vs. prompting, setting up effective AI processes
• 45:00–54:56 – Deep dive into planning, verification, advanced orchestrations
• 52:57 – Using Claude as a thinking partner
• 63:56 – Biggest mistake: giving up too soon
• 67:05 – Claude Code—it’s not just for “code”

Final Takeaways

• Team OS democratizes context and multiplies leverage across functions (not just for PMs/engineers).
• Advanced Claude use means prioritizing context management, repeatable structures (skills), and thoughtful planning.
• Be proactive: document plans, invite AI to push your thinking, review and iterate, and “always be learning.”
• Full-team participation is possible (and essential); beginners are welcome, and everyone can upskill quickly.
• Don’t get discouraged—continuous learning and rapid iteration are key to fully realizing the value of coding agents like Claude.

Where to Find Guest

• Hannah Stulberg’s Substack: hannahstulberg.substack.com (“In The Weeds”)

This summary captures the technical depth, actionable frameworks, and collaborative mindset that define Hannah’s approach, making it an invaluable primer for any PM or product team exploring Claude Code, ChatGPT, or similar AI-powered workflows.