By playing, you agree to uListen's Terms and Privacy Policy and YouTube's Terms of Service.

How I use Claude Code (Meta L7 Senior Staff Engineer Tips)

This is my 50 Claude Code tips from 6 months of daily use personally and at Meta as a Staff Software Engineer. I've been coding with Claude Code basically 12 hours a day really trying to understand what makes Claude Code tik.

John Kimhost

Feb 7, 202646mWatch on YouTube

Summaries, chapters, transcripts, and FAQs on this page are made by uListen, not YouTube.

CHAPTERS

Jump to publisher timestamps

Chapter summaries

Why he lives in Claude Code: 50 tips, daily pairing, and code review bottlenecks
John Kim sets the context for why he’s sharing these tips: he’s been using Claude Code daily for months and spends long stretches pair-programming with it. He frames the video as a practical guide covering foundations first (setup, commands, rules) before moving into advanced workflows.
- •He uses Claude Code heavily (long daily sessions) and still reviews every line of generated code
- •He considers code review the current bottleneck, not writing code
- •The video is structured as 50 tips that he wished he knew when starting
- •He will cover setup, keyboard shortcuts, essential commands, CLAUDE.md rules, and advanced workflows
Project setup fundamentals: start Claude from the repo root and run /init early
He demonstrates launching Claude Code from a project’s root directory to ensure correct context loading. Then he shows using /init so Claude analyzes the codebase and generates an initial CLAUDE.md inside the project’s .claude directory.
- •Running from the root directory affects what gets zipped into initial context and token usage
- •Opening Claude can consume tokens immediately because it prepares project context
- •/init analyzes the codebase architecture and generates a starter CLAUDE.md
- •Claude presents a summary of what it detected and asks to commit the generated file
How CLAUDE.md and memory work: hierarchy, scope, and keeping rules lean
John explains that CLAUDE.md rules operate hierarchically across project (“checked-in”) and user (“global”) memory. He emphasizes keeping the file concise to avoid token bloat and reduce the chance the model gets distracted by irrelevant rules.
- •Using /memory reveals active rule sources (project vs user/global)
- •Rules are hierarchical and Claude operates based on the currently loaded memories
- •He prefers CLAUDE.md to stay relatively small to control token usage
- •Too much context bloat can reduce model reliability and adherence to intent
A practical CLAUDE.md template: architecture + domain context + validation loop
Using an iOS project example, he shows the kinds of information he puts into CLAUDE.md: what the project is, the domain and patterns, and especially how to build/validate changes. He argues that a clear validation loop helps the model iterate until the work actually compiles and works.
- •Include project purpose/requirements plus high-level technical architecture
- •Add domain context like frameworks, patterns, and relevant file structure
- •Document build steps and validation commands/workflows
- •A strong validation loop helps the model self-correct when outputs don’t work
- •He highlights validation as central to effective agentic coding workflows
Keyboard shortcuts that change speed: Plan Mode vs edits, interrupting, rewind, and screenshots
John walks through the shortcuts he uses constantly to manage flow: toggling Plan Mode, interrupting with Escape, clearing input, rewinding context, and dragging screenshots in. He frames these as core “context management” tools when working all day in the terminal UI.
- •Shift+Tab toggles between modes; he starts most features in Plan Mode to verify assumptions
- •Escape interrupts generation; he encourages course-correcting early rather than waiting
- •Double Escape clears the input buffer; on empty input it opens rewind/restore options
- •Dragging screenshots into Claude is a fast workflow, especially for UI work
- •He notes screenshots work best when you add contextual instructions alongside them
Essential slash commands: /clear, /context, compaction, /model, /resume, /mcp, and /help
He reviews the core slash commands he considers most valuable for everyday use, with emphasis on inspecting and controlling context. He also explains how to recover sessions, switch models, and discover other commands through /help.
- •/clear resets conversation context without opening a new instance
- •/context shows what’s in context and token usage so you can audit bloat sources
- •He usually lets auto-compaction summarize long sessions, using manual compaction rarely
- •/model (models) lets you switch depending on cost/speed preferences; he often defaults to Opus
- •/resume restores a lost session’s context
- •/mcp lists installed MCPs; /help enumerates commands and descriptions
Using Git as a safety net instead of relying on rewinds
John describes using Git workflows alongside Claude Code to manage risk and checkpoints. While Claude has a rewind/restore capability, he finds Git clearer and prefers it as the primary safety mechanism.
- •Claude can help with Git-related work (including summaries/test plans) when paired with templates
- •He treats Git as the main safety net for changes
- •He mentions Claude’s rewind feature but finds it confusing compared to Git
- •He uses rewind as a last resort when he lacks a Git checkpoint
CLAUDE.md deep dive: priority order, “never/always” rules, and updating via Claude (not manually)
He explains how he thinks about rule priority and specificity inside CLAUDE.md, including the idea that instructions are read top-to-bottom. He recommends fixing recurring mistakes by updating rules, and prefers asking Claude to make those updates rather than editing rule files by hand.
- •He believes CLAUDE.md should be ordered from most important to least important
- •Rules should capture strong constraints (never do X, always do Y) and useful examples
- •When the model fails on unique internal patterns, fix once and encode it into rules
- •He recommends asking Claude to update the rules instead of manual edits
- •He demonstrates the workflow of prompting Claude to update the rule file
Workflow triggers and team sharing: keywords, committing rules, and when to use dangerously-skip
John shows how keywords in rules can trigger repeatable behaviors (like build flows) and discusses committing CLAUDE.md to the codebase to help teammates—while keeping the bar high to avoid bloating everyone’s context. He also covers the risks of running with permissions skipped and using /permissions to keep guardrails.
- •He uses trigger keywords in rules to invoke workflows like building via an MCP
- •He describes committing CLAUDE.md (“compound engineering”) to improve teammate experience, with caution about file size and relevance
- •He suggests evaluating whether shared rules help, often via trying them for a period and gathering feedback
- •He demonstrates running with --dangerously-skip permissions to avoid constant approvals
- •He warns to use skip only in throwaway environments and keep protections via /permissions for dangerous actions
Daily workflow philosophy: plan first, challenge outputs, and keep context fresh
He demonstrates how he starts work by iterating in Plan Mode and treating Claude like an engineering partner rather than accepting first outputs. He repeatedly emphasizes that “fresh, condensed context” beats long, messy sessions and that up-front planning makes later execution easier.
- •He begins new features in Plan Mode and spends time validating direction before edits
- •He actively questions and challenges Claude’s suggestions instead of accepting first drafts
- •He believes once the context and execution spec are good, code generation becomes the easy part
- •He argues bloated context from repeated trial-and-error can confuse the model
- •He returns to the theme that context engineering is central to effective use
Persisting and lazy-loading context: a “second brain” for project to-dos and switching
John describes saving useful session output into a local store and later reloading it to bootstrap new sessions. He explains a lazy-loading approach where he only pulls in project to-dos/context when needed, helping him switch projects without carrying large external tracking systems.
- •He prompts Claude to save completed work into local project notes/context
- •He can later request Claude to load that stored context into a new session
- •He keeps project to-dos inside this local index and lazy-loads them on demand
- •This supports quick context switching without always relying on external boards/tools
- •He notes this approach fits especially well for personal projects, but could be adapted via MCPs for other systems
Verification loops beyond builds: debugging automation, browser-driven validation, and model choice
He expands validation into broader automation: adding logs, running apps, controlling emulators, and analyzing outputs—then ties it back to model choice for difficult tasks. He reiterates that strong validation is the lever for better first-pass results and highlights using stronger models when feasible.
- •He suggests verification loops like adding debug logs, running the app, and reading logs to debug issues
- •He mentions performance-oriented validation concepts like running traces and analyzing timing/jank via tools
- •For web validation, he describes navigation/testing approaches (end-to-end flows) and later connects to browser control
- •He reiterates that validation loops are key to more automated, higher-quality iterations
- •He encourages considering stronger models (like Opus) for complex work when possible
Power-user composability: skills, commands, MCP discovery/installation, subagents, and avoiding overload
John explains Claude Code’s “primitives” and how they compose: skills and commands as saved workflows, MCPs as integrations, and subagents as isolated contexts. He argues against instruction overload and cautions that subagents often get misused when the main session needs the full context to do good work.
- •Skills are saved recurring workflows; he demonstrates creating one from a multi-step process
- •Commands now overlap with skills, enabling quick invocation via a slash command
- •He recommends not manually creating/maintaining skills/commands—ask Claude to manage them
- •He suggests asking Claude to find and install MCPs, while staying mindful of outdated info and token bloat
- •Subagents help parallelize work and protect the main context, but only return outputs (not full reasoning/context)
- •He discourages “instruction overload” and argues for bringing work to a focused context instead of scattering it
Advanced parallel development: multiple instances, iTerm pane juggling, notifications, and Git worktrees
He shows how running multiple Claude Code instances enables parallel work across features and even projects, and how iTerm helps manage it quickly from the keyboard. He adds optional productivity layers like notifications, and introduces Git worktrees to avoid local editing conflicts when many instances touch the same repo.
- •He runs multiple Claude instances simultaneously and switches between them to keep momentum
- •He uses iTerm features (splits/tabs and keyboard navigation) to juggle sessions quickly
- •He sometimes renames tabs/sessions (e.g., local vs remote SSH) for organization
- •He describes enabling notifications so he can work elsewhere while a session runs
- •Git worktrees allow parallel edits in the same project without conflicts between instances
- •He frames this as a major reason he moved his workflow into the terminal
/chrome and hooks: browser control for debugging plus automation guardrails, then a context-first wrap-up
John demos /chrome to let Claude navigate websites via screenshots and actions when APIs aren’t available, and positions it as another composable validation tool. He then introduces hooks for pre/post execution automation and safety checks, encourages exploring shared plugins, and closes by reiterating that keeping context minimal and relevant is the core principle.
- •/chrome opens browser control so Claude can navigate pages, click, type, and extract information
- •He uses browser control when API access isn’t available, and notes it can be composed into larger workflows
- •He introduces hooks that run before/after tool actions (including failure cases) and recommends asking Claude to set them up
- •He cites examples like auto-formatting/linting and blocking destructive actions as hook use cases
- •He describes plugins as combinations of these primitives (skills/MCPs/subagents/scripts) shared by others
- •He closes with the message that “context is king”: keep it fresh, relevant, and no more than needed

Publisher timestamps

Get more out of YouTube videos.

Read along on your phone, search it beside the video, or ask your favorite AI app what was said.