CHAPTERS
- 0:00 – 1:41
Why Claude Code is exploding—and why most people still use it like a chatbot
Aakash opens with Claude Code’s massive growth and frames the core problem: people treat it like a prompt box instead of a configurable work environment. Carl previews an “operating system” approach built from skills, sub-agents, and better context management.
- •Claude Code’s rapid revenue ramp and adoption
- •Shift from prompt engineering to context engineering
- •Teaser: OS-like setup with skills, visualization, and sub-agents
- •Why context limits and trust matter for real work
- 1:41 – 3:48
Does Claude Code still matter vs Cowork and OpenClaw? (Power vs UI vs autonomy)
Carl compares Claude Code with newer wrappers and agentic runners. His thesis: Cowork is a constrained UI built on top of Claude Code, and OpenClaw is great for autonomous monitoring, but Claude Code remains best when you need maximum power and to stay in the driver’s seat.
- •Cowork as a UI layer that constrains power/features
- •OpenClaw for always-on autonomy, monitoring, and background tasks
- •Claude Code for in-the-loop, high-control work (esp. PM workflows)
- •Positioning: Claude Code as the foundational layer others build on
- 3:48 – 6:26
The four friction areas this episode solves: context, skills, trust, and “OS” structure
They outline the mastery-level agenda: reduce context-window churn, patch weaknesses using skills, make outputs trustworthy (especially data), and organize everything into a cohesive operating system so work doesn’t sprawl.
- •Strategies to slow context fill-up and reduce compactions
- •Using skills to compensate for weak areas (research, design, slides)
- •Building trust via reproducible, transparent workflows
- •Creating a file/folder OS to keep Claude Code work coherent
- 6:26 – 8:44
Make context visible: customizing Claude Code’s status line UI
Carl demonstrates customizing the status line so Claude Code shows model, directory, and a color-coded context usage meter. This gives immediate feedback on what kinds of actions consume context and helps you manage the session proactively.
- •/status line customization to display context usage
- •Color-coded thresholds (green/orange/red) for quick scanning
- •Lightweight UI changes that improve workflow awareness
- •Setup shown inside Cursor while using Claude Code CLI
- 8:44 – 12:06
Why context management matters: compaction pain + “context rot” quality decay
They explain why auto-compaction isn’t “free”: tool calls, web reads, and multi-file work can hit 100% quickly and interrupt flow with long compactions. Beyond latency, long threads degrade answer quality, so minimizing unnecessary context improves outputs.
- •Tool calls and web fetches rapidly consume tokens
- •Compaction interrupts flow (minutes of waiting)
- •Context engineering: include only what’s needed, maximize signal
- •Quality degradation over long conversations (“context rot”)
- 12:06 – 19:39
Sub-agents for context preservation: /context inspection, delegation, background runs, and rollback
Carl shows how to inspect what’s consuming context and emphasizes delegating heavy work (like research) to sub-agents so the main thread only receives summaries. He also demonstrates running agents in the background and using Esc rollback to undo mistakes and reclaim context.
- •/context reveals token usage by system prompt, tools, MCPs, etc.
- •Delegating research to sub-agents keeps main session lean
- •Ctrl+B runs a sub-agent in the background while you continue
- •Esc (and double-Esc) to stop/rollback and remove unwanted context
- 19:39 – 23:47
Creating a new skill live: “Context Guard” + skill safety and reliable invocation
After noticing an existing skill is wrong, they delete it and create a new skill in natural language to decide when to use sub-agents. They also warn against untrusted skill marketplaces and discuss best practices for reliably triggering skills with explicit slash commands.
- •Live skill creation: replacing a flawed skill with a better one
- •Context Guard: evaluate main-session vs sub-agent delegation
- •Security warning: malware/prompt injection in random skills
- •Practical tip: invoke via slash command / explicit phrasing for reliability
- 23:47 – 27:35
The ask-user-questions tool: turning assumptions into structured clarification
Carl introduces his favorite feature: a built-in UI that prompts the user with targeted questions. This reduces hidden assumptions, improves spec quality, and creates a collaborative workflow where Claude gathers missing context before generating output.
- •Ask-user-questions generates a custom in-CLI UI for responses
- •Great for requirement gathering and ambiguity reduction
- •Can scale to many questions for vague prompts
- •Transforms workflow from “guessing” to “interviewing”
- 27:35 – 33:35
Skills that are “just prompts” can still be powerful: the official front-end design skill
They show that some of the most valuable skills don’t add new tools—just high-quality instructions that improve taste and guardrails. Carl contrasts an obviously “AI-looking” landing page with a cleaner result produced using Anthropic’s front-end design skill prompt.
- •/plugins shows official marketplace options (safer baseline)
- •Front-end design skill improves aesthetic decisions and structure
- •Demonstration: generic gradient UI vs more polished redesign
- •Lesson: excellent prompts packaged as skills can be huge unlocks
- 33:35 – 35:33
Tool-powered research skills with Tavily + Firecrawl (and why web search alone fails)
Carl explains why default web search is unreliable and how to fix research quality by giving Claude better tools. He highlights Tavily for higher-quality search results and Firecrawl for clean markdown extraction, then wraps them into a reusable web research skill.
- •Default Google-style search surfaces SEO/slop and weak sources
- •Tavily MCP for stronger, Perplexity-like search quality
- •Firecrawl for clean scraping/markdown extraction from URLs
- •Wrap tools into a skill to standardize research workflow
- 35:33 – 39:02
CLI vs MCP vs API: the hierarchy for power, reliability, and context efficiency
They argue MCPs can be costly in context overhead, while CLIs often provide a more reliable and agent-friendly interface (sometimes wrapping APIs). Examples include Google Workspace, GitHub CLI, and Vercel CLI—described as high-leverage for “vibe coding” and ops.
- •MCPs consume context even when idle (token overhead)
- •CLIs run locally and are easy for agents to operate
- •GitHub CLI and Vercel CLI called out as “mandatory” for builders
- •Practical heuristic: ask Claude if a CLI exists before using MCP
- 39:02 – 43:30
Making slides with Puppeteer: skills that can “see” and validate their own output
Carl shows a more advanced skill that includes a build process using Puppeteer to render and screenshot slides, then checks layout issues like overflow. The key idea is giving Claude a verification loop so you don’t manually iterate via screenshots and feedback.
- •Slides are hard for LLMs without visual feedback loops
- •Puppeteer renders HTML slides and enables screenshots/measurement
- •Automated overflow checks improve layout reliability
- •Builder/validator iteration (e.g., enforce 3 iterations before showing)
- 43:30 – 46:45
Auto-invoking skills with hooks: keyword detection on user prompt submit
They address finicky skill auto-invocation and show how hooks can inject automation into Claude Code’s lifecycle. Carl describes a user-prompt-submit hook that runs a fast script to match prompt keywords against skill triggers, then lets the LLM decide whether to apply the skill.
- •Built-in auto-invocation is unreliable without nudges
- •CLAUDE.md listing helps but costs context and is hard to maintain
- •Hooks run before/after lifecycle events (submit, response, compaction)
- •Fast script-based keyword match triggers skill consideration
- 46:45 – 54:59
Trustworthy data analysis with Jupyter notebooks: reproducible proof-of-work inside your IDE
Carl tackles the trust problem by having Claude produce Jupyter notebooks that show code, outputs, and charts—traceable and reviewable. They walk through loading a CSV, visualizing distributions, and generating a correlation heatmap to demonstrate transparent analysis.
- •Core trust issue: where numbers come from and how calculated
- •Jupyter notebooks render natively in Cursor/VS Code
- •Workflow: inspect data → chart distributions → deeper analyses
- •Artifacts provide deterministic, reviewable proof-of-work
- 54:59 – 1:04:54
Building a Claude Code operating system: folder structure, projects, tools, and a living CLAUDE.md
They explain how to prevent file sprawl by establishing an OS-like structure: Knowledge, Meetings, Projects, Data, Tasks, Tools, and a carefully maintained CLAUDE.md that stays in context. They also discuss compounding benefits—mixing skills and connections so Claude becomes the hub for cross-tool workflows.
- •Knowledge folder for relatively static reference (people, company context)
- •Projects folder as the unit of work; drag-drop to rehydrate context fast
- •Tools folder for scripts/capabilities that skills can call
- •CLAUDE.md as always-in-context “lens”; iterate it over time
- 1:04:54 – 1:06:48
Wrap-up: where to learn more + final calls to action
Carl shares where to find his courses and newsletter, including Claude Code-taught-in-Claude Code lessons. Aakash closes with subscription asks and a tools bundle promotion.
- •cc4pms.com and cc4everyone.com courses and how they work
- •The Full-Stack PM newsletter and socials
- •Encouragement to like/comment for future episodes
- •Final subscribe/follow CTAs and bundle mention
