Summary of "His Claude Code Workflow Is Insane"

Short summary

The video walks through Boris Chenry’s (creator of Claude / Cloud Code) personal Claude/Cloud Code workflow and demos how the narrator reproduced many of his tips in practice. It’s a practical guide showing features, configuration patterns, and operational cautions for using Claude/Cloud Code as a daily engineering toolchain.

Key technological concepts and product features covered

Multi-instance workflow
- Run multiple “clouds” (Claude instances) in parallel: local terminal instances plus 5–10 web sessions (cloud.ai/code) synced to phone.
- Tabs are numbered and renamed; system notifications signal when a session needs input.
Teleport
- Move a local session to the web UI (cloud web) to continue work or hand off to a phone.
Model choice and trade-offs
- Boris favors Opus (4.5 → 4.6) with “thinking” for fewer steerings and better tool use, at the cost of slower runtime compared to smaller models.
Plan mode
- Start sessions in plan mode (Shift+Tap twice) to create detailed plans and context before edits; then switch to auto-accept edits so Claude implements the plan.
cloud.md (context engineering)
- Keep a single cloud.md per repo checked into Git and maintained by the team to teach Claude project-specific conventions and avoid repeat mistakes.
Code reviews automation
- Integrate Claude into PR workflows (GitHub Actions) to auto-review diffs and add contextual guidance via Claude.md files.
Slash commands / skills
- Store reusable inner-loop commands in .cloud/commands (or skills).
- Example: slash commit-push-pr — formats, commits, pushes and opens a PR using inline bash to precompute git status.
Custom subagents / Agent Swarms
- Create subagents for repetitive roles (Code Simplifier, Verify app, architecture checks).
- Opus 4.6 introduces Agent Swarm / Agent Teams where subagents have roles and shared context with a master orchestrator.
Post-tool-use hooks
- Automatic formatting / clean-up hooks (like pre-commit) triggered after tool usage to avoid CI formatting errors.
Slash permissions vs dangerously-skip
- Prefer pre-authorized slash permissions stored in .cloud/settings.json rather than using dangerously-skip; share team-wide to avoid permission friction.
MCPs (external tool integrations)
- Use MCP configurations to let Cloud interact with Slack, BigQuery, Sentry, etc. (checked in as MCP JSON).
- Warning: MCPs can expand the context window and increase prompt-injection risk — review before installing.
Long-running / background tasks
- Use background agents, agent stop hooks or plugins (e.g., Ralph Wiggin) to run long tasks without blocking.
- Be cautious about reliability and result variability; manage permissions safely.
Agentic validation / verification feedback loop
- Have Claude verify and test its changes (Chrome extension-driven E2E UI tests, screenshots, assertions).
- Deterministic verification increases output quality significantly (roughly 2–3x improvement).

Practical demos, guides and how-tos shown

Terminal layout with multiple Claude instances and tab management (hotkeys, naming).
Creating and teleporting sessions between local and web (demonstrated, with a brief teleport trial).
Switching models (Opus 4.5 → 4.6) and setting model via slash model.
Creating slash commands/skills interactively via Cloud Code (example: commit-push-pr / slash ship).
Creating/using subagents to inspect code architecture or run verifications.
Configuring slash permissions and editing .cloud/settings.json.
Running automated end-to-end integration checks:
- Launching the site, navigating, clicking posters, matching titles, capturing screenshots and passing/failing checks.
Brief coverage of installing and using plugins like Ralph for iterative long-running automation.

Operational / engineering advice and cautions

Keep cloud.md and slash commands in the repo to enable team-wide “compound engineering” and reproducible context.
Avoid granting blanket or unsafe permissions; prefer fine-grained slash permissions.
Be cautious with MCPs and plugins — they can introduce prompt-injection vectors and context blow-up.
Hardware limits: running many instances and heavy models consumes RAM — you may need to sacrifice local IDEs or Chrome tabs.
Ralph / long-run agents can be useful for side projects but results vary; don’t rely blindly.
Verification loops are crucial — automated E2E checks improve reliability and trust in agentic changes.

Concise list of Boris’s numbered tips

Run multiple Claude instances (clouds) in parallel; number tabs and use notifications.
Run 5–10 web clouds (cloud.ai/code) parallel to local ones; start sessions on phone as needed; use teleport.
Use Opus + thinking for coding (better tool use, less steering) — note Opus speed trade-offs.
Share a single cloud.md per repo in Git; update regularly to capture fixes and conventions.
Add Claude into code reviews (GitHub Actions) and include Claude.md as part of PRs.
Start in plan mode for most sessions; iterate the plan with Claude, then switch to auto-accept edits.
Use slash commands / skills for repeated inner-loop tasks; store them in .cloud/commands.
Create custom subagents to automate common workflows (Code Simplifier, Verify app); consider Agent Swarms.
Use post-tool-use hooks for formatting and preventing CI issues.
Use slash permissions (pre-approved safe commands) rather than dangerously-skip.
Use MCP integrations to operate Slack, BigQuery, Sentry, etc., but be cautious.
For long-running tasks, use background agents, agent stop hooks, or plugins like Ralph; manage permissions appropriately.
Always give Claude a verification loop (E2E tests/screenshots); verified work greatly improves quality.

Main speakers / sources

Boris Chenry — creator of Claude / Cloud Code; primary source of the workflow and tips.
The video narrator / presenter (unnamed in subtitles) — demos and explains how he replicated Boris’s workflow.