The Growth Podcast

Episode: How to Turn Claude Code into an Operating System with Carl Vellotti
Host: Aakash Gupta
Guest: Carl Vellotti
Date: March 30, 2026

Episode Overview

In this masterclass, Aakash Gupta and Claude code expert Carl Vellotti dive deep into transforming Claude code from a “super-powered chatbot” into a true operating system for advanced AI work. Building on two previous, widely viewed episodes (beginner and advanced), this conversation focuses on context management, creating and using skills, deploying sub agents, managing trust and reproducibility in outputs, and most importantly, architecting Claude code into a cohesive, personal OS for product managers (“from 80 to 95 out of 100 on Claude code usage”).
Emphasis is on practical, demystifying explanations with step-by-step breakdowns, examples, and new best practices.

Key Discussion Points

1. Does Claude Code Still Matter?

• [02:29] Carl: Despite new tools like Anthropic's Cowork or OpenClaw, Claude code remains the “most powerful” and flexible tool, giving users maximal control, especially important for PMs.
  • Quote: “If you want the most power just to be able to do things and do work, cloud code is still...the number one tool.” — Carl [02:29]
• Cowork and OpenClaw are built on top of Claude code; they add convenience but also constraint power.
• Cowork: Great for managing files, good UI, but ultimately “constrained.”
• OpenClaw: Best for automation and monitoring; for “driving” and high agency, stay in Claude code itself.

2. Four Major Friction Areas for PMs (And Solutions)

• [04:17] Carl: Episode transitions from “advanced” to “mastery”, targeting:

  1. Context Management: Strategies to avoid filling up Claude’s context window, minimizing auto-compaction delays, and keeping quality high over long sessions.
  2. Shoring Up Weaknesses with Skills: Enhancing Claude with purpose-built skills for research, UI design, slide creation, etc.
  3. Building Trust/Traceability: Making outputs auditable and reproducible, especially for high-accountability documents and data.
  4. Building a Cohesive Operating System: Architecting workflow and files so everything fits together and isn’t scattered.
  • Quote: “There’s another level deeper that you can go to solve the biggest problems you might have with cloud code.” — Carl [04:17]

3. Practical Context Management

a. The Status Line Trick

• [06:26] Carl: Claude’s UI is surprisingly customizable; using /statusline, you can create a live “context used” indicator (green / orange / red).
• [08:55] Carl: Hitting context limits auto-triggers compaction—which can be painfully slow and breaks flow (e.g., waiting 2-3 minutes).
  • Quote: “If you have a bigger project...it’s easy for this to get to a hundred percent with just like five messages, and then you’re waiting...” — Carl [08:55]

b. The True Golden Rule: Context Engineering

• [09:54] Carl: "It’s not about prompt engineering anymore; it’s about context engineering."
  • Principle: Only provide Claude code the information it actively needs—never more. Minimize “context rot” for higher output quality.

4. Sub Agents for Clean Context

a. How Sub Agents Work

• [12:05] Carl: Sub agents act like clones of Claude, offloading long-running or research-heavy tasks into parallel sessions. The main session stays lean, only receiving summaries rather than all the intermediate tokens.
  • Quote: “Instead of doing that in its main session, it has spun up basically a clone of itself that is now doing all that work.” — Carl [12:05]
• Example: Researching web topics. Without subagents, main session context balloons; with subagents, nearly no increase.
  • Before: 16% context used → After sub-agent research: 16.5% (vs. ~25% with main thread).

b. Tactics and Skills

• You can instruct Claude to use a sub agent directly in your prompt, or build a reusable skill for this (“spin up” or “Context Guard”).
• [17:48] Carl: Create skills using natural language—easier and safer than downloading random marketplace skills.
  • Security Note: Only install skills from trusted people or author them yourself ([21:14]).

c. Efficiency Tips

• Escape key, double-tap [18:53]: Quickly roll back (and reclaim context) if a misfire occurs.
• Background agents [22:55]: Use Ctrl-B to run subagents in background, allowing main chat flow to continue.

5. The Magic of “Ask User Questions” Tool

• [24:11] Carl: Claude code’s unique “Ask User Questions” UI allows it to present a custom form of clarification questions in the chat, improving requirements-gathering and drastically increasing output relevance.
  • Memorable Story: One user on Twitter got 67 clarifying questions in a session!
  • Quote: “If you really make it strong...‘please ask me as many questions as you possibly can,’ it will just keep asking you...” — Carl [26:57]
• Use for feature specs, design clarifications, or requirements gathering.

6. When and How to Build Your Own Skills

a. General Strategy

• Make a skill whenever you’re repeating a workflow or need to shore up a Claude weakness.
  • E.g., Front-end design, web research, slide creation.
• [27:35]: “If you think cloud code is really weak, then you might be able to just come up with...a prompt or skill that gives it the tools...to do much better work.”

b. Examples & Showcases

Front-end Design Skill

• [29:10-30:50]: Default AI-generated UIs are soulless. Skill is just a powerful, well-crafted prompt—no code—providing direction and good aesthetic practices to Claude.

Web Research Skill

• [33:35]: Wrapping CLIs and APIs (e.g., Tavily, Firecrawl) to provide more trustworthy search.
  • [34:43] “CLIs are better than MCPs ([37:33] per Karpathy: CLI > API > MCP).”
  • [38:23] “If you take anything away from this episode, stop using MCPs, start using CLIs.”

Slides/Visuals Creation

• [39:08-41:52]: Advanced skills can include executable code (e.g., Puppeteer for auto-checking HTML overflow in slides). Having Claude review its own outputs (“builder-validator pattern”) improves quality.

c. Skill Invocation Best Practices

• [43:35]: Automatic skill invocation via “hooks” (on user prompt submit) is possible but finicky—a script can scan user input for keywords and invoke relevant skills.

7. Trust, Traceability, and “Proof of Work” in AI Outputs

a. The “Jupyter Notebook” Approach

• [46:45] Carl: PMs need outputs they can trust, especially on data. Jupyter Notebooks provide “proof-of-work”—showing exact code and intermediate steps, viewable right in the IDE (Cursor, VS Code).
• Use AI to:
  • Visualize/data-explore CSVs and large datasets instantly ([50:12]).
  • Produce charts, distributions, correlation heatmaps ([51:33], [53:11]).
  • Generate complex analytics (“correlation heatmap...what patterns jump out?”)
• Role-based subagents: Have, e.g., an analytics manager agent that crafts good prompts for the “analyst” agent ([53:11]).

8. Architecting Claude Code as a Personal Operating System

a. Folder Structure & Knowledge Organization

• [55:18] Carl: Key folders—Knowledge (static, rarely changing), Meetings, People (custom dossiers), Projects (temporary, per-task), Data (analysis/outputs), Tasks (current and backlog), Tools (scripts, CLIs), and the ever-important Cloud MD file.
  • Quote: “Having just a knowledge folder with some of the key things you want to be able to say, ‘Hey Claude, I have a meeting with David Chen...’”

b. Workflow

• Projects folder as “workspace”—all transcripts, context, research, etc. for an initiative live together ([58:16]).
• Pull artifacts automatically from Notion, Linear, GitHub, etc. ([60:00]).
• Use skills for recurring processes (e.g., “standup” pulls data from code, calendar, tasks, etc.)

c. The Power of Cloud MD

• [62:04]: Your Claude MD file is “always in context”—automatically referenced in every session/message.
• Make it a living document: update with company info, goals, workflow pointers.
• [64:54] “There’s alpha in iterating on your Cloud MD file every week, every month, every time you run into an issue.”

Notable Quotes & Memorable Moments

• “It’s not about prompt engineering anymore, it’s about context engineering.” – Carl Vellotti [00:12, restated at 09:54]
• “Sub agents...it has spun up basically a clone of itself that is now doing all that work.” – Carl Vellotti [12:05]
• “The Ask User Questions tool is so awesome...it will dynamically come up with a list of questions to ask us, but it will be in like a new custom UI within Claude code.” – Carl Vellotti [24:20]
• “If you take anything away from this episode, stop using MCPs, start using CLIs.” – Carl Vellotti [38:23]
• “There’s another level deeper that you can go to solve the biggest problems that you might have with cloud code.” – Carl Vellotti [04:17]
• “The Cloud MD will always be there. And what’s cool is...it’s there in the background for every message.” – Carl Vellotti [63:14]
• “If you spend the hour to add in this really important context and then structure it in this way, [the] outputs you get will look nothing like the output somebody else using Claude code is building.” – Akash [56:44]

Timestamps for Key Segments

| Timestamp | Key Segment | |----------------|----------------------------------------------------| | 00:12 | Prompt vs. context engineering | | 02:29 | Why Claude code isn't obsolete | | 04:17 | The four main friction/solution areas | | 06:26 | Customizing UI: status line for context | | 08:55 | Why context management matters | | 12:05 | Sub agents for context-efficient work | | 15:23 | Building and invoking sub agent skills | | 17:48 - 21:14 | Building and safely sourcing skills | | 22:55 | Running subagents in the background | | 24:11 | "Ask User Questions" tool demo | | 27:35 | When/why to create skills | | 29:10 | Front end design skill vs. default AI design | | 33:35 | Web research skill and moving beyond MCPs | | 39:08 | Make slides: Adding code to skills | | 43:35 | Auto-invoking skills with hooks | | 46:45 | Ensuring trust: proof of work with Jupyter | | 50:12 | Data visualization / exploring CSVs in Claude | | 53:11 | Role-based subagents for analytics workflows | | 55:18 | How to structure a Claude code OS | | 62:04 | Cloud MD file and recommendations |

Actionable Takeaways

• Monitor context actively and setup UI feedback to avoid slow compaction and context rot.
• Leverage sub agents for any research-heavy or multi-step workflow to preserve core session clarity.
• Build skills whenever you notice repetition or a gap in Claude’s performance, and prefer CLIs over context-hungry MCPs.
• Use the Ask User Questions tool for richer, less assumption-ridden outputs.
• Ensure trust and traceability for anything analytics- or data-driven via Jupyter Notebooks; “proof of work” is key.
• Systematize your Claude code workspace: have a clear OS structure (Knowledge, Projects, People, Data, Tools, Tasks, Claude MD).
• Iterate on your Cloud MD regularly to tune your OS and maximize relevant productivity.

Closing Resources

• Carl’s free course for PMs: cc4pms.com
• General user course: ccforeveryone.com
• Full Stack PM newsletter: Link
• Carl Vellotti: Instagram, LinkedIn, Twitter

For recurring Claude code breakthroughs, subscribe and engage!

(Summary skips ad sections and focuses on high-density insights and workflows. Quotes and explanations use the original language and technical tone of Akash and Carl.)