Aakash GuptaI should be charging $999 for this Claude Code Tutorial
CHAPTERS
Claude Code’s breakout growth and what you’ll learn
Aakash introduces Claude Code’s rapid adoption and frames the episode as a beginner-to-hero tutorial. Carl Vellotti joins to show practical workflows, especially for product managers, and why the terminal-based interface changes how you work with LLMs.
- •Claude Code reportedly hit massive ARR growth quickly with a tiny team
- •Positioning: replacing/competing with tools like Cursor/Lovable/Replit/Bolt
- •Episode goal: build a “copilot” workflow for productivity
- •Guest context: Carl runs a major PM Instagram account and builds agents
- •High-level promise: beyond chat—workflows, files, and automation
Why PMs should care: escaping chatbot limitations with workflows
Carl explains why Claude Code matters even if you’re non-technical: it moves you from a chat box into a flexible file-system-driven workflow. The key theme is “context engineering”—feeding the model structured, reusable context so outputs are more useful and repeatable.
- •Chat interfaces make it hard to reuse prompts, files, and context over time
- •Claude Code operates directly in folders/files for fast context loading
- •Enables new workflows (research, writing, synthesis) not tied to an IDE
- •Flexibility: adapt to your existing PM workflow rather than starting over
- •Core through-line: better context → better results
Claude Code vs Copilot/Cursor/other CLIs: where it wins
The conversation compares Claude Code to IDE-first assistants and other terminal/CLI agents (Gemini CLI, OpenAI Codex). Carl argues Claude Code is polished, strong at tool use and agent behavior, and especially strong for writing-heavy tasks PMs do daily.
- •IDE tools skew toward coding; Claude Code supports research + docs more naturally
- •Claude is positioned as a stronger writing model than many alternatives
- •Terminal as a “new interface”: minimal UI, maximum flexibility
- •Competitive landscape: Gemini CLI/Codex exist, but Claude Code feels most polished
- •Practical pricing talk: Pro vs Max; ROI framing for PMs
Installation and first launch: one-command setup + basic commands
Carl walks through installing Claude Code from Anthropic’s quick start and launching it in the terminal. He demystifies the terminal, shows the basic chat-like interaction, and introduces the “clear” workflow to manage context.
- •Native install from official guide; run a single command
- •Launch by typing `claude` in terminal
- •Interaction is natural language, not “coding” by default
- •Useful command: `clear` to reset context and avoid drift
- •Concept: work inside a specific project folder, not your whole machine
Working in a project folder: file-based Q&A on customer interviews
Using a prepared demo repository (a fictional company wiki), Carl shows how Claude Code can automatically inspect directories and read files. He asks for counts and summaries of interview transcripts and compares insights across industries to demonstrate fast synthesis.
- •Open terminal in a specific folder to scope Claude’s context
- •Ask structural questions: “How many interviews?” and get grounded answers
- •Summarize a specific interview and compare interviews across segments
- •Claude reads files directly—no copy/paste into chat
- •PM benefit: instant synthesis of qualitative data with minimal setup
Web search + token visibility + image input inside the terminal
Carl demonstrates Claude Code’s web search and discusses how token counting makes usage/cost more tangible than typical chat apps. He also shows that despite being terminal-first, you can drag in images for analysis and feedback (useful for debugging or reviewing assets).
- •Claude Code can search the web without Perplexity-style add-ons
- •Token counter provides transparency into “how much context is used”
- •Drag-and-drop images into the terminal for analysis/feedback
- •Debugging and content review become faster with multimodal input
- •Prompting matters: web search results improve with tighter instructions
Running code + using GitHub repos: transcript extraction demo
Claude Code is shown running real code: Carl provides a GitHub repo for a YouTube transcript API and asks Claude to fetch a transcript and save it to a markdown file. The key moment is Claude generating a task checklist and executing step-by-step without manual engineering work.
- •Claude can install/use code from GitHub repos with minimal hand-holding
- •Creates a self-checking to-do plan (install, script, run, output file)
- •Outputs artifacts directly into the repo (e.g., `youtube-transcript.md`)
- •Non-technical users can still leverage repos via natural language
- •Demonstrates “tool use” + file write as a leap beyond chatbots
Using Claude Code inside Cursor: viewing files and a cost-effective setup
Carl shifts into an IDE (Cursor) to visualize and edit generated files while continuing to run Claude Code in the integrated terminal. He explains a hybrid approach: use Claude Pro (Sonnet) for research/writing and Cursor for heavier coding models when needed.
- •Run Claude Code in any IDE terminal; Cursor used for convenience/preview
- •Markdown preview makes outputs readable and editable
- •Hybrid stack idea: Claude Pro for docs/research; Cursor for advanced coding models
- •Explains why Max/Opus may matter more for coding-heavy sessions
- •Workflow advantage: keep artifacts (notes, docs, scripts) in the same repo
Project initialization: `init` and the persistent CLAUDE file memory
Carl introduces `init`, which scans the repo and generates/updates a `CLAUDE` file describing structure and instructions. This file acts like persistent project memory: rules, style guides, and guardrails that Claude references every session, reducing repeated context setup.
- •`init` helps Claude understand the project layout and key components
- •`CLAUDE` file persists across sessions and is always referenced
- •Add guardrails (e.g., don’t commit without asking) and formatting rules
- •Quick add-to-memory shorthand using `#`-style notes
- •Can use subfolder-specific CLAUDE files for localized rules
PRDs with context engineering: combining business info, styles, and examples
Carl demonstrates a “super prompt” that pulls business context, writing-style guides, and example PRDs from folders, plus web research (e.g., GPT real-time). Claude generates a structured PRD and writes it to a file, showing how reusable context assets dramatically simplify PM writing.
- •Store business context and writing styles as reusable files
- •Provide example PRDs to anchor format and quality
- •Claude researches missing domain info via web search
- •Generates a full PRD draft with technical constraints and references
- •Discussion of context overload: clear sessions + upfront context beats long chats
Reusable slash commands: consistent meeting notes and internal messaging
Carl shows custom slash commands (saved prompts) to standardize outputs like meeting notes. He then combines meeting transcript context + writing tone files to draft a Slack follow-up message, illustrating how teams can avoid “generic AI voice” and keep outputs in a personal/company style.
- •Slash commands = stored prompts you can trigger repeatedly
- •Standardize meeting-note structure (action items, risks, metrics, next steps)
- •Automatically edit files to append summaries—impossible in basic chat UIs
- •Combine task context + tone/style files to produce human-sounding messages
- •Practical benefit: consistent outputs without maintaining a separate prompt library
Plan Mode for complex tasks: prompt/model testing harness
Carl introduces Plan Mode (Shift+Tab) to prevent premature file edits while designing an approach. He builds a workflow to generate multiple summarization prompts and run them across multiple LLM APIs, then iterates on the plan to control file structure before executing.
- •Plan Mode: read/search allowed, file edits blocked until you approve
- •Use it to avoid “manifestation” and requirement drift
- •Creates a checklist plan you can critique and modify
- •Example: create 3 prompt variants and test across Gemini/ChatGPT/Groq via API keys
- •Outputs consolidated markdown files for easy side-by-side comparisons
Agents and sub-agents: parallel work + role-based review personas
Carl demonstrates parallelization by spinning up multiple sub-agents to analyze separate interview files simultaneously. He then shows role-based agents (designer/engineer/executive) to review a PRD from different perspectives, and pulls new agents from online registries to expand capabilities fast.
- •Parallel sub-agents accelerate multi-file analysis dramatically
- •Role-based agents provide distinct viewpoints (exec vs eng vs design)
- •Agents can be defined as simple text configs (personality, constraints, output format)
- •Import agent templates from registries (e.g., legal advisor) in seconds
- •Tradeoff: more agents/parallelism can consume many tokens
MCPs and tool extensions: Reddit mining + PM-focused opportunities
The episode explains how MCPs extend Claude Code with specialized tools (e.g., Reddit access), enabling workflows that normal web search or scraping can’t reliably do. Carl highlights how PMs can use MCPs for continuous insight gathering (communities, competitors) and points out a gap: most shared agents/tools are still engineering-centric.
- •MCPs are LLM-friendly “tool connectors” akin to specialized APIs
- •Demo: Reddit MCP to extract pain points from a thread on automation
- •Potential automations: daily/weekly community summaries, competitor monitoring
- •Registries exist for MCPs (Google Drive, etc.) to pull company context faster
- •Opportunity: build more non-coding agents/tools tailored to PM workflows
Where Claude Code is best + prototyping demo + avoiding ‘manifestation hell’
Carl summarizes Claude Code’s strengths for PMs (research, writing, synthesis, lightweight prototyping) and demonstrates building a simple workflow-builder UI from a spec. They discuss evals, safe use with engineering teams, and best practices like Plan Mode and staying in the loop to avoid unproductive loops.
- •Best PM use cases: research, docs (PRDs/notes), synthesis, simple prototypes
- •Prototype demo: node canvas with add/connect behavior; slower than dedicated tools but flexible
- •Evals: Claude Code can help structure prompt tests and integrate evaluation workflows
- •Safety/realism: prototypes aren’t production-ready; use test environments + engineer review
- •Avoid loops: Plan Mode, clearer requirements upfront, active supervision
Claude Code adoption, PM agent strategy, and Carl’s Instagram ‘agent’ stack
They reflect on why Claude Code grew fast (coding bet + strong writing + intent understanding) and how PMs should choose between tactical agents (Claude Code) vs recurring automations (n8n/Lindy). The conversation then pivots to Carl’s Instagram growth and his internal “Meme Mage” tool that uses LLMs/templates/personas to generate meme captions.
- •Growth drivers: strong coding performance + best-in-class writing + intent understanding
- •PM agent guidance: build agents for repetitive, text-based work you dislike
- •Single vs multi-agent: more complexity increases failure risk; keep humans in loop
- •Instagram growth: consistency, shareability (PM–engineering tropes), Reels advantage
- •Meme Mage: templates + personas + video understanding to generate caption candidates
Outro: Carl’s Fullstack PM newsletter and next steps
Carl shares his transition from PM roles to building a community/newsletter for “builder PMs,” focusing on modern AI tooling. Aakash closes with where to find links/docs and a call to subscribe/follow/review.
- •Carl left his job to focus on content/community (The Fullstack PM)
- •Motivation: tooling/model progress made “building” newly feasible for PMs
- •Monetization: early-stage, focused on growth and community first
- •Viewer CTA: newsletter post for documents/tools/frameworks
- •Subscribe/follow/review to support the show
