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.

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.

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.

They also explicitly tell Claude to enter plan mode for verification steps, not just for the build.

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.

One engineer tells Claude to maintain a notes directory for every task/project, updated after every PR. They then point CLAUDE.md at it.

Create your own skills and commit them to git. Reuse across every project.

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.

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.

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.

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.

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.

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.

A few quick settings to make Claude Code feel right in your terminal:

Run /model to pick your preferred effort level:

Personally, I use High for everything.

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.

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.

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.

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.

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.

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.

Hooks are a way to deterministically hook into Claude's lifecycle. Use them to:

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.

Run /config and set an output style to have Claude respond using a different tone or format.

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.

To 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.

If you prefer not to use the terminal, head to the Code tab in the Claude Desktop app and check the worktree checkbox.

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.

You can also make subagents always run in their own worktree. To do that, just add isolation: worktree to your agent frontmatter.

If you're a Mercurial, Perforce, or SVN user, define worktree hooks to benefit from isolation without having to use Git.

Use parallel agents to improve code quality, tune code efficiency, and ensure CLAUDE.md compliance. Just append /simplify to any prompt.

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.

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.

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.

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.

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.

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+).

Voice mode is now rolled out to 100% of users, including in Claude Code Desktop and Cowork. Sometimes you need somebody to talk to.

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.

Name your session at launch with the --name flag. Makes it easy to identify sessions when running multiple in parallel.

After plan mode, Claude will automatically name your session based on what you're working on. No manual naming needed.

Change the color of the prompt input with /color. Useful for visually distinguishing sessions when running multiple in parallel.

A new hook event: PostCompact. Fires after Claude compresses its conversation context, letting you inject instructions or run commands when compaction happens.

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.

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.

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.

Claude Code now has a built-in memory system. Run /memory to configure it.

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.

Move sessions back and forth between mobile/web/desktop and terminal.

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.

Use hooks to deterministically run logic as part of the agent lifecycle.

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."

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.

Download the extension for Chrome/Edge.

Use the Claude Desktop app to have Claude automatically start and test web servers.

People often ask how to fork an existing session. Two ways:

Boris uses this all the time to answer quick questions while the agent works.

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.

/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.

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.

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.

Custom agents are a powerful primitive that often gets overlooked.

Fun fact: Boris does most of his coding by speaking to Claude, rather than typing.

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.

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.

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.

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.

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.

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."

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.

Drop it down if you want speed over depth, or leave it alone for most work. Available through /effort just like the other levels.

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.

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.

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.

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."

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.

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'."

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.

"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.

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.

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

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

Building a mental model for these helps you nudge Claude via prompts. They're not exclusive — Claude mixes and nests them.

Thariq: "I've found that workflows are sometimes even more useful for non-technical work." A sampling from the article:

Workflows compose with the rest of Claude Code. Three levers worth knowing, plus the honest "when not to."

A good workflow is reusable. Once Claude builds one you like, keep it.

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.

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.

"From context engineering to context minimalism" is its own chapter in the interview. The era you're in tracks the model you're using.

Boris calls this the single most important idea for long-running work — and it's the whole reason his agents can run for hours.

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.

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."

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.

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:

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.

The step-ups, at a glance

• Fewer prompts & steers
• More efficient token use
• Better code quality & tool use
• More intelligent self-verification
• Longer-running sessions
• Higher trust & autonomy

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."

Fable 5 supersedes Opus 4.8 as the strongest coding model — which shifts a couple of earlier tips and leans harder into others.