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

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