Boris created Claude Code at Anthropic. When asked how he uses it, he shared 13 practical tips from his daily workflow. His setup is "surprisingly vanilla" — proof that CC works great out of the box.
Boris runs 5 instances of Claude Code simultaneously in his terminal using 5 separate git checkouts of the same repo. He numbers his tabs 1-5 for easy reference and uses system notifications to know when any Claude needs input.
Key detail
Each tab runs in its own git checkout, so Claude can make changes in parallel without conflicts. Configure iTerm2 notifications to know when any Claude needs attention.
~/repo-1 $ # Tab 1: Working on feature
~/repo-2 $ # Tab 2: Running tests
~/repo-3 $ # Tab 3: Code review
~/repo-4 $ # Tab 4: Debugging
~/repo-5 $ # Tab 5: Documentation
Beyond the terminal, Boris runs 5-10 additional sessions on claude.ai/code. He fluidly hands off between local and web using the &
command or --teleport
flag.
He also kicks off sessions from his phone via the Claude iOS app in the morning, then picks them up on his computer later.
Key commands
& — Background a session
--teleport — Switch contexts between local and web
Boris uses Opus 4.5 with thinking mode for every task. His reasoning:
Why Opus over Sonnet
"It's the best coding model I've ever used, and even though it's bigger & slower than Sonnet, since you have to steer it less and it's better at tool use, it is almost always faster than using a smaller model in the end."
The takeaway: less steering + better tool use = faster overall results, even with a larger model.
The team shares a single CLAUDE.md file for the Claude Code repo, checked into git. The whole team contributes multiple times a week.
Key practice
"Anytime we see Claude do something incorrectly we add it to the CLAUDE.md, so Claude knows not to do it next time."
bash
claude-cli $ cat CLAUDE.md
**Always use `bun`, not `npm`.**
bun run typecheck
bun run test -- -t "test name" # Single suite
bun run test:file -- "glob" # Specific files
bun run lint:file -- "file1.ts" # Specific files
bun run lint # All files
bun run lint:claude && bun run test
During code review, Boris tags @.claude on PRs to add learnings to the CLAUDE.md as part of the PR itself.
They use the Claude Code GitHub Action (/install-github-action
) for this. Boris calls it their version of "Compounding Engineering" — inspired by Dan Shipper's concept.
// Example PR comment:
nit: use a string literal, not ts enum
@claude add to CLAUDE.md to never use enums,
always prefer literal unions
Result
Claude automatically updates the CLAUDE.md and commits: "Prefer `type` over `interface`; **never use `enum`** (use string literal unions instead)"
Most sessions start in Plan mode (shift+tab twice). Boris iterates on the plan with Claude until it's solid, then switches to auto-accept mode.
The workflow
Plan mode → Refine plan → Auto-accept edits → Claude 1-shots it
> i want to improve progress notification
rendering for skills. can you make it look
and feel a bit more like subagent progress?
▮▮ plan mode on (shift+tab to cycle)
"A good plan is really important to avoid issues down the line."
Boris uses slash commands for workflows he does many times a day. This saves repeated prompting, and Claude can use them too.
Commands are checked into git under .claude/commands/
and shared with the team.
> /commit-push-pr
/commit-push-pr Commit, push, and open a PR
Power feature
Slash commands can include inline Bash to pre-compute info (like git status) for quick execution without extra model calls.
Boris thinks of subagents as automations for the most common PR workflows:
Examples
code-simplifier — Cleans up code after Claude finishes
verify-app — Detailed instructions for end-to-end testing
The team uses a PostToolUse hook to auto-format Claude's code. While Claude generates well-formatted code 90% of the time, the hook catches edge cases to prevent CI failures.
Instead of --dangerously-skip-permissions
, Boris uses /permissions to pre-allow common safe commands. Most are shared in .claude/settings.json
.
> /permissions
Permissions: Allow Ask Deny Workspace
Claude Code won't ask before using allowed tools.
↑ 12. Bash(bq query:*)
13. Bash(bun run build:*)
14. Bash(bun run lint:file:*)
15. Bash(bun run test:*)
16. Bash(bun run test:file:*)
17. Bash(bun run typecheck:*)
18. Bash(bun test:*)
19. Bash(cc:*)
20. Bash(comm:*)
> 21. Bash(find:*)
Claude Code uses all of Boris's tools autonomously:
claude-cli-2 $ cat .mcp.json
{
"mcpServers": {
"slack": {
"type": "http",
"url": "https://slack.mcp.anthropic.com/mcp"
}
}
}
For very long-running tasks, Boris ensures Claude can work uninterrupted:
Options
(a) Prompt Claude to verify with a background agent when done
(b) Use an agent Stop hook for deterministic checks
(c) Use the "ralph-wiggum" plugin (community idea by @GeoffreyHuntley)
For sandboxed environments, he'll use --permission-mode=dontAsk
or --dangerously-skip-permissions
to avoid blocks.
* Reticulating... (1d 2h 47m · ↓ 2.4m tokens · thinking)
>
This is Boris's #1 tip:
Key insight
"Probably the most important thing to get great results out of Claude Code — give Claude a way to verify its work. If Claude has that feedback loop, it will 2-3x the quality of the final result."
For his own changes to claude.ai/code, Claude uses the Claude Chrome extension to open a browser, test UI changes, and iterate until it works perfectly.
Verification varies by domain: Bash commands, test suites, simulators, browser testing, etc. The key is giving Claude a way to close the feedback loop.
Takeaway
Invest in domain-specific verification for optimal performance. Claude tests every single change Boris lands to claude.ai/code.
Boris shared 10 more tips on January 31, 2026. These are sourced directly from the Claude Code team — remember, everyone's setup is different. Experiment to see what works for you!
Spin up 3-5 git worktrees at once, each running its own Claude session in parallel. It's the single biggest productivity unlock, and the top tip from the team.
Why worktrees over checkouts
Most of the Claude Code team prefers worktrees — it's the reason @amorriscode built native support for them into the Claude Desktop app!
Some people also name their worktrees and set up shell aliases (za, zb, zc) so they can hop between them in one keystroke. Others have a dedicated "analysis" worktree that's only for reading logs and running BigQuery.
$ git worktree add .claude/worktrees/my-worktree origin/main
$ cd .claude/worktrees/my-worktree && claude
Pour your energy into the plan so Claude can 1-shot the implementation. Don't keep pushing when things go sideways — switch back to plan mode and re-plan.
Team patterns
One person has one Claude write the plan, then they spin up a second Claude to review it as a staff engineer. Another says the moment something goes sideways, they switch back to plan mode and re-plan.
They also explicitly tell Claude to enter plan mode for verification steps, not just for the build.
> Try "refactor cli.tsx"
▮▮ plan mode on (shift+Tab to cycle)
After every correction, end with: "Update your CLAUDE.md so you don't make that mistake again." Claude is eerily good at writing rules for itself.
Key practice
Ruthlessly edit your CLAUDE.md over time. Keep iterating until Claude's mistake rate measurably drops.
One engineer tells Claude to maintain a notes directory for every task/project, updated after every PR. They then point CLAUDE.md at it.
Memory files · /memory
└ ~/.claude/CLAUDE.md: 76 tokens
└ CLAUDE.md: 4k tokens
Create your own skills and commit them to git. Reuse across every project.
Tips from the team
If you do something more than once a day, turn it into a skill or command
Build a /techdebt slash command and run it at the end of every session to find and kill duplicated code
Set up a slash command that syncs 7 days of Slack, GDrive, Asana, and GitHub into one context dump
Build analytics-engineer-style agents that write dbt models, review code, and test changes in dev
Enable the Slack MCP, then paste a Slack bug thread into Claude and just say "fix." Zero context switching required.
Or, just say "Go fix the failing CI tests." Don't micromanage how.
Pro tip
Point Claude at docker logs to troubleshoot distributed systems — it's surprisingly capable at this.
> fix this https://ant.slack.com/archives/...
● slack - search_public (MCP)(query: "in:C07VBS...")
Searches for messages in public Slack ch...
'slack_search_public' does NOT generally
for user consent to use 'slack_search_p...
a. Challenge Claude. Say "Grill me on these changes and don't make a PR until I pass your test." Make Claude be your reviewer. Or, say "Prove to me this works" and have Claude diff behavior between main and your feature branch.
b. After a mediocre fix, say: "Knowing everything you know now, scrap this and implement the elegant solution."
c. Write detailed specs and reduce ambiguity before handing work off. The more specific you are, the better the output.
Key insight
Don't accept the first solution. Push Claude to do better — it usually can.
The team loves Ghostty! Multiple people like its synchronized rendering, 24-bit color, and proper unicode support.
For easier Claude-juggling, use /statusline to customize your status bar to always show context usage and current git branch. Many of us also color-code and name our terminal tabs, sometimes using tmux — one tab per task/worktree.
Voice dictation
Use voice dictation. You speak 3x faster than you type, and your prompts get way more detailed as a result. (Hit fn x2 on macOS)
┌──────────────────────────────────────────┐
│ ● ● ● │ 1 ⌘1 │ 2 ● ⌘2 │ 3 ⌘3 │ 4 │
├──────────────────────────────────────────┤
│ × * Claude Code (node) │
│ │
│ Claude Code v2.1.29 │
│ Opus 4.5 · Claude Enterprise │
│ /code/claude │
└──────────────────────────────────────────┘
a. Append "use subagents" to any request where you want Claude to throw more compute at the problem.
b. Offload individual tasks to subagents to keep your main agent's context window clean and focused.
c. Route permission requests to Opus 4.5 via a hook — let it scan for attacks and auto-approve the safe ones.
> use 5 subagents to explore the codebase
● I'll launch 5 explore agents in parallel to...
● Running 5 Explore agents... (ctrl+o to expand)
├─ Explore entry points and startup · 10 t...
│ └ Bash: Find CLI or main entry files
├─ Explore React components structure · 14...
│ └ Bash: ls -la /Users/boris/code/clau...
├─ Explore tools implementation · 14 tool...
│ └ Bash: Find tool implementation files
├─ Explore state management · 13 tool uses
│ └ Search: **/screens/REPL.tsx
└─ Explore testing infrastructure · 13 to...
└ Search: test/mocks/**/*.ts
Ask Claude Code to use the "bq" CLI to pull and analyze metrics on the fly. We have a BigQuery skill checked into the codebase, and everyone on the team uses it for analytics queries directly in Claude Code.
Boris's take
"Personally, I haven't written a line of SQL in 6+ months."
This works for any database that has a CLI, MCP, or API.
A few tips from the team to use Claude Code for learning:
a. Enable the "Explanatory" or "Learning" output style in /config to have Claude explain the why behind its changes.
b. Have Claude generate a visual HTML presentation explaining unfamiliar code. It makes surprisingly good slides!
c. Ask Claude to draw ASCII diagrams of new protocols and codebases to help you understand them.
d. Build a spaced-repetition learning skill: you explain your understanding, Claude asks follow-ups to fill gaps, stores the result.
Key takeaway
Claude Code isn't just for writing code — it's a powerful learning tool when you configure it to explain and teach.
Boris shared 12 more tips on February 11, 2026. This time the theme is customization — hooks, plugins, agents, permissions, and all the ways to make Claude Code your own.
A few quick settings to make Claude Code feel right in your terminal:
Key settings
Theme: Run /config to set light/dark mode
Notifications: Enable notifications for iTerm2, or use a custom notifs hook
Newlines: If you use Claude Code in an IDE terminal, Apple Terminal, Warp, or Alacritty, run /terminal-setup to enable shift+enter for newlines (so you don't need to type \)
Vim mode: Run /vim
Run /model
to pick your preferred effort level:
Effort levels
Low — less tokens & faster responses
Medium — balanced behavior
High — more tokens & more intelligence
Personally, I use High for everything.
||| High effort (default) ← → to adjust
Fast mode is ON and available with Opus 4.6
Plugins let you install LSPs (now available for every major language), MCPs, skills, agents, and custom hooks.
Install a plugin from the official Anthropic plugin marketplace, or create your own marketplace for your company. Then, check the settings.json
into your codebase to auto-add the marketplaces for your team.
Getting started
Run /plugin to browse and install plugins.
To create custom agents, drop .md
files in .claude/agents
. Each agent can have a custom name, color, tool set, pre-allowed and pre-disallowed tools, permission mode, and model.
Pro tip
There's a little-known feature that lets you set the default agent used for the main conversation. Just set the "agent" field in your settings.json or use the --agent flag.
> use the sentry errors agent
sentry-errors(Fetch Sentry error logs)
Search(pattern: "sentry", path: "src")
+10 more tool uses (ctrl+o to expand)
Run /agents
to get started.
Claude Code uses a sophisticated permission system with a combo of prompt injection detection, static analysis, sandboxing, and human oversight.
Out of the box, we pre-approve a small set of safe commands. To pre-approve more, run /permissions
and add to the allow and block lists. Check these into your team's settings.json
.
Wildcard syntax
We support full wildcard syntax. Try "Bash(bun run *)" or "Edit(/docs/**)"
> /permissions
Permissions: [Allow] Ask Deny
52. Bash(gh issue view:*)
53. Bash(gh pr checks:*)
54. Bash(gh pr comment:*)
55. Bash(gh pr diff:*)
56. Bash(gh pr list:*)
Opt into Claude Code's open source sandbox runtime to improve safety while reducing permission prompts.
Run /sandbox
to enable it. Sandboxing runs on your machine, and supports both file and network isolation. Windows support coming soon.
Sandbox modes
Sandbox BashTool, with auto-allow — commands run in sandbox, auto-approved
Sandbox BashTool, with regular permissions — sandbox + normal permission prompts
No Sandbox — default behavior
Custom status lines show up right below the composer, and let you show model, directory, remaining context, cost, and pretty much anything else you want to see while you work.
Everyone on the Claude Code team has a different statusline. Use /statusline
to get started, to have Claude generate a statusline for you based on your .bashrc
/.zshrc
.
> _
[Opus] 📁 my-app | 🌿 feature/auth
█████████░░░░░░░░░ 42% | $0.08 | 🕐 7m 3s
Did you know every key binding in Claude Code is customizable?
Run /keybindings
to re-map any key. Settings live reload so you can see how it feels immediately.
How it works
Keybindings are stored in ~/.claude/keybindings.json. Claude can generate the config for you — just describe what you want.
Hooks are a way to deterministically hook into Claude's lifecycle. Use them to:
Use cases
Automatically route permission requests to Slack or Opus
Nudge Claude to keep going when it reaches the end of a turn (you can even kick off an agent or use a prompt to decide whether Claude should keep going)
Pre-process or post-process tool calls, e.g. to add your own logging
Ask Claude to add a hook to get started.
It's the little things that make CC feel personal. Ask Claude to customize your spinner verbs to add or replace the default list with your own verbs.
Check the settings.json
into source control to share verbs with your team.
> in my settings, make my spinner verbs star trek themed.
● Update(~/.claude/settings.json)
✱ Beaming up… (esc to interrupt)
Run /config
and set an output style to have Claude respond using a different tone or format.
Recommended styles
Explanatory — great when getting familiar with a new codebase, to have Claude explain frameworks and code patterns as it works
Learning — have Claude coach you through making code changes
Custom — create your own output styles to adjust Claude's voice the way you like
Claude Code is built to work great out of the box. When you do customize, check your settings.json into git so your team can benefit, too.
We support configuring for your codebase, for a sub-folder, for just yourself, or via enterprise-wide policies.
By the numbers
Pick a behavior, and it is likely that you can configure it. We support 37 settings and 84 env vars (use the "env" field in your settings.json to avoid wrapper scripts).
Boris announced built-in git worktree support for Claude Code on February 20, 2026. Agents can now run in parallel without interfering with each other — in CLI, Desktop app, IDE extensions, web, and mobile.
claude --worktree
for IsolationTo run Claude Code in its own git worktree, just start it with the --worktree
option. You can name your worktree, or have Claude name it for you.
Use this to run multiple parallel Claude Code sessions in the same git repo, without the code edits clobbering each other.
$ claude --worktree my_worktree
$ claude --worktree my_worktree --tmux
What changed
The Claude Code Desktop app has had built-in support for worktrees for a while — now it's in the CLI too.
If you prefer not to use the terminal, head to the Code tab in the Claude Desktop app and check the worktree checkbox.
How to enable
Open the Claude Desktop app → Code tab → check the "worktree" checkbox. That's it.
Subagents can also use worktree isolation to do more work in parallel. This is especially powerful for large batched changes and code migrations.
To use it, ask Claude to use worktrees for its agents. Available in CLI, Desktop app, IDE extensions, web, and Claude Code mobile app.
> Migrate all sync io to async. Batch up the changes,
and launch 10 parallel agents with worktree isolation.
Make sure each agent tests its changes end to end,
then have it put up a PR.
You can also make subagents always run in their own worktree. To do that, just add isolation: worktree
to your agent frontmatter.
---
name: worktree-worker
model: haiku
isolation: worktree
---
If you're a Mercurial, Perforce, or SVN user, define worktree hooks to benefit from isolation without having to use Git.
$ cat .claude/settings.json
{
...
"hooks": {
"WorktreeCreate": [
{ "command": "jj workspace add \"$(cat /dev/stdin | jq -r '.name')\"" }
],
"WorktreeRemove": [
{ "command": "jj workspace forget \"$(cat /dev/stdin | jq -r '.worktree_path')\"" }
]
},
...
}
Boris announced two new built-in skills for Claude Code on February 27, 2026: /simplify to improve code quality and /batch to automate code migrations in parallel. Combined, these automate much of the work it used to take to shepherd a PR to production and perform parallelizable code migrations.
Use parallel agents to improve code quality, tune code efficiency, and ensure CLAUDE.md compliance. Just append /simplify
to any prompt.
> hey claude make this code change then run /simplify
What it does
Runs parallel agents that review your changed code for reuse opportunities, quality issues, and efficiency improvements — all in one pass.
Interactively plan out code migrations, then execute in parallel using dozens of agents. Each agent runs with full isolation using git worktrees, testing its work before putting up a PR.
> /batch migrate src/ from Solid to React
How it works
You plan the migration interactively, then /batch fans out the work to parallel agents — each in its own worktree, each testing and creating a PR independently.
/loop lets Claude run recurring tasks for up to 3 days unattended. Code Review dispatches a team of agents on every PR. /btw lets you ask questions mid-task without breaking Claude's flow.
Use /loop to schedule recurring tasks for up to 3 days at a time. Claude runs your prompt on an interval, handling long-running workflows autonomously.
> /loop babysit all my PRs. Auto-fix build issues and when comments come in, use a worktree agent to fix them
> /loop every morning use the Slack MCP to give me a summary of top posts I was tagged in
What it does
Schedules a prompt to run on a recurring interval. Use it for PR babysitting, Slack summaries, deploy monitoring, or any repeating workflow — running for up to 3 days unattended.
When a PR opens, Claude dispatches a team of agents to hunt for bugs. Anthropic built it for themselves first — code output per engineer is up 200% this year, and reviews were the bottleneck.
Boris personally used it for weeks before launch. It catches real bugs he wouldn't have noticed otherwise.
What it does
Automatically reviews every PR with a team of agents. Each agent focuses on a different concern — logic errors, security issues, performance regressions — then posts inline comments directly on the PR.
A slash command for side-chain conversations while Claude is actively working. Single-turn, no tool calls, but has full context of the conversation. Built by @ErikSchluntz as a side project — 1.5M views on the launch tweet.
> /btw what does the retry logic do?
The retry logic in auth.ts uses exponential backoff
with a max of 3 attempts. It catches 401/403 errors
and refreshes the token before retrying.
What it does
Lets you ask a quick question mid-task without interrupting Claude's flow. The response is single-turn with no tool calls, but Claude has full context of what it's working on — so answers are grounded in the current conversation.
The Claude Code team dropped 8 features in one thread: /effort max for deeper reasoning, voice mode for everyone, remote control sessions, setup scripts, session naming, /color, and a new PostCompact hook.
Set effort to 'max' and Claude reasons for longer, using as many tokens as needed. Burns through your usage limits faster, so you activate it per session.
> /effort max
What it does
Sets the reasoning effort level for the current session. At 'max', Claude thinks longer and uses more tokens per response — useful for hard debugging, architecture decisions, or tricky code where you want Claude to really think it through.
Run claude remote-control
and then spawn a new local session directly from the mobile app. Available on Max, Team, and Enterprise (v2.1.74+).
$ claude remote-control
What it does
Lets you start fresh Claude Code sessions from your phone while connected to your local dev environment. Walk away from your desk, think of something, and kick off a task from mobile — Claude runs on your machine.
Voice mode is now rolled out to 100% of users, including in Claude Code Desktop and Cowork. Sometimes you need somebody to talk to.
🎙 "Hey Claude, fix all the bugs in this repo."
What it does
Lets you speak to Claude Code instead of typing. Available in Desktop and Cowork — useful for hands-free coding, dictating complex requirements, or when you think faster than you type.
Add a setup script in Claude Code on the web and desktop. It runs before Claude Code launches on a cloud environment — install dependencies, configure settings, set env vars.
apps
#!/bin/bash
yarn install
What it does
Runs a bash script automatically when a new Claude Code session starts on a cloud environment. Skipped when resuming an existing session. Use it to install dependencies, set up configs, or prepare the environment before Claude starts working.
Name your session at launch with the --name
flag. Makes it easy to identify sessions when running multiple in parallel.
$ claude --name "auth-refactor"
What it does
Gives your Claude Code session a human-readable name on start. Especially useful when juggling multiple worktrees or sessions — you can tell at a glance which session is doing what.
After plan mode, Claude will automatically name your session based on what you're working on. No manual naming needed.
> shift+tab
[plan]> Refactor the auth middleware to use JWT
What it does
Claude infers a descriptive session name from your plan mode conversation. Pairs well with claude --name — use --name when you know what you're doing upfront, and let auto-naming handle it when you start by planning.
Change the color of the prompt input with /color
. Useful for visually distinguishing sessions when running multiple in parallel.
> /color
What it does
Sets the color of your prompt input for the current session. When you have 3-5 sessions open in different terminals, color-coding them makes it instantly clear which is which.
A new hook event: PostCompact. Fires after Claude compresses its conversation context, letting you inject instructions or run commands when compaction happens.
"hooks": {
"PostCompact": [{
"matcher": "",
"hooks": [{
"type": "command",
"command": "echo 'Context was compacted'"
}]
}]
}
What it does
Fires after Claude compresses its context window. Use it to re-inject critical instructions that might get lost during compaction, log when compaction happens, or trigger any automation you need when the context resets.
Auto mode kills permission prompts with built-in safety classifiers, /schedule creates cloud-based recurring jobs that run beyond your laptop, iMessage becomes a channel, and auto-dream keeps your memory clean.
Instead of approving every file write and bash command, or skipping permissions entirely with --dangerously-skip-permissions
, auto mode lets Claude make permission decisions on your behalf.
$ claude --enable-auto-mode
How it works
Anthropic built and tested classifiers that evaluate each action before it runs. Safe operations (reading files, running tests) get auto-approved. Risky ones (deleting files, force-pushing, running unknown scripts) still get flagged. It's the middle ground between clicking "approve" 50 times per session and yolo-ing with no safety net.
Boris's take: "no 👏 more 👏 permission prompts 👏"
Use /schedule
to create recurring cloud-based jobs for Claude, directly from the terminal. Unlike /loop
(which runs locally for up to 3 days), scheduled jobs run in the cloud — they work even when your laptop is closed.
$ /schedule a daily job that looks at all PRs shipped
since yesterday and update our docs based on the
changes. Use the Slack MCP to message #docs-update
with the changes
Use cases
The Anthropic team uses these internally to automatically resolve CI failures, push doc updates, and power automations that need to exist beyond a closed laptop. Think of it as cron jobs, but Claude does the work.
iMessage is now available as a Claude Code channel. Install the plugin and text Claude like you'd text a friend — from any Apple device.
$ /plugin install imessage@claude-plugins-official
What it does
Claude Code becomes a contact in your Messages app. Send it tasks, get responses as iMessages. Works from your iPhone, iPad, or Mac — no terminal needed. Pairs well with remote control sessions for kicking off work from anywhere.
Claude Code now has a built-in memory system. Run /memory
to configure it.
$ /memory
$ /dream
Auto-memory
When enabled, Claude automatically saves preferences, corrections, and patterns between sessions. No manual CLAUDE.md editing needed — Claude writes the memories for you.
Auto-dream
As memory accumulates, it can get messy — outdated assumptions, overlapping notes, low-signal entries. Auto-dream runs a subagent that periodically reviews past sessions, keeps what matters, removes what doesn't, and merges insights into cleaner structured memory. The naming maps to how REM sleep consolidates short-term memory into long-term storage.
Boris's favorite hidden and under-utilized features in Claude Code. Mobile app, session teleporting, /loop and /schedule, hooks, Cowork Dispatch, Chrome extension, Desktop app, /branch, /btw, worktrees, /batch, --bare, --add-dir, --agent, and /voice.
Did you know Claude Code has a mobile app? Boris writes a lot of his code from the iOS app. It's a convenient way to make changes without opening a laptop.
How to use it
Download the Claude app for iOS/Android, then tap the Code tab on the left. You get a full Claude Code session right from your phone.
Move sessions back and forth between mobile/web/desktop and terminal.
$ claude --teleport
$ /teleport
$ /remote-control
Boris's setup
"I have 'Enable Remote Control for all sessions' set in my /config."
Two of the most powerful features in Claude Code. Use these to schedule Claude to run automatically at a set interval, for up to a week at a time.
$ /loop 5m /babysit
$ /loop 30m /slack-feedback
$ /loop /post-merge-sweeper
$ /loop 1h /pr-pruner
Pro tip
Experiment with turning workflows into skills + loops. It's powerful.
Use hooks to deterministically run logic as part of the agent lifecycle.
Examples
Dynamically load in context each time you start Claude (SessionStart)
Log every bash command the model runs (PreToolUse)
Route permission prompts to WhatsApp for you to approve/deny (PermissionRequest)
Poke Claude to keep going whenever it stops (Stop)
See code.claude.com/docs/en/hooks
Boris uses Dispatch every day to catch up on Slack and emails, manage files, and do things on his laptop when he's not at a computer.
"When I'm not coding, I'm dispatching."
What it is
Dispatch is a secure remote control for the Claude Desktop app. It can use your MCPs, browser, and computer, with your permission.
The most important tip for using Claude Code is: give Claude a way to verify its output. Once you do that, Claude will iterate until the result is great.
Think of it like any other engineer: if you ask someone to build a website but they aren't allowed to use a browser, will the result look good? Probably not. But if you give them a browser, they will write code and iterate until it looks good.
Boris's workflow
"I use the Chrome extension every time I work on web code. It tends to work more reliably than other similar MCPs."
Download the extension for Chrome/Edge.
Better than Playwright or Chromium MCP for E2E
Asked directly whether Claude in Chrome beats Playwright or a Chromium MCP for end-to-end tests, Boris: "Yes. It's more powerful and more token-efficient." The way he wires it into a long autonomous run is to hand verification to a workflow:
> use a workflow to test the result e2e in a browser using
claude in chrome mcp. Especially look for edge cases and ui issues
From Boris's June 2026 "running Opus autonomously" thread →
Use the Claude Desktop app to have Claude automatically start and test web servers.
What it does
The Desktop app bundles in the ability for Claude to automatically run your web server and even test it in a built-in browser. You can set up something similar in CLI or VSCode using the Chrome extension, or just use the Desktop app.
People often ask how to fork an existing session. Two ways:
$ /branch
$ claude --resume <session-id> --fork-session
What happens
Claude creates a branched conversation. You're now in the branch. To resume the original, use the session ID it gives you.
Boris uses this all the time to answer quick questions while the agent works.
> /btw how do i spell daushund?
dachshund — German for "badger dog"
(dachs = badger, hund = dog).
How it works
Single-turn, no tool calls, but has full context of the conversation. Claude responds inline without stopping its work.
Claude Code ships with deep support for git worktrees. Worktrees are essential for doing lots of parallel work in the same repository. Boris has dozens of Claudes running at all times.
$ claude -w
Non-git VCS
For non-git VCS users, use the WorktreeCreate hook to add your own logic for worktree creation.
/batch
interviews you, then has Claude fan out the work to as many worktree agents as it takes (dozens, hundreds, even thousands) to get it done.
Use cases
Use it for large code migrations and other kinds of parallelizable work. Each agent runs in its own worktree with full isolation.
By default, when you run claude -p
(or the TypeScript or Python SDKs) it searches for local CLAUDE.md's, settings, and MCPs. But for non-interactive usage, most of the time you want to explicitly specify what to load.
$ claude -p "summarize this codebase" \
--output-format=stream-json \
--verbose \
--bare
Why it matters
This was a design oversight when the SDK was first built. In a future version, the default will flip to --bare. For now, opt in with the flag to get up to 10x faster startup.
When working across multiple repositories, Boris usually starts Claude in one repo and uses --add-dir
(or /add-dir
) to let Claude see the other repo. This tells Claude about the repo and gives it permissions to work in it.
$ claude --add-dir /path/to/other-repo
> /add-dir /path/to/other-repo
Team setup
Add "additionalDirectories" to your team's settings.json to always load in additional folders when starting Claude Code.
Custom agents are a powerful primitive that often gets overlooked.
$ cat .claude/agents/ReadOnly.md
---
name: ReadOnly
description: Read-only agent restricted to the Read tool only
color: blue
tools: Read
---
You are a read-only agent that cannot edit files or run bash.
$ claude --agent=ReadOnly
How it works
Define a new agent in .claude/agents, then run claude --agent=<your agent's name>. Each agent can have a custom name, color, tool set, and system prompt.
Fun fact: Boris does most of his coding by speaking to Claude, rather than typing.
How to use it
CLI: Run /voice then hold the space bar
Desktop: Press the voice button
iOS: Enable dictation in your iOS settings
Fresh out of Anthropic this week. Routines — schedule Claude Code runs or trigger them from GitHub events. Three session management tips from Thariq on the 1M context window: /rewind over correcting, /compact vs /clear, and a one-line env var to dodge context rot. Plus three from Cat on using Opus 4.7: delegate, full-context briefs, and the new xhigh effort level.
Claude announced Routines in Claude Code — research preview, Apr 14 2026. Configure a routine once (prompt, repo, connectors), and it runs on a schedule, from an API call, or in response to a GitHub event. Runs on Anthropic infra — no laptop needed.
Triggers
Schedule — cron expression
GitHub event — PR opened/merged, release published, issue opened
API — POST to a webhook URL with token
Connectors
GitHub, Linear — extend with your own. Each routine has its own API endpoint, so you can point alerts, deploy hooks, or internal tools at Claude directly.
Example use case: POST an alert payload to the routine's webhook. Claude finds the owning service and posts a triage summary to #oncall.
From Thariq (Apr 15, 2026): the single habit that signals good context management is rewind, not correction.
When Claude goes down a wrong path, don't type "that didn't work, try X instead." That keeps the failed attempt in your context and pollutes the window. Instead, rewind and re-prompt with what you learned.
$ /rewind
The math
Correcting: context = file reads + failed attempt + correction + fix.
Rewinding: context = file reads + one informed prompt + fix.
You can also use "summarize from here"
to have Claude summarize its learnings into a handoff message before rewinding — a message from the next iteration of Claude to its past self.
Two ways to shed weight from a long session. They feel similar but behave very differently.
/compact — lossy LLM summary
Claude summarizes the conversation and replaces the history with that summary. Cheap, keeps momentum, details can be fuzzy. You're trusting Claude to decide what mattered.
$ /compact focus on the auth refactor, drop the test debugging
/clear — hand-written brief
You write down what matters ("we're refactoring the auth middleware, constraint is X, files are A and B, we've ruled out approach Y") and start clean. More work, but the context is exactly what you decided.
Rule of thumb: starting a genuinely new task → new session with /clear
. Related task where you still need some context → /compact
with a hint.
Context rot — model performance degrading as context grows — kicks in around 300-400k tokens on the 1M context model. You can set your autocompact threshold to force earlier compaction and effectively lower your context window.
$ CLAUDE_CODE_AUTO_COMPACT_WINDOW=400000 claude
Why this works
Stays below the rot zone while still getting most of the 1M benefit. Context windows are a hard cutoff — when you near the end, you're forced to compact. Forcing it earlier means your compaction happens while the model is still sharp.
Pair with proactive /compact <hint>
when you feel bad-compact risk (autocompact fires mid-task and summarizes the wrong things).
Docs: Claude Code settings
From Cat Wu (Apr 16, 2026) on Opus 4.7 in Claude Code: "The model performs best if you treat it like an engineer you're delegating to, not a pair programmer you're guiding line by line."
This is a mental model shift. The old workflow: describe a step, watch the output, correct, describe the next step. High interrupt frequency, you're always in the loop.
The new workflow
Write a crisp brief. Launch Claude. Come back when it's done — or when it asks a real question. Fewer interruptions, more autonomous runs, higher quality output.
When Claude asks too many clarifying questions or goes off-track, that's usually a signal that your brief was incomplete — not that the model needs more hand-holding. Invest in the upfront brief (see next tip) and let Opus 4.7 do its thing.
The delegation model from Tip 5 only works if Claude has what it needs. Cat's second tip: "Give Claude Code your full task context upfront: goal, constraints, acceptance criteria in the first turn."
The three things to include
Goal — what success looks like in plain language
Constraints — non-goals, things not to touch, perf/API contracts
Acceptance criteria — how you'll verify the work is done right
Goal: add rate limiting to the /api/login endpoint
Constraints:
- don't modify the DB schema
- keep the existing auth flow unchanged
- use Redis (already configured)
Acceptance criteria:
- 5 req/min per IP, returns 429 on limit
- existing tests still pass
- new test case for the rate-limit behavior
If Claude starts with all three, it plans around the full problem space. If it starts with just "add rate limiting," it'll make assumptions you'll have to correct later — and every correction costs context.
Opus 4.7 in Claude Code defaults to xhigh
— a new effort level beyond the low/medium/high/max scale Tip 34 described. The model reasons longer before acting, which pairs with the delegation shift: think harder once, rather than iterate fast and bounce back to you.
$ /effort
Why xhigh is the new default
xhigh effort + a full-context brief = one-shot completion of bigger tasks than previous Opus models could handle. The default change signals that Opus 4.7 is expected to run more autonomously, which benefits from more reasoning tokens upfront.
Drop it down if you want speed over depth, or leave it alone for most work. Available through /effort
just like the other levels.
Boris dogfooded Opus 4.7 for weeks before launch. His verdict: "It feels more intelligent, agentic, and precise than 4.6. It took a few days for me to learn how to work with it effectively." Here's what he learned — plus key behavioral shifts from the Anthropic blog. Auto mode, /fewer-permission-prompts, recaps, /focus, effort mastery, the /go composite skill, and what changed under the hood.
Opus 4.7 loves complex, long-running tasks — deep research, refactoring code, building complex features, iterating until it hits a performance benchmark. In the past, you either had to babysit the model or use --dangerously-skip-permissions
.
Auto mode changes the game
Permission prompts are routed to a model-based classifier. If it's safe, it's auto-approved. No more babysitting while the model runs. More than that — it means you can run more Claudes in parallel. Once a Claude is cooking, switch focus to the next one.
Shift-tab to enter auto mode in the CLI, or choose it in the dropdown in Desktop or VSCode. Available for Max, Teams, and Enterprise.
A new skill that scans through your session history to find common bash and MCP commands that are safe but caused repeated permission prompts.
$ /fewer-permission-prompts
What it does
Recommends a list of commands to add to your permissions allowlist. Use it to tune up your permissions and avoid unnecessary prompts — especially useful if you don't use auto mode.
Shipped alongside Opus 4.7. Recaps are short summaries of what an agent did and what's next. Useful when returning to a long-running session after a few minutes or a few hours.
✻ Cogitated for 6m 27s
✻ recap: Fixing the post-submit transcript
shift bug. The styling-flash part is shipped
as PR #29869 (auto-merge on, posted to stamps).
Next: I need a screen recording of the remaining
horizontal rewrap on `cc -c` to target that
separate cause. (disable recaps in /config)
Pairs naturally with auto mode — you launch Claude, switch focus, come back, and immediately see what happened and what's next without scrolling through tool output. Disable in /config
if you prefer the old behavior.
Boris: "I've been loving the new focus mode in the CLI, which hides all the intermediate work to just focus on the final result. The model has reached a point where I generally trust it to run the right commands and make the right edits. I just look at the final result."
$ /focus
When to use it
When you trust the model enough that watching every file read and bash command is noise. Focus mode shows you what changed, not how it got there. A natural complement to auto mode — one removes permission prompts, the other removes visual clutter.
Opus 4.7 uses adaptive thinking instead of fixed thinking budgets. The model decides when thinking is beneficial rather than using a fixed allocation — less overthinking, smarter resource use.
Boris's setup
"I use xhigh effort for most tasks, and max effort for the hardest tasks."
$ /effort
Key detail most people miss
Max applies to just your current session. All other effort levels (including xhigh) are sticky and persist for your next session too. This means you can safely crank to max for one hard debugging session without permanently changing your default.
To steer thinking without changing effort: say "Think carefully and step-by-step before responding" for harder problems, or "Prioritize responding quickly rather than thinking deeply" to save tokens on simple tasks.
"Give Claude a way to verify its work. This has always been a way to 2-3x what you get out of Claude, and with 4.7 it's more important than ever."
Boris's workflow these days: "Many of my prompts look like 'Claude do blah blah /go'."
/go is a skill that has Claude:
Test itself end to end using bash, browser, or computer use
Run the /simplify skill
Put up a PR
Verification by domain: backend → make sure Claude knows how to start your server/service to test end to end. Frontend → use the Claude Chromium extension. Mobile → use the iOS/Android simulator MCP. Desktop apps → use computer use.
Scripted or Claude-driven tests?
Asked whether tests should be scripted (guaranteed but flaky) or Claude-driven, Boris: "We do both! Depends if it's a one-off or something you want to run on future PRs." One-off check → let Claude drive it. Something you want to re-run on every PR → have it write a real test.
"For long running work, verification is important because that way when you come back to a task, you know the code works."
If you're upgrading from 4.6, three behavioral changes matter. Don't assume your old habits carry over — Opus 4.7 thinks differently.
1. Calibrated response length
Shorter answers for simple queries, longer for open-ended analysis. If you want a specific length or style, say so explicitly in your prompt.
2. Less automatic tool usage
4.7 reasons more instead of immediately calling tools. If Claude isn't reaching for the right tools, provide explicit guidance describing when and why to use them.
3. More judicious subagent spawning
4.7 is more selective about delegation. For tasks like "refactor across 40 files," explicitly request parallel subagents. Anti-pattern: don't ask it to spawn subagents for refactoring a single visible function.
Source: Anthropic blog post
With auto mode + focus mode, you're spending less time watching Claude work. But you need to know when it finishes. Set up notifications so you don't have to keep checking back.
Options
Sound alert — ask Claude to play a sound when it finishes a task
Stop hook — use a Stop hook to trigger a notification (Slack, system notification, etc.)
iTerm2 notifications — enable native terminal notifications
Recaps — when you do check back, recaps tell you what happened (tip 3)
The workflow that pulls this all together: start Claude in auto mode with focus on. It runs autonomously, verifies its own work via /go
, and notifies you when done. You review the recap and the PR. The future Boris described in Part 1 is here.
Source: Anthropic blog post
Two Claude Code features surfaced this week. Agent view (launched May 11) is a native control plane for managing many concurrent sessions: run claude agents
from a root code directory and see every session grouped by what needs your input, what's still working, and what's done. /goal (highlighted by ClaudeDevs on May 12, described as recently shipped) keeps a single session working until a completion condition is met: /goal all tests in test/auth pass and the lint step is clean
, and Claude won't stop until it's true. Two halves of the same story. Run more agents, and make each one finish what it started.
Boris: "The best way to level up from 1 agent => many agents. No more cycling between terminal tabs." Thariq's description: "kind of like tmux built for CC" — a native control plane for concurrent Claude Code sessions.
How to run it
Cat Wu and Thariq both recommend running it from a single high-level directory containing all your repos (Thariq uses ~/Projects). Every session launched under that root gets tracked.
bash
$ claude agents
What you see
Sessions are grouped by status — needs input, working, completed. Each row shows the session name and a short description of what it's doing. Switch focus into one, answer its question, come back to the view.
Operational tips from Dickson Tsai
Two practical details: new sessions inherit the directory your cursor is on (so starting a session in the right repo is one keystroke), and renaming is critical for keeping the view scannable as sessions pile up. Use /rename or set up a UserPromptSubmit hook to auto-rename.
This is the productized version of Part 1, Tip 1 — Boris's original "spin up 3-5 worktrees" pattern, but with a first-class control plane instead of manual terminal tabs and za
/zb
/zc
aliases.
Research preview. The Claude Code team is actively reading feedback — Thariq: "let me know if you have any feedback! we will read all of it and action."
Surfaced in a May 12 ClaudeDevs thread, described as "shipped recently" — exact ship date isn't in the post and would need the changelog to confirm. /goal
sets a completion condition. Claude keeps working until the condition is true; every time it tries to stop, the model checks the condition against the transcript. Not done, it keeps going. Done, you get a "Goal achieved" summary.
$ /goal all tests in test/auth pass and the lint step is clean
How it works
ClaudeDevs calls this the Ralph loop, built into Claude Code. Each stop attempt is intercepted; the model self-checks against your condition before exiting. The loop only breaks when the condition is satisfied.
Companion tools
/loop runs Claude on repeat. Good for iterative refactors, cleanups, or burning down a backlog.
/schedule kicks off Claude on a cadence. Nightly test runs, morning triage, weekly cleanup.
A Stop hook gives programmatic control over when Claude can finish. Run your test suite, hit a CI endpoint, gate on anything.
Auto mode lets Claude work uninterrupted without permission prompts. Enable with shift+tab in the CLI or via the mode selector on desktop.
The pairing with Part 12 Tip 1 is the launch story: agent view lets you run many sessions at once; /goal
makes each session finish what it started. Boris's worktrees pattern (Part 1, Tip 1) plus auto mode (Tip 68) plus /goal
approximates an autonomous fleet that doesn't need babysitting.
A non-test use of /goal: make Claude teach you
Thariq (@trq212) shared a prompt from Suzanne at Anthropic that points /goal at your understanding instead of a test suite. Claude becomes a tutor: it keeps a running checklist of what you should grasp — the problem and why it existed, the solution and its design decisions, the broader impact — has you restate your understanding, fills the gaps (ask for eli5 / eli14 / "explain like I'm an intern"), then quizzes you with AskUserQuestion (shuffled answers, no peeking). The last line is the enforcement:
$ /goal the session should not end until you've verified
that the human has demonstrated they understood
everything on your list.
Same Ralph-loop mechanism — but the exit condition is comprehension, not a green build. A good companion to Part 2's "Learning with Claude" (Tip 10).
Anthropic shipped Claude Opus 4.8 — Boris calls it "our strongest coding model yet". SWE-Bench Pro jumps from 64.3 to 69.2, but the bigger shift is honesty: the model tells you when it's unsure and catches its own bugs instead of declaring victory early. Same price as 4.7. Alongside the model: a new high-effort default (with xhigh
for hard problems and raised Claude Code rate limits to cover the extra tokens) and dynamic workflows — a research preview that runs hundreds of parallel subagents in a single session for tasks too big for one pass. Cat Wu surfaced the activation trigger: mention "workflow" in your prompt and Claude builds the orchestration plan automatically.
Boris's framing: "up on SWE-bench Pro (from 64.3 to 69.2) and noticeably more honest about its own work. It tells you when it's unsure and catches its own bugs instead of declaring victory early." Same price as 4.7. Live on claude.ai, the Claude Platform, and all major cloud platforms.
Benchmark deltas vs 4.7
Agentic coding (SWE-Bench Pro): 64.3% → 69.2%
Agentic terminal coding (Terminal-Bench 2.1): 66.1% → 74.6%
Multidisciplinary reasoning (Humanity's Last Exam, with tools): 54.7% → 57.9%
Agentic computer use (OSWorld-Verified): 82.8% → 83.4%
Knowledge work (GDPval-AA): 1753 → 1890
Agentic financial analysis (Finance Agent v2): 51.5% → 53.9%
The honesty shift matters more than the benchmarks
The behavioral change Boris calls out — catching its own bugs, flagging uncertainty — is exactly the failure mode that breaks long-running agents. A model that overclaims at step 4 wastes the next 40 steps. Pair this with /goal from Part 12 and dynamic workflows below: honesty is what makes async work actually finish.
Also shipped today
Fast mode for Opus 4.8 (research preview): same model at roughly 2.5x the speed, 3x cheaper than before. Toggle with /fast in Claude Code. A new effort control on claude.ai lets you choose how much thinking Claude puts into each response — the consumer surface catching up to what Claude Code users already had.
Boris: "4.8 defaults to high effort, which spends about the same tokens as 4.7's default on coding but performs better." The default change isn't a tax — it's the same token budget, used smarter. For hard problems and long-running async work, switch to xhigh
. To make that economical, Anthropic raised Claude Code rate limits to cover the extra tokens.
$ /effort high
$ /effort xhigh
Carry-over from Part 11
Part 11 introduced xhigh as Opus 4.7's new top tier (Tip 5: Effort Mastery). With 4.8, the default moved up — what used to be a deliberate choice is now baseline. Mental model: assume more reasoning per turn, and reach for xhigh when you'd previously have reached for "let it think longer."
When the extra tokens pay off
Boris ties xhigh directly to dynamic workflows (next tab) and long-running async runs. Short conversational tasks don't need it — the default is already higher than 4.7's. Save xhigh for jobs where you're not watching the screen.
Research preview, shipped today. Boris: "for tasks too big for one pass. Make sure to default to auto mode so Claude isn't stopping for permissions." Per the launch post, Claude runs hundreds of parallel subagents in a single session and verifies its work before reporting back.
How to invoke it
Cat Wu: "Mention 'workflow' in a prompt and Claude will dynamically create an orchestration plan that it strictly follows, allowing you to confidently trust that every stage happens in the right order even across 100s of agents." Claude takes a request for a workflow as a signal to plan and execute as a dynamic workflow rather than a single run. No new command, no flag. Update (June 9, 2026): Boris refined the trigger to the phrase "use a workflow" — bare "workflow" had too many false positives (see Part 16).
Under the hood — the orchestrator pattern
A dynamic workflow is an orchestrator shape, not peer-to-peer "agent teams." A top-level claude kicks off N tasks (N can be in the 100s). Each task fans out: implementer writes, branches into two verifiers, both verifiers feed into a single fixer. Each task's loop runs until its verifiers pass; the orchestrator returns only once every branch completes.
Diagram from Cat Wu's May 28 thread.
A concrete example
Cat: "Recently, I used dynamic workflows to catalogue all of our 100s of A/B test flags and find the ones rolled out to 0% or 100% so that we can quickly deprecate the stale ones. Instead of waiting for Claude Code to investigate each sequentially, dynamic workflows allowed Claude to process all of them in parallel in <10 minutes." The sweet spot: large fan-out across independent items where each needs the same investigation loop.
Save it for your biggest jobs
Boris's explicit list plus the category Cat's example highlights:
Migrations
Refactors
Perf optimization
Batch bug fixes
Catalogue-and-categorize sweeps (A/B flags, feature toggles, dependencies, dead code, stale endpoints)
It's token-intensive. Don't burn it on a 20-line tweak — that's what default mode and the new high-effort baseline are already for.
Auto mode is not optional
With hundreds of parallel subagents, a single permission prompt freezes the run. Boris: "default to auto mode so Claude isn't stopping for permissions." Shift+tab into auto mode in the CLI, or toggle it on the desktop app. The combo: auto mode + dynamic workflows + xhigh = Claude actually walking off and finishing.
The framing that matters
Boris: "Big migrations and refactors are some of a team's most important work, and the easiest to push off to a 'better time' since they'd tie up engineers for a quarter. With dynamic workflows, Claude can now land that kind of work in days or weeks." The pitch isn't speed for routine work — it's making the kind of work teams perpetually defer actually shippable.
This connects the arc from Part 11 (auto mode, effort mastery) through Part 12 (agent view, /goal
) into Part 13: the model is more honest about its progress (Tip 1), spends more reasoning by default (Tip 2), and now has a first-class execution mode for jobs that don't fit in one pass. The autonomous fleet from Part 12's intro — agent view + /goal
- worktrees — gets a fourth pillar.
Research preview. Expect the surface to change.
Part 13 announced dynamic workflows at launch. A week later, Thariq Shihipar and Sid Bidasaria — the engineers who built the feature — published the practitioner's guide: how workflows actually work, the patterns Claude composes, and where they pay off (often on non-coding work). "Claude can now write its own harness on the fly, custom-built for the task at hand." This is the how-to behind the launch note. Best practices are still developing, and workflows often use more tokens — so think about when to reach for one.
The default Claude Code harness plans and executes in one context window. For most coding tasks that's highly effective. It breaks down on the long-running, massively parallel, or adversarial tasks — and the longer Claude works in a single window, the more three specific failure modes creep in.
Agentic laziness
Claude stops before finishing a complex, multi-part task and declares it done after partial progress — addressing 20 of the 50 items in a security review and calling it complete.
Self-preferential bias
Claude tends to prefer its own results, especially when asked to verify or judge its work against a rubric. The grader and the author being the same context is the problem.
Goal drift
Gradual loss of fidelity to the original objective across many turns — worst after compaction. Each summarization step is lossy, and details like edge-case requirements or "don't do X" constraints quietly fall out.
The fix
A workflow orchestrates separate Claudes, each with its own context window and a focused, isolated goal. Laziness loses to a deterministic loop that doesn't exit until every item is handled; bias loses to a different agent doing the judging; drift loses because each agent holds one small goal that never gets summarized away. This connects straight to Part 13's honesty story — a model that overclaims at step 4 wastes the next 40 steps.
A dynamic workflow is a JavaScript file with a few special functions that spawn and coordinate subagents. Standard JSON
, Math
, and Array
are there too for processing data.
const bugs = await agent("audit auth.ts", {
schema: BugList, // JSON Schema → validated output
model: "haiku", // opus · sonnet · haiku · omit = inherit
isolation: "worktree", // own checkout, for parallel edits
agentType: "reviewer", // custom / built-in subagent
})
Compose the block
parallel([ fns ]) — fan out, run at once. A barrier: it waits for all of them, then you have every result together.
pipeline(items, ...stages) — each item streams through every stage independently. No barrier: item A can be in stage 3 while item B is still in stage 1.
Claude decides which model each agent uses and whether it runs in its own worktree — picking the intelligence level and isolation the step actually needs.
Resumable by default
Interrupt a workflow — quit the terminal, cancel mid-run — and resuming the session picks up where it left off. The deterministic harness remembers what already completed.
Dynamic vs static
You may have built static workflows before with the Agent SDK or claude -p. Because a static workflow has to handle every edge case, it ends up generic: "turn this into 5 web searches → fetch → verify → summarize → a generic report." With Opus 4.8, Claude is smart enough to write a custom harness tailor-made for your case: "read our billing code → check each feature against the new provider's docs → devil's advocate the strongest case against migrating → a specific recommendation."
Building a mental model for these helps you nudge Claude via prompts. They're not exclusive — Claude mixes and nests them.
1 · Classify-and-act
A classifier agent decides the type of task, then routes to different agents or behavior. Or classify at the end to shape the output.
2 · Fan-out-and-synthesize
Split into many smaller steps, run an agent on each, then synthesize. The synthesize step is a barrier — it waits for all the fan-out agents, then merges their structured outputs into one result. Best when each step benefits from its own clean context so they don't cross-contaminate.
3 · Adversarial verification
For each spawned agent, run a separate agent to adversarially verify its output against a rubric. The verifier is never the author — that's what kills self-preferential bias.
4 · Generate-and-filter
Generate many ideas on a topic, then filter by a rubric or by verification, dedupe, and return only the highest-quality, tested few.
5 · Tournament
Instead of dividing work, have agents compete. Spawn N agents that each attempt the same task a different way, then judge them pairwise until you have a winner. Comparative judgment is more reliable than absolute scoring.
6 · Loop-until-done
For an unknown amount of work, keep spawning agents until a stop condition is met — no new findings, no more errors in the logs — instead of a fixed number of passes. Simple counters miss the tail.
Thariq: "I've found that workflows are sometimes even more useful for non-technical work." A sampling from the article:
Migrations & refactors
Bun was rewritten from Zig to Rust using workflows. Break the task into units — callsites, failing tests, modules — spin off a subagent for each fix in its own worktree, have another agent adversarially review, then merge. Tell agents to avoid resource-intensive commands so you can maximally parallelize without melting your machine.
Deep research & deep verification
The /deep-research skill is itself a workflow: fan out web searches, fetch sources, adversarially verify their claims, synthesize a cited report. The inverse is deep verification — one agent extracts every factual claim from a report, a subagent checks each in detail, and an optional source-auditor agent confirms the source is high quality. "Verify every technical claim in my blog draft against the codebase — I don't want to ship anything wrong."
Sorting 1,000+ items
You can't sort 1,000 rows by a qualitative measure in one prompt — quality degrades and it won't fit in context. Run a tournament, a pipeline of pairwise-comparison agents (comparative judgment beats absolute scoring), or bucket-rank in parallel then merge. Each comparison is its own agent; the deterministic loop holds the bracket so only the running order stays in context.
Memory & rule adherence
For rules Claude keeps missing even in CLAUDE.md: one verifier agent per rule, plus a skeptic persona that reviews the rules to avoid false positives. The reverse direction works too — mine your recent sessions and code-review comments for corrections you keep making, cluster them, adversarially verify each candidate ("would this rule have prevented a real mistake?"), and distill the survivors back into CLAUDE.md.
Root-cause investigation
Debugging works best with several independent hypotheses tested in parallel — but one context window invites self-preferential bias. A workflow spins up agents that generate hypotheses from disjoint evidence (logs, files, data), then each hypothesis faces a panel of verifiers and refuters. Works for sales ("why did sales drop in March?"), data engineering, any post-mortem.
Triage, taste, evals, routing
Triage at scale: classify each backlog item, dedupe against what's already tracked, then fix or escalate. Use a quarantine pattern — agents reading untrusted public content can't take high-privilege actions. Pair with /loop to run continuously.
Exploration & taste: for design or naming, give a review agent a rubric; the task is done when the rubric is met. Order options via tournament.
Evals: spin agents in worktrees, then comparison agents grade outputs against a rubric — handy for refining a skill you're building.
Model routing: a classifier researches the task, then routes to Sonnet or Opus based on expected complexity.
Workflows compose with the rest of Claude Code. Three levers worth knowing, plus the honest "when not to."
/goal + /loop
For repeatable workflows — triage, research, verification — pair with /loop to run at regular intervals and /goal to set a hard completion requirement. This is the Part 12 + Part 13 arc closing: /goal sets the exit condition, the workflow does the parallel work, /loop keeps it going.
Token budgets
Workflows are token-hungry, so cap them. Prompt a budget directly — "use 10k tokens" — and the workflow holds the ceiling.
$ Use a workflow to rank these 80 resumes for the backend
role and double-check the top ten. use 50k tokens
See what's burning tokens: /usage
When a long autonomous run eats your limits faster than expected, run /usage for a breakdown of the specific skills, MCPs, and plugins spending your tokens. Boris points people here first when they hit limits mid-run — it's how you find the workflow or MCP that's quietly dominating the bill.
Quick workflows
They aren't only for big jobs. Prompt a "quick workflow" for something small — a fast adversarial review of a single assumption, for instance.
When not to use one
Workflows can use significantly more tokens and aren't needed for every task. Thariq: "For regular coding tasks, ask yourself: does it really need more compute? Most traditional coding tasks do not need a panel of 5 reviewers." Use them to push Claude in ways you couldn't before — not as the default for a 20-line change.
A good workflow is reusable. Once Claude builds one you like, keep it.
Save it
Press "s" in the workflow menu to save. Check the files into ~/.claude/workflows, or distribute them via a skill.
Dynamic workflows
1 running · 2 completed
⟩ ✓ review-changes · 14 agents · 482k tok · 6m 12s
◴ find-flaky-tests · 6 agents · 121k tok · 1m 48s
✓ deep-research · 22 agents · 1.1M tok · 11m 3s
↑/↓ select · enter view · s save · esc close
Share via a skill
Put your JavaScript workflow files in the skill folder and reference them in the SKILL.md. For flexibility, prompt Claude to treat the workflows in a skill as a template, not a script to run verbatim — so it adapts the harness to the specific case instead of replaying it blindly.
The "ultracode" trigger
You can start a workflow just by asking for one — or use the trigger word "ultracode" to guarantee Claude Code builds a workflow rather than running a single pass.
This is the fourth pillar settling into place: Part 11's auto mode, Part 12's agent view + /goal
, Part 13's Opus 4.8 + the workflow launch, and now the patterns to drive them. Thariq's closing line is the honest one — "there's still much to discover in how to use them best."
Research preview. Best practices are still developing.
One year after Claude Code went GA, Boris Cherny (Head of Claude Code) and Cat Wu (Head of Product) sat down to talk about what changed — "from a Slack demo that got two reactions to engineering teams deploying it across entire codebases." Four ideas stood out, and a couple quietly overturned earlier advice on this very site: why Boris dropped plan mode, the shift to context minimalism, the one habit that lets Claude run for hours, and why auto mode is safer than reading every prompt.
For over a year, plan mode was Boris's go-to for synchronous coding. A year after GA, he's moved on — and the reason is the model, not the feature.
In his words
"What it used to be is plan mode. I don't use that anymore. I use auto mode — instead of plan mode. The newer models don't actually need a planning step. It was really important for Opus 4 through 4.5, but starting with 4.6, and definitely with 4.7, it just doesn't need it."
Why it changed
Older models needed an explicit plan to stay on track. 4.6+ plan implicitly, so the planning step became overhead — an artifact to review before any work starts.
js
What he does instead
Start Claude in auto mode, let it work, move to the next Claude. No babysitting. Some people keep plan mode for the written artifact, and that's fine — Boris just runs auto mode for everything.
Updates Part 1
This revises the plan-mode tip from Part 1. The rule of thumb shifted with the model: pre-4.6, plan first; 4.6 and later, let it run. Pairs with the auto mode tips in Parts 8 and 11.
"From context engineering to context minimalism" is its own chapter in the interview. The era you're in tracks the model you're using.
The progression
Sonnet 3.5 was the era of prompt engineering. Opus 4 was the era of context engineering. Today's models need neither.
Boris
"You give it the minimal possible system prompt, the minimal possible tools, and then you let the model figure it out. You just have to give the model some way to pull in the context."
Cat
"I'm a context minimalist. Tell the model only what it needs to know and let it figure out the rest. When you give the model too much context, it's like you're micromanaging it — and sometimes the model knows a better way to get to the same outcome."
The move
Stop front- giant prompts and tool lists. Give a lean brief plus a way to fetch context — files, search, MCP — then get out of the way. Minimal ≠ vague: give the goal, not the micro-steps. Pairs with Part 10's "delegation over guidance."
Boris calls this the single most important idea for long-running work — and it's the whole reason his agents can run for hours.
In his words
"Every single time Claude makes a mistake, I don't tell it to do it differently. I tell it to write it to the CLAUDE.md, or make a skill, or something. If you can do this, then Claude can just run forever."
The distinction
Correcting Claude in chat fixes this one run. Writing the fix into CLAUDE.md or a skill fixes every future run. A conversational correction is a patch; a written rule is a fix.
Why it compounds
The error rate trends down over time instead of resetting each session. The rule set grows; the mistakes don't come back. When something goes wrong, your next instruction isn't "do it this way" — it's "add a rule so this doesn't happen again."
Pairs with Part 1's CLAUDE.md and Skills tips, and Part 10's /rewind
over correcting.
Auto mode routes each action to a classifier instead of asking you to approve every prompt. The interview explains why you can trust it — and why it's arguably safer than reading every prompt yourself.
How it was hardened
The team collected thousands of full agent transcripts plus the permission prompt, had auto mode classify each as safe or unsafe, then brought in red-teamers to prompt-inject and attack the codebase. Those attacks became evals; auto mode was tuned until it caught them all.
The counterintuitive part
"When you accept 99% of requests, your eyes glaze over. Auto mode is more safe than reading every single permission prompt because it means you're only paying attention to the most important thing."
js
The payoff
Because he trusts it, he can let one agent run and start a second. Trust is what makes parallel, autonomous work possible — it protects against today's known vulnerabilities and the most intelligent attacks the team can construct. Pairs with the auto mode tips in Parts 8 and 11.
A June 9 ship: nested subagent support — "agents kicking off agents as a way to better manage context," capped at depth=5 to start. Plus an experimental fork: true
skill frontmatter, and a correction to how you trigger a dynamic workflow (it's "use a workflow" now, not bare "workflow"). Three quick ones, straight from Boris's thread.
Boris: "Just landed nested subagent support in Claude Code. Starting to experiment more with agents kicking off agents as a way to better manage context. Capped at depth=5 to start."
What it is
A subagent can now spawn its own subagents, down to depth=5 (a starting cap). Nesting is a context-management tool — each layer keeps its own context window, so deep work doesn't bloat the parent.
Monitor them
To watch what each subagent is doing, hit arrow-down in the terminal. (Asked how to see them, Boris: "In terminal? Hit arrow down.")
Model propagates, thinking weights don't (yet)
Dispatched subagents can run on a chosen model; per a user's testing that Boris confirmed, the model carries through but thinking weights do not propagate yet. Nesting also works with forked sessions and subagents can use Chrome.
Where a dynamic workflow (Parts 13–14) is an orchestrated harness, nested subagents are the lower-level primitive — any agent can delegate to keep its own context clean. Pairs with Part 1's subagents + worktrees and Part 12's agent view.
An idea Boris shared in the same thread, framed explicitly as "one idea I'm experimenting with" — so treat it as a preview, not a stable API.
The mechanic
Add fork: true to a skill's frontmatter so the skill runs in its own context window, then have the skill use agents to keep context isolated per step.
--- skill frontmatter ---
name: my-skill
fork: true
In his words
"add 'fork:true' to a skill's frontmatter to have it run in its own context window, then in the skill tell it to use agents to keep context isolated for each step also. Adding this to the built in /code-review skill to improve performance even more."
Why
A heavy skill (deep research, code review) can pollute or blow out the main context. Forking gives it a clean window; per-step agents (tip 1) isolate further. Same instinct as Part 15's context minimalism — keep each unit of work to the smallest context it needs.
A correction to the activation trigger from Part 13 and Part 14. The launch said the bare word "workflow" in a prompt was the trigger. Boris has refined it:
In his words
"Say 'use a workflow'. Just 'workflow' had too many false positives."
Do this
To launch a dynamic workflow, say "use a workflow" — e.g. "use a workflow to rank these 80 resumes" — not just the word "workflow."
Updates Parts 13 & 14
The workflow mechanics in Parts 13–14 are unchanged — orchestrator → implementer → verifiers → fixer, hundreds of agents, default to auto mode. Only the trigger phrasing tightened.
Anthropic launched Claude Fable 5 — a "Mythos-class model we've made safe for general use," whose "capabilities exceed those of any model we've ever made generally available." Now in Claude Code and Cowork. Boris: "the best model I have used for coding, by a wide margin… a big step up." Anthropic published a full benchmark table too — Fable 5 is state-of-the-art on nearly all of them. It's priced at $10/M in · $50/M out — double Opus 4.8. Fable-specific effort/usage tactics are still emerging.
The announcement from Claude: "Introducing Claude Fable 5: a Mythos-class model that we've made safe for general use. Its capabilities exceed those of any model we've ever made generally available." Available now in Claude Code and Cowork.
Boris's verdict
"Fable is the best model I have used for coding, by a wide margin. It is a big step up, enabling less prompts and steers, more efficient token use, better code quality, better tool use, more intelligent self-verification, longer running sessions, and higher trust & autonomy."
"Big model smell" — Boris on living with it
"With Fable, it's felt like Claude has stepped up from being a coding agent to a thought and design partner… Fable has judgement, taste, and dimensionality in a way that previous models didn't. The first time I had this realization was when I asked Fable to debug something — it's the first model I've used that was so methodical and precise, taking measurements and adding logs then verifying that it truly fixed the issue before declaring victory. There's nothing in Claude Code's prompting telling it to do that; it's just part of its personality. It really has this 'big model smell.'" That self-verifying debugging is the Verification (Part 1) + Opus 4.8 honesty (Part 13) thread paying off in the base model. Boris on living with Fable 5
The step-ups, at a glance
The benchmarks (Fable 5 → Opus 4.8 → GPT 5.5 → Gemini 3.1 Pro)
Claude: "state-of-the-art on nearly all tested benchmarks… the longer and more complex the task, the larger Fable 5's lead."
Agentic coding, SWE-Bench Pro: 80.3% → 69.2 → 58.6 → 54.2
Frontier coding, FrontierCode/Diamond (xhigh): 29.3% → 13.4 → 5.7 → —
Knowledge work, GDPval-AA: 1932 → 1890 → 1769 → 1314
Spatial reasoning, Blueprint-Bench 2: 38.6% → 14.5 → 36.2 → 26.5
Computer use, OSWorld-Verified: 85.0% → 83.4 → 78.7 → 76.2
Accuracy note: "Fable 5" is the Mythos-class model made safe for general use; the table reports the higher of Mythos 5 / Fable 5 (within 1–3 pts). On the starred benchmarks (cybersecurity, biology, Terminal-Bench, Humanity's Last Exam, HealthBench), Fable 5 performs closer to Opus 4.8 due to safety fallbacks — so treat those higher figures as Mythos 5. Boris confirms the classifiers are currently "trigger-happy" (flagging ordinary debugging as cyber/bio) and the team is "working on improving it."
A second voice — Andrej Karpathy (now at Anthropic)
"It's SOTA on everything by a margin… qualitatively, a major-version-bump-deserving step change forward. You can give it a lot more ambitious tasks than what you're used to — the model 'gets it' and it will just go. It's never felt this tempting to stop looking at the code at all (but don't do this in prod!)." He adds the safeguards are "a little too trigger-happy for launch" — the same fallbacks behind the starred benchmarks above. Karpathy's take
Fable 5 supersedes Opus 4.8 as the strongest coding model — which shifts a couple of earlier tips and leans harder into others.
It's the new default for coding
Updates Part 1's "use Opus" tip and Part 13's "Opus 4.8, strongest yet." When you pick a model for coding, Fable 5 now leads.
"Less prompts and steers" → lean into minimalism + delegation
That's exactly the world Part 15's context minimalism and Part 10's delegation-over-guidance describe — give it the goal, not the micro-steps.
Longer sessions + higher autonomy → the autonomy stack pays off more
Auto mode (Parts 8, 11), /goal (Part 12), nested subagents (Part 16), and workflows (Parts 13–14) all benefit from a base model that self-verifies better and needs less babysitting.
Caveat
Pricing is live — $10/M input · $50/M output, exactly 2× Opus 4.8's $5/$25. Model id claude-fable-5; 1M context, 128K max output, adaptive thinking, knowledge cutoff Jan 2026; no fast mode yet. Fable-specific effort levels and usage best-practices aren't documented yet.
Anthropic runs hundreds of skills internally. Thariq cataloged what works, what doesn't, and how to think about building them. 9 skill types, 9 authoring tips, and distribution strategies from production use. We turned his post into a skill. Obviously.
Get the full guide available directly in Claude Code. Type /thariq-skills
anytime to surface it.
$ mkdir -p ~/.claude/skills/thariq-skills && curl -L -o ~/.claude/skills/thariq-skills/SKILL.md https://howborisusesclaudecode.com/api/install-thariq
copy
Covers all 9 skill types, authoring best practices, progressive disclosure patterns, distribution strategies, and the gotchas Anthropic discovered running hundreds of skills in production.
After cataloging all their skills, Anthropic noticed they cluster into recurring categories. The best skills fit cleanly into one.
Library & API Reference
Internal libs, CLIs, SDKs, gotchas
billing-lib · platform-cli
Product Verification
Drive the running product to verify
signup-driver · checkout
Data & Analysis
IDs, field names, query patterns
funnel-query · grafana
Business Automation
Multi-tool workflows → one command
standup · weekly-recap
Scaffolding & Templates
Framework-correct boilerplate
new-app · migration
Code Quality & Review
Adversarial review, style, testing
adversarial · hypothesis
CI/CD & Deployment
Commit, push, deploy safely
babysit-pr · deploy
Incident Runbooks
Symptom → investigation → report
oncall · log-correlator
Infrastructure Ops
Safety-gated cleanup & maintenance
orphans · cost-investigation
The best practices from running hundreds of skills in production.
Get all 107 tips available directly in Claude Code. Type /boris
anytime to surface these workflow patterns.
A skill is a knowledge file that lives on your machine. Once installed, Claude references it automatically when you ask about workflows — or on demand with /boris
.
npm install -g @anthropic-ai/claude-code
Run this command in your terminal to install globally:
$ mkdir -p ~/.claude/skills/boris && curl -L -o ~/.claude/skills/boris/SKILL.md https://howborisusesclaudecode.com/api/install
copy
This installs globally to ~/.claude/skills/
. For project-specific install, use .claude/skills/
instead.
Start a new Claude Code session and type:
> /boris
> How should I set up parallel Claude sessions?
You'll see the full tips document appear in your conversation. If you get "skill not found", verify the file exists: ls ~/.claude/skills/boris/SKILL.md
107 Tips Organized by Topic
Parallel Execution - Worktrees, multiple sessions, web/mobile
Model Selection - Why Opus 4.5 with thinking
Plan Mode - Start complex tasks right
CLAUDE.md - Best practices, @.claude in PRs
Skills & Commands - /simplify, /batch, /btw, custom workflows
Subagents - Common PR automations
Hooks - PostToolUse, SessionStart, PermissionRequest, Stop
Permissions - Pre-allow safe commands, wildcard syntax
MCP Integrations - Slack, BigQuery, Sentry
Prompting - Challenge Claude, write specs
Terminal Setup - Ghostty, /voice, /color, keybindings
Bug Fixing - Slack MCP, CI tests, docker logs
Long-Running Tasks - Stop hooks, background agents
Verification - Chrome extension, browser testing
Learning - Use Claude to understand code
Customization - Themes, spinners, output styles
Plugins & Agents - LSPs, MCPs, --agent, custom agents
Safety - Sandboxing, auto mode, permissions
Worktrees - claude -w, Desktop, subagent isolation, non-git VCS
Scheduled Tasks - /loop, /schedule, automated workflows
Code Review - Agent-powered PR reviews that catch real bugs
/effort - Max reasoning mode for deeper thinking
Remote Control - Teleport, mobile app, /remote-control
Session Management - --name, /branch, --fork-session
Setup Scripts - Automate cloud environment setup
PostCompact Hook - React to context compression
iMessage Plugin - Text Claude from any Apple device
Auto-Memory & Dream - Persistent, self-cleaning memory
Mobile App - Write code from the Claude iOS/Android app
Cowork Dispatch - Remote control for Claude Desktop
Desktop App - Auto start and test web servers
--bare - 10x faster SDK startup
--add-dir - Give Claude access to more folders
Routines - Scheduled and event-driven Claude Code runs
Rewind - Double-Esc to drop failed attempts from context
/compact vs /clear - Know when to summarize vs start fresh
Auto-compact window - Env var to dodge context rot at 400k
Delegation over Guidance - Treat Opus 4.7 like an engineer you hand off to
Full Task Context Upfront - Goal, constraints, acceptance criteria in first turn
xhigh effort - New default reasoning level for Opus 4.7
Auto Mode + Parallel Claudes - Run multiple sessions, zero babysitting
/fewer-permission-prompts - Scan history, tune your allowlist
Recaps - Know what happened while you were away
Focus Mode - /focus to see only the final result
/go - Verify + simplify + PR in one composite skill
4.6→4.7 Shifts - Calibrated length, less auto-tool-use, judicious subagents
Notifications - Hooks and alerts for autonomous runs
Agent View - claude agents control plane — one list of all your sessions grouped by status
/goal - Set a completion condition; Claude keeps working until it's met (Ralph loop built into Claude Code)
Opus 4.8 - Strongest coding model yet: SWE-Bench Pro 64.3 → 69.2, more honest about its own work, catches bugs before declaring victory
High-Effort Default + xhigh - 4.8 defaults to high effort (same tokens as 4.7, better output); switch to xhigh for hard problems; Claude Code rate limits raised to cover
Dynamic Workflows - Research preview for tasks too big for one pass; say use a workflow to activate the orchestrator → implementer → verifiers → fixer pattern; save for migrations, refactors, perf, batch bug fixes, catalogue-and-categorize sweeps
Workflow Failure Modes - Why workflows exist: agentic laziness, self-preferential bias, goal drift
Workflow Primitives - agent, parallel, pipeline, schema/model/isolation; dynamic vs static harnesses
Six Workflow Patterns - Classify-and-act, fan-out-and-synthesize, adversarial verification, generate-and-filter, tournament, loop-until-done
Workflow Use Cases - Bun's Zig→Rust rewrite, deep research/verification, sorting 1000+ items, rule adherence, root-cause, triage
Workflow Budgets - Cap tokens ("use 10k tokens"), pair with /goal and /loop, quick workflows, when not to use one
Saving & Sharing Workflows - Press "s" to save, check into ~/.claude/workflows, distribute via a skill as a template
Auto Mode Retired Plan Mode - Boris dropped plan mode for auto mode on Opus 4.6+ — newer models don't need a planning step
Context Minimalism - Minimal system prompt + tools; let the model pull the rest (prompt eng → context eng → minimalism)
Write It Down, Don't Re-Prompt - Every mistake → CLAUDE.md or a skill, not a chat correction
Why Auto Mode Is Trustworthy - Thousands of transcripts classified + red-teamed into evals; safer than glazing over prompts
Nested Subagents - Agents kick off agents (depth=5) to manage context; monitor with arrow-down in the terminal
fork: true - Experimental skill frontmatter: run a skill in its own context window; being added to /code-review
Workflow Trigger - Say "use a workflow" (not bare "workflow" — too many false positives)
Fable 5 - Anthropic's "Mythos-class" model — Boris's best coding model "by a wide margin"; in Claude Code + Cowork
What Fable 5 Changes - New default coding model (supersedes Opus 4.8); leans into context minimalism + delegation
Try After Installing
> How do I run parallel Claude sessions with worktrees?
> What should I put in my CLAUDE.md?
> Set up a PostToolUse hook to auto-format my code
> What's the best way to verify Claude's work?
Prefer to download manually? Download SKILL.md and place it in:
~/.claude/skills/boris/SKILL.md
Create the ~/.claude/skills/boris/
directory if it doesn't exist.
The skill automatically checks for updates when you type /boris
. If a newer version is available, Claude will download it for you — no manual steps needed.
To uninstall: rm -rf ~/.claude/skills/boris/
How Skills Work
Skills are markdown files with YAML frontmatter that Claude Code loads automatically. When you type /boris or ask about related topics, Claude surfaces this knowledge to help you. Skills can be user-invocable (slash commands) or auto-surfaced based on semantic matching.