A no-fluff synthesis of Anthropic's official best practices and Boris Cherny's personal Claude Code workflow, distilled into 15 concrete sections.
Posted
6 months ago
Duration
Format
Tutorial
educational
Views
15.2K
388 likes
57 · 43
Big Idea
The argument in one line.
The context window is the single binding constraint in agentic coding, and every Claude Code best practice -- from plan mode to CLAUDE.md to parallel sessions -- is ultimately a strategy for protecting and managing it.
Who This Is For
Read if. Skip if.
READ IF YOU ARE…
You use Claude Code daily and want to push beyond the basics into the habits the Claude Code team itself uses.
You have hit context-related degradation (Claude forgetting earlier instructions, making inconsistent edits) and want a systematic fix.
You are building a CLAUDE.md file and want a concrete include/exclude checklist straight from the official docs.
You want to understand when and how to use subagents, skills, and parallel sessions without reading the full documentation.
You are a solo builder or small team who wants compound productivity gains through slash commands and hooks.
SKIP IF…
You have never opened Claude Code -- the getting-started guide would serve you better first.
You are looking for new, unreleased Claude Code features -- this covers existing documented best practices, not announcements.
TL;DR
The full version, fast.
The context window fills fast and performance degrades as it fills -- that one constraint explains every best practice in this video. The recommended workflow is Explore (plan mode, read-only) then Plan (detailed spec, iterate with Claude) then Implement (auto-accept) then Commit. Verification is non-negotiable: give Claude tests, screenshots, or expected outputs so it can self-check. CLAUDE.md should be under 500 lines, team-maintained, and updated after every correction. Parallel sessions (3-5 git worktrees) let you run multiple tasks without context collision, and Boris throws away 10-20% of sessions without guilt -- the 80% that work more than compensate.
Free for members
Chat with this breakdown — free.
Sign in and you get 23 free chat messages on us — ask for the hook, quote a framework, find the exact transcript moment, generate a markdown action plan. Bring your own key when you want unlimited.
Hook: Anthropic published official best practices plus Boris Cherny shared his workflow thread
00:45 – 01:27
02 · The Boris Way
Host intro, video structure: Anthropic says / Boris says / you apply
01:27 – 03:15
03 · Context is king
Context window as the number one constraint; /context, 5-10 parallel sessions, git worktrees, /status line
03:15 – 04:52
04 · Always make a plan
Explore to Plan to Implement to Commit; Shift+Tab plan mode; Boris: plan first, then auto-accept
04:52 – 06:11
05 · Let Claude verify its work
Verification is highest leverage; test cases, visual verification, root cause fixing; Chrome extension
06:11 – 07:09
06 · Provide specific context
Before/after prompt examples: scope task, point to sources, reference patterns, describe symptoms
07:09 – 10:11
07 · Prompting techniques
Write specs, voice dictation, make Claude your reviewer; CLAUDE.md include/exclude table; Boris compound CLAUDE.md habit
10:11 – 11:28
08 · Skills
Domain knowledge vs workflow skills; auto-invoked vs slash-command; commit to git, reuse across projects
11:28 – 12:51
09 · Ensuring skill invocation
Vercel benchmark: 56% fail rate without explicit mention; compressed 8KB docs index achieves 100% pass
12:51 – 13:58
10 · Subagents
Subagents explore in own context window; Boris four named agents: code-simplifier, verify-app, build-validator, code-architect
13:58 – 14:44
11 · Let Claude interview you
AskUserQuestion tool; interview-first workflow for complex features; clean session to implement
14:44 – 17:07
12 · Patterns to avoid
Kitchen sink session, correcting over and over, over-specified CLAUDE.md, trust-then-verify gap, infinite exploration; Boris: 10-20% of sessions get thrown away
17:07 – 17:56
13 · Managing sessions
Escape to stop, double-tap/rewind, /clear, compact with instructions, save to markdown
17:56 – 20:17
14 · Quick tips
CLI tools, /init, IMPORTANT keyword, @references, child CLAUDE.md, Opus 4.5, slash commands, hooks, /permissions, /sandbox
20:17 – 21:49
15 · Develop your intuition
Rules are not laws; adapt to your workflow; develop judgment no guide can capture
21:49 – 22:52
16 · TLDR
Summary of top Boris and Anthropic principles: context, verification, plan-implement-commit, CLAUDE.md, subagents, parallel sessions
Atomic Insights
Lines worth screenshotting.
The context window is the one constraint all Claude Code best practices exist to protect -- not model capability, not speed.
Boris runs 5-10 parallel Claude sessions simultaneously, treating AI as schedulable capacity rather than a single conversation.
After every correction, end your prompt with update your CLAUDE.md so you do not make that mistake again -- every mistake becomes a permanent improvement.
Manual summarization beats autocompact: ask Claude to write a markdown file, then /clear and restart with that file as input.
CLAUDE.md over 500 lines means critical rules get lost in the noise -- prune ruthlessly, delete anything Claude already does correctly.
Vercel benchmarks showed skills fail to invoke 56% of the time without explicit mention in CLAUDE.md; a compressed 8KB docs index achieved 100% pass rate.
Boris uses Opus 4.5 for everything, optimizing for cost-per-reliable-change rather than cost-per-token -- the correction tax of weaker models costs more.
The interview technique: start a complex feature with a minimal prompt and ask Claude to interview you using the AskUserQuestion tool, then start a clean session to implement.
After two failed corrections, use /clear and write a better initial prompt incorporating what you learned -- do not keep correcting in the same polluted context.
Subagents run in their own context window, read dozens of files, and report back a summary -- your main context stays clean.
Boris has four named subagents: code-simplifier, verify-app, build-validator, code-architect -- each a specialist, not a generalist.
Plan mode adds overhead -- if you can describe the diff in one sentence, skip the planning and just do it.
Sessions are ephemeral: Claude does not learn preferences over time -- put persistent knowledge in CLAUDE.md or it disappears.
Any workflow you do multiple times a day should be a slash command committed to git for reuse across projects.
Post-tool-use hooks for automatic formatting catch the last 10% of code style issues without approval prompts.
Takeaway
Context is the only resource that actually matters.
WHAT TO LEARN
Every Claude Code best practice -- plan mode, CLAUDE.md hygiene, parallel sessions, subagents -- exists to protect the one finite resource: your context window.
03Context is king
The context window fills with everything: conversation history, file contents, command output, loaded rules -- when it fills, Claude starts forgetting and making inconsistent edits.
Run 3-5 parallel sessions via git worktrees instead of one long session: plan with one, implement with another, review with a third, and throw away the sessions that go nowhere without guilt.
04Always make a plan
The four-phase workflow (Explore, Plan, Implement, Commit) prevents mid-course corrections that waste both time and context -- a good plan means Claude usually executes in one shot.
05Let Claude verify its work
Verification is the single highest-leverage habit: give Claude tests, screenshots, or expected outputs so it can check its own work without requiring your attention on every mistake.
08Skills
CLAUDE.md should stay under 500 lines and be pruned ruthlessly -- if a rule is getting lost in the noise, Claude will silently ignore it; delete anything Claude already does correctly.
After every correction, end the prompt with update your CLAUDE.md so you do not make that mistake again -- this converts each mistake into permanent institutional knowledge.
09Ensuring skill invocation
When skills fail to invoke, the root cause is usually that they are not mentioned in CLAUDE.md -- explicit mention lifts invocation from 44% to 79%; a compressed docs index gets to 100%.
10Subagents
Subagents investigate in their own context window and report back a summary, keeping your main conversation clean -- they are the fix for the infinite exploration anti-pattern.
12Patterns to avoid
After two failed corrections, do not keep correcting -- use /clear and write a better initial prompt that incorporates what you learned; polluted context compounds errors.
14Quick tips
Any workflow you repeat multiple times a day should be a slash command committed to git, not something you re-type -- the compounding effect of automation is where the real productivity lives.
Glossary
Terms worth knowing.
Plan mode
A Claude Code mode (entered via Shift+Tab) where Claude reads files and answers questions but cannot make changes -- safe exploration before any edits.
CLAUDE.md
A special file Claude reads at the start of every session containing persistent project rules, code style, workflow conventions, and gotchas that Claude cannot infer from code alone.
Skills
Reusable knowledge files in .claude/skills/ that extend Claude with domain knowledge or repeatable workflows; loaded on demand rather than in every session.
Subagent
A separate Claude instance that runs an investigation or task in its own context window, reports back a summary, and keeps the main conversation context clean.
Autocompact
Claude Code built-in context compression that triggers automatically when the context gets full; less reliable than manual summarization because it loses nuance.
Git worktree
A Git feature that lets you check out multiple branches simultaneously in separate directories, enabling parallel Claude sessions on different tasks without context collision.
/clear
A Claude Code slash command that resets the conversation history, giving Claude a clean context window for a new unrelated task.
Interview technique
A workflow where you give Claude a minimal prompt and ask it to interview you with the AskUserQuestion tool before writing any code, surfacing edge cases and requirements you had not considered.
Context window
The total amount of text (conversation history, file contents, command output, loaded rules) that Claude can hold in memory at once; performance degrades as it fills.
/compact
A Claude Code command that compresses the current context with explicit instructions, giving you control over what gets preserved versus autocompact automatic behavior.
“Think of AI as capacity we can schedule, not a single conversational tool.”
Paradigm-shift framing, standalone with zero context→ TikTok hook↗ Tweet quote
10:04
“After every correction, end your prompt with: update your CLAUDE.md, so you do not make that mistake again. This turns every mistake into a permanent improvement.”
See every word as it's spoken — crank it to 2× and still catch all of it. The same dual-channel trick behind Amazon's Kindle + Audible.
17px
metaphoranalogy
Anthropic just updated their Claude Code documentation with official best practices, and Boris, the creator of Claude Code, recently shared his personal workflow and how the Claude Code team uses Claude Code every day.
Best practices for context management, plan mode, verification strategies, compound engineering, Claude MD power tips, the interview technique, parallel sessions, sub agents, skills, and a whole lot more straight from the makers of Clawdocode.
Let me break this down into concrete tips you can apply to your workflows today.
Hey. Alex here from Grit AI Studio. Today, we're going through Anthropix official best practices for Claude Code, enhanced with what Boris and the rest of the Claude Code team actually does day to day.
I figured we'll do a no fluff video, just straightforward. Here's what Anthropic says, here's what Boris says, and here's what the team does, and here's how you can apply it to yourself. If you're new to Claude Code, you should probably check out our getting started guide first.
Be warned, this video is going to be jam packed with tips, so fasten your seat belts. We'll also add a cheat sheet for you to download in the comments below. Okay.
Let's go.
Context is king, but also a scarce resource we really need to treat with care. Anthropic says this explicitly. Most best practices are based on one constraint.
Claude's context window fills up fast and performance degrades as it fills. This is the core insight. Everything else flows from here.
Your context window holds everything. Conversation history, file contents, command outputs, Claude MD, loaded skills.
When it fills up, Claude starts forgetting earlier instructions, makes more mistakes. According to Anthropic, this is the most important resource to manage.
So how do you apply this? Check context regularly with slash context. Clear between unrelated tasks and use sub agents for deep exploration.
Manual summarization beats autocompact. Boris takes this even further. He runs five to 10 parallel sessions.
Plan with one, review with another, clear between tasks. Instead of cramming everything into one long session, he keeps each focused on a single task. When context gets polluted, start fresh in another session.
As Boris puts it, think of AI as capacity we can schedule, not a single conversational tool. Pro tip from Boris, use three to five git work trees or multiple git checkouts to run parallel sessions on different branches simultaneously.
This lets you explore multiple approaches or work on unrelated features without context collision. Also, track your context. Use slash status line to customize your status bar to always show context usage.
This keeps the constraint visible so you'll never forget to manage it. Always make a plan. Anthropic recommends separating research and planning from implementation.
Here's their exact workflow. Phase one, explore in plan mode. Enter plan mode with shift tab tab.
Claude reads files, answers questions, but cannot make changes. Safe exploration.
Phase two, plan. Claude produces a detailed implementation plan. You review it, ask questions, refine, iterate.
Phase three, implement. Exit plan mode and start implementing.
Now Claude codes. It has context from exploration. It follows the plan you approved.
A great plan means much better code output. And then phase four, commit. Anthropic adds one important caveat.
Plan mode is useful but also adds overhead. For tasks where the scope is clear and the fix is small, like fixing a typo or adding a logline or renaming a variable, just ask Cloyd to do it directly. If you could describe the diff in one sentence, you can probably skip the planning.
Boris has one strict rule here. Start every complex task in plan mode, no exceptions. And he takes this a step further.
Plan first in plan mode, iterate with Claude until the plan is solid, then switch to auto accept with shift tab. His words, Claude typically executes in one shot after a good plan.
The planning prevents mid course corrections that wastes time and context.
Give Claude a way to verify its work. Anthropic says this is the single highest leverage that you can do. Claude can check its own work.
Without verification criteria, you become the only feedback loop. Every mistake requires your attention. Here are three verification strategies from the docs.
One, include test cases. Two, visual verification.
Three, root cause fixing. Personally, I use the Claudine Chrome extension for UI verification. It opens a browser, tests the UI, iterates until it works.
But the core principle works everywhere. Give Claude something to verify against. Boris calls verification probably the most important thing to get great results.
He uses the Chrome extension daily for UI testing. Claude iterates until it looks right and functions correctly. For him, verification isn't optional.
Nothing ships without it. You don't trust, you instrument.
The go fix pattern. Claude fixes most bugs by itself. When something breaks, don't over explain, just say go fix it.
Trust the verification loop that you've set up.
As we always say, context is king, but it's a precious resource. Anthropic provides specific before and after examples of how you can provide specific context to your prompts. Let me show you the pattern.
Scoping the task. Pointing to sources. Referencing patterns.
Describing symptoms. The more precise your instructions, the fewer corrections you'll need.
Anthropic lists several ways to give Claude context. You can reference files directly with references. You can paste images by copy pasting or drag and dropping into the prompt.
You can give URLs for documentation and API references, and you can also pipe data in.
You can tell Claude to pull context itself using bash commands, MCP tools, or by reading files.
Here are some advanced techniques to level up your prompting according to the Claude code team. Specs reduce corrections. Write detailed specs and reduce ambiguity before handing work off.
The more specific you are, the better the output. This ties directly into the interview technique, which we'll cover later. Use voice dictation.
You speak three times faster than you type, and your prompts get way more detailed as a result. On macOS, hit the function key twice to activate.
More detail is generally better output, but also remember quality over quantity.
Make Claude your reviewer. Say something like grill me on these changes and don't make a PR until I pass your test or prove me this works and have Claude diff between the main and your feature branch.
Our most valuable tool for consistent results and making Cloid compound over time is CloidMD. We've done several videos on this topic already.
Anthropic provides a clear table of what to include and exclude. Generally, you should include bash commands that Claude can't guess, code style rules that differ from defaults, testing instructions, and preferred test runners.
Include repository etiquette, branch naming, PR conventions, and so on. Architectural decisions specific to your project.
And also include common gotchas or non obvious behavior in your project. And then generally exclude anything Claude can figure out by reading code.
Standard language conventions Claude already knows or detailed API documentation. You should link to the docs instead. Information that changes frequently generally stays out of Claude MD.
Long explanations or tutorials do not belong in the Claude MD file. And there's no need for file by file description of the codebase.
Here's a critical insight from the docs. If Claude keeps doing something you don't want despite having a rule against it, the file is probably too long and the rule is getting lost. Keep your Claude MD file under 500 lines and prune ruthlessly.
Boris and his team takes this seriously. The entire team contributes to the Claude MD file multiple times weekly. When Claude makes a mistake, they document it here.
During code review, they tag Claude to update guidelines automatically. They make use of the GitHub app with the slash install GitHub action and they treat Claude MD as a living document that compounds value over time. Boris' golden rule which I wholeheartedly agree with, after every correction, end your prompt with update your Claude MD, so you don't make that mistake again.
This turns every mistake into a permanent improvement. Always think compound engineering.
While Claude MD loads every session, skills load on demand. Create skills in your Claude skills folder for domain knowledge or repeatable workflows that don't need to be in every conversation.
Boris recommends creating your own skills and committing them to git, reuse across every project. Any pattern you repeat becomes a portable skill. The team even builds learning focus skills like a spaced repetition skill where you explain your understanding, and Claude asks follow ups to fill gaps, and then stores the result.
Skills are a superpower we'll cover in-depth in a separate episode. In brief, in the context of Claude code, you can think of two types of skills. One, auto invoked domain knowledge.
Claude applies these when working in relevant areas. Two, workflow skills that you invoke with the slash command, repeatable multi step workflows.
Run fix issue one two three four and Claude executes the whole workflow. Today, skills and slash commands are sort of the same thing and you can use disable model invocation equals true for workflows that you want to trigger manually.
Here are some pro tips for maximizing skill reliability. We've already done a few videos about Claude MD and Agents MD, but it's also worth mentioning that Vercel recently did some interesting benchmarks on invocation of skills with and without explicit mentions in your Claude or AgentsMD files.
In 56% of their eval cases, the skill was never invoked even though it was available. This finding supports putting critical information directly into Claude MD rather than relying on Claude fetching it by itself.
They also looked at embedding a compressed docs index directly into their agents MD or Claude MD, and that actually achieved 100% pass rate, while skills maxed out at 79% with explicit instructions.
Now this makes sense as the Claude md is always loaded upfront in all conversations. You might think adding a whole index into ClaudeMD fills up a lot of space, but they managed to compress 40 kilobytes of docs down to eight kilobytes, 80% reduction, while maintaining a 100% pass rate.
Again, still supporting the argument, keep your Claude MD focused. You can pack a lot of valuable information in a compact index that points to retrievable files.
Okay. Use sub agents for investigation. Anthropic explicitly recommends this pattern.
Since context is your fundamental constraint, sub agents are one of the most powerful tools available. So here's what happens.
The sub agent explores in its own context window, reads dozens of files, and reports back a summary. Your main context stays clean. You can also use sub agents for verification after Claude implements something.
Boris uses specialized sub agents for specific roles. Code Simplifier for cleanup, Verify App for end to end testing, build validator to ensure build pass, and code architect for design decisions. Think of them as team members with distinct responsibilities.
Simply append use sub agents to any request where you want Claude to throw more compute at the problem, or use slash commands to trigger sub agents that you've defined in your project. Offload individual tasks to sub agents to keep your main agent's context window clean and focused.
With the newly introduced ask user question tool in ClaudeCode, we all of a sudden got a really powerful technique that you should definitely adopt in your workflows. We call it the interview technique. This is brilliant, especially when you work on larger features.
Have Claude interview you first. Start with a minimal prompt and ask Claude to interview you using the ask user question tool. Claude asks about things you might not have considered.
Technical implementation, UI, UX, edge cases, trade offs, and you can use this for so much more than coding. Once the spec is complete, start a fresh session to execute it.
Clean context, focus entirely on implementation. Let's talk about some common failure patterns to avoid.
Anthropic calls these out explicitly. Here's what to watch for. The kitchen sink session.
You start with one task, ask something unrelated, go back to the first task, now context fills with irrelevant information. The fix is simple, use slash clear between unrelated tasks or fork.
Correcting over and over. Claude does something wrong, you correct it. Still wrong, correct again.
Context is polluted with failed approaches. The fix, after two failed corrections, use slash clear and write a better initial prompt incorporating what you learned.
A lot of the Claude code team members also call out that they will enter plan mode again if Claude starts derailing or starts getting stuck. The over specified Claude MD. Too long, Claude ignores half of it because important rules get lost in the noise.
The fix, ruthlessly prune. If Claude already does something correctly without the instruction, delete it or convert it to a hook.
The trust then verify gap. Claude produces plausible looking code that doesn't handle edge cases. Now here the fix is to always provide verification.
If you can't verify it, don't ship it. The infinite exploration. You ask Claude to investigate without scoping it.
Claude reads hundreds of files filling the context. The fix is of course to scope investigations narrowly or use sub agents.
And here's a reality check from Boris. He admits he throws away 10 to 20% of Claude code sessions that go nowhere. And that's okay.
Not every session succeeds. Parallel sessions hedge against dead ends. Quick abandonments beats the sunk cost fallacy.
The 80% that work more than compensate. The team points out that after a mediocre fix, you can say, knowing everything you know now, scrap this and implement the elegant solution. Claude often finds better approaches once it understands the problem space.
Here are some quick tips from the docs on managing sessions. Course correct early. Hit escape to stop Claude mid action.
Double tap escape or use slash rewind to open the rewind menu where you can restore previous state. You can also tell Claude undo that and Claude will revert its changes. And remember, slash clear, reset context between unrelated tasks.
Manage context aggressively. Use slash clear frequently between tasks and run compact with instructions for controlled compaction.
I like to ask Claude to just put it in a markdown file and then reset with clear and then start over with that context file as your input.
Okay. Let's do some final rapid fire tips from the official docs and Boris' workflow. One, install CLI tools like GitHub, AWS, g cloud.
Cloyd can use them for external services without rate limits. Two, the slash init command analyzes your code base to detect build systems, test frameworks, and code patterns. Use it.
Three, add emphasis like important or you must in your ClawdMD file to improve adherence to critical rules. Four, Claude MD can import files with at references.
Keep the main file clean, details in separate files. Five, child directories can have their own Claude MD file.
Claude loads them on demand when working in those directories. Number six, sessions are ephemeral. Claude doesn't learn preferences over time.
Put persistent knowledge in your Claude MD file. And a special one from Boris, seven, always use Opus 4.5 or the latest model.
Yes, it costs more per token, but Boris optimizes for cost per reliable change. The correction tax of weaker models hallucinations cost more than the model itself.
And by now, you're probably on the max plan already and if not, you should definitely consider it. By the way, Anthropic is not paying me anything to say this. Eight, any workflow you do multiple times a day should be a slash command or skill.
Create your own skills and commit them to git. Reuse across projects. Any pattern you repeat becomes a portable skill.
Number nine, Use post tool use hooks for automatic formatting. After write or edit, run your formatter. That catches the last 10% without approval prompts.
Number 10. Never use dangerously skipped permissions in production. Use slash permissions to pre approve specific safe commands instead.
And also check out sandboxing with slash sandbox for OS level isolation. Sandbox defines upfront boundaries rather than bypassing all checks.
This reduces interruptions while keeping you in control. And finally, make sure you don't get lazy.
Keep learning with Claude. Enable the explanatory or learning output styles in slash config to have Claude explain the why behind its changes.
Have Claude generate a visual HTML presentation explaining unfamiliar code. It makes surprisingly good slides.
Ask Claude to draw ASCII diagrams of new protocols and code bases to help you understand them. Build a space repetition learning skill.
You explain your understanding. Claude asks follow ups to fill gaps and stores the results.
Now one last thing from Anthropics Guide. These patterns and best practices aren't laws. Sometimes you should let context accumulate because you're deep in a complex problem.
Sometimes skipping the plan is right because the task is exploratory. And sometimes a vague prompt is exactly what you need to see how Claude interprets the problem. Pay attention to what works for you.
Over time, you'll develop intuition no guide can capture. The core message from Anthropic and Boris, context window is your most important resource.
Give Claude verification criteria, test screenshots expected outputs. Explore, plan, implement, commit.
Be specific in prompts, reference files and patterns, and keep Claude MD focused and pruned. Use sub agents to preserve main context.
Clear between tasks, restart after failed corrections. And remember the interview technique for complex features.
Specifically from Boris' workflow, run multiple parallel sessions, not just one. Make Claude MD a team effort, updated constantly.
Automate inner loops with slash commands and hooks. Accept that 10 to 20% of sessions fail. That's normal.
And verification is non negotiable. These aren't my personal opinions.
This is from the team that built CloidCode and the person who created it. Apply them in your workflow.
That was a lot, but I hope you picked up some useful tips and tricks. As always, I would really appreciate if you hit that like button and subscribe for more Claude code videos. Thanks a lot for watching, and I'll see you in the next one.
The Hook
The bait, then the rug-pull.
What happens when the person who built the tool publishes exactly how his own team uses it? Alex from GritAI Studio takes Anthropic official best practices doc and Boris Cherny public workflow thread and collapses them into 15 sections of concrete, terminal-tested guidance -- no filler, no speculation.
Frameworks
Named ideas worth stealing.
03:15model
Explore, Plan, Implement, Commit
Four-phase workflow: plan mode for safe exploration, iterate on a spec, auto-accept during implementation, commit. Separates thinking from doing to prevent mid-course corrections.
Steal forAny new feature or bug fix involving more than one file
08:20list
CLAUDE.md Include/Exclude Checklist
Include: bash commands Claude cannot guess
Include: code style rules that differ from defaults
Include: testing instructions and preferred runners
Add Modern Creator as a preferred source and Google shows you more of our breakdowns in Search, Top Stories, and AI Overviews. It only changes what you see, and you can undo it in your Google settings anytime.
Add to Preferred SourcesOpens your Google source preferences with us pre-loaded. Tick the box and you're done.
A systems playbook for Claude Code and Codex: the five-step loop, the instruction files, and the guardrails that separate trustworthy AI output from expensive rework.
A 17-minute screen-recorded walkthrough of installing, configuring, and running the mattpocock/skills repo on a real codebase — from a vague idea to a reviewed, committed change.
A live, no-coding walkthrough of the six concepts behind autonomous AI loops, then two working examples built with Claude Code's /goal command and Routines.
A breakdown of why maxing out effort settings on Claude, GPT, Grok, and Gemini rarely makes the output better — and the framework for picking the right level every time.
00:48
01:17
01:48
02:01
02:21
02:40
03:02
03:34
03:50
04:00
04:20
04:47
05:22
05:36
05:57
06:25
06:43
07:07
07:09
07:41
07:48
08:25
08:43
09:00
09:11
09:29
09:53
10:04
10:48
10:53
11:16
11:28
11:55
12:26
12:51
13:17
13:26
14:10
14:32
15:05
15:09
15:29
15:51
16:08
16:29
16:40
17:16
17:40
17:55
18:22
18:45
19:01
19:12
19:26
19:49
20:16
20:23
20:43
20:56
21:51
22:09
22:26
22:43
29:19
17:17
16:16
15:12
16:17
1:14:40