Claude Code Workflow

I'm Boris and I created Claude Code. Lots of people have asked how I use Claude Code, so I wanted to show off my setup a bit. My setup might be surprisingly vanilla! Claude Code works great out of the box, so I personally don't customize it much. There is no one correct way to use Claude Code: we intentionally build it in a way that you can use it, customize it, and hack it however you like. Each person on the Claude Code team uses it very differently. So, here goes. 1:58 PM · Jan 2, 2026 · 6.5M Views Boris Cherny @bcherny · Jan 2 1/ I run 5 Claudes in parallel in my terminal. I number my tabs 1-5, and use system notifications to know when a Claude needs input https://code.claude.com/docs/en/terminal-config#iterm-2-system-notifications Boris Cherny @bcherny · Jan 2 2/ I also run 5-10 Claudes on http://claude.ai/code, in parallel with my local Claudes. As I code in my terminal, I will often hand off local sessions to web (using &), or manually kick off sessions in Chrome, and sometimes I will --teleport back and forth. I also start a few Show more Boris Cherny @bcherny · Jan 2 3/ I use Opus 4.5 with thinking for everything. 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. Boris Cherny @bcherny · Jan 2 4/ Our team shares a single http://CLAUDE.md for the Claude Code repo. We check it into git, and the whole team contributes multiple times a week. Anytime we see Claude do something incorrectly we add it to the http://CLAUDE.md, so Claude knows not to do it next Show more Boris Cherny @bcherny · Jan 2 5/ During code review, I will often tag @.claude on my coworkers' PRs to add something to the http://CLAUDE.md as part of the PR. We use the Claude Code Github action (/install-github-action) for this. It's our version of @danshipper 's Compounding Engineering Boris Cherny @bcherny · Jan 2 6/ Most sessions start in Plan mode (shift+tab twice). If my goal is to write a Pull Request, I will use Plan mode, and go back and forth with Claude until I like its plan. From there, I switch into auto-accept edits mode and Claude can usually 1-shot it. A good plan is really Show more Boris Cherny @bcherny · Jan 2 7/ I use slash commands for every "inner loop" workflow that I end up doing many times a day. This saves me from repeated prompting, and makes it so Claude can use these workflows, too. Commands are checked into git and live in .claude/commands/. For example, Claude and I use a Show more

Here’s the **signal distilled** from Boris’s thread, plus how you can actually *apply it* without cargo-culting his setup. --- ## What Boris is really saying (beneath the tweet) This isn’t about fancy configuration. It’s about **throughput, feedback loops, and institutional memory**. ### 1. Parallelism > Prompt Perfection - He runs **many Claudes at once** (terminal + web). - This turns Claude from a single assistant into a **distributed team**. - Key idea: *don’t wait*. Always have multiple lines of thought progressing. **Takeaway for you:** Even 2–3 parallel sessions dramatically outperform “one perfect prompt.” --- ### 2. Model choice is about *steering cost* - He uses **Opus 4.5 w/ thinking** despite latency. - Why? Less babysitting, fewer corrections, better tool usage. - Bigger model = lower *human* cognitive load. **Rule of thumb:** > The fastest model is the one that needs the fewest follow-ups. --- ### 3. CLAUDE.md = Compounding Intelligence This is the most important part. - One shared `CLAUDE.md` - Updated whenever Claude messes up - Checked into git - Reviewed like code This turns Claude into: - A **team member with memory** - A system that *improves over time*, not resets every session **This is the real moat.** --- ### 4. Plan mode is non-negotiable - Start in **Plan mode** - Iterate until the plan is solid - Only then let Claude write code - Good plan → 1-shot PRs This mirrors how senior engineers think: > Design is where correctness is decided. Code is just transcription. --- ### 5. Slash commands = externalized habits - Repeated workflows → slash commands - Stored in `.claude/commands/` - Claude can invoke them too This means: - You stop re-explaining yourself - Claude learns *how you work*, not just what you ask --- ## The meta-pattern (this matters for your projects) Boris is treating Claude Code as: > **A programmable collaborator with memory, process, and feedback** Not: - A chatbot - A code generator - A magic autocomplete This aligns *exactly* with: - Agentic workflows - Your persona systems - Your interest in compounding prompt structures - Cline / local-LLM orchestration --- ## If you wanted to copy this *minimally* Here’s the **80/20 version**: 1. Run **2–3 Claude sessions in parallel** 2. Create a `CLAUDE.md` with: - “Do not do X” - “Always do Y” - Project conventions 3. Always: - Start with a plan - Approve the plan - Then auto-accept edits 4. Extract one repeated workflow into a slash command That’s it. --- ## Why this should resonate with you specifically You already: - Think in systems - Care about memory and personas - Build compounding tooling - Prefer structure over vibes This thread is basically: > *Claude Code as applied epistemology.* If you want, next we can: - Draft a **CLAUDE.md template** tuned to your style - Translate this into a **Cline-optimized workflow** - Or design a **persona-aware slash command system** Just tell me which layer you want to build.

Translate this into a Cline-optimized workflow

Alright—this maps *cleanly* onto how Cline actually wants to be used. Below is a **Cline-native translation** of Boris’s Claude Code workflow, stripped of Anthropic-specific assumptions and rebuilt around **process, memory, and agentic control**. I’ll give you: 1. The **conceptual mapping** (Claude Code → Cline) 2. A **concrete Cline workflow** 3. A **drop-in project structure** 4. A **usage loop you can actually follow** No fluff. --- ## 1. Conceptual Translation: Claude Code → Cline | Boris / Claude Code | Cline Equivalent | Why it Works | |-------------------|------------------|--------------| | Parallel Claudes | Parallel VS Code windows / workspaces | Cline is single-threaded per session; parallelism comes from editors | | Opus w/ thinking | Large local model (Qwen2.5-Coder, DeepSeek-Coder, Mixtral) | Lower steering cost > latency | | CLAUDE.md | `CLINE.md` (or `AI_RULES.md`) | Persistent, versioned behavioral memory | | Plan mode | Explicit **Planning Phase prompt** | Cline obeys structure better than implicit modes | | Auto-accept edits | Cline’s file-edit loop | Works *only* after plan is locked | | Slash commands | Prompt macros / saved instructions | Externalized habits | | GitHub action | PR review prompt + diff context | Human-in-the-loop reinforcement | --- ## 2. The Cline-Optimized Workflow (End-to-End) ### Phase 0 — Project Memory (One-time, Compounding) Create a file at project root: ``` CLINE.md ``` This is **non-negotiable**. #### Example `CLINE.md` ```markdown # Cline Operating Rules ## General - Always read this file before planning or editing code - If behavior conflicts with this file, STOP and ask ## Planning - Never modify files before presenting a plan - Plans must include: - Files to be changed - New abstractions - Risks / edge cases ## Code Style - Prefer explicitness over cleverness - No silent behavior changes - Avoid magic constants ## Project-Specific Rules - This project favors: - Deterministic behavior - Pure functions where possible - No new dependencies without justification ## Known Failure Modes - Do NOT refactor unrelated code - Do NOT rename public APIs unless instructed - Do NOT invent abstractions ``` This is your **institutional memory**. Every time Cline screws up → add a bullet. --- ### Phase 1 — Planning Mode (Boris’s Plan Mode, Explicit) Start **every serious task** with a planning prompt like this: ```text Read CLINE.md. We are in PLANNING MODE. Do NOT modify any files. Goal: <one-sentence goal> Deliverable: - A clear implementation plan - File-level changes - Risks and tradeoffs Ask clarifying questions if needed. ``` **You do not proceed until the plan is approved.** This is where 90% of correctness lives. --- ### Phase 2 — Plan Lock-In When the plan is good, respond with: ```text Plan approved. Switch to IMPLEMENTATION MODE. Follow the plan exactly. Do not make additional design decisions. ``` This mimics Boris’s **auto-accept edits**. At this point, Cline becomes a deterministic executor. --- ### Phase 3 — Implementation Loop (Cline Strength Zone) Cline excels when: - Scope is locked - Files are known - Behavior is constrained Let it: - Create files - Modify code - Iterate until tests pass or logic is complete If it deviates: - Stop - Add a rule to `CLINE.md` - Retry This is compounding alignment. --- ### Phase 4 — Parallelism (Cline-Native) Since Cline can’t fork itself: **You do the forking.** Run: - VS Code Window A → Architecture / planning - VS Code Window B → Implementation - VS Code Window C → Refactor / cleanup Each has: - Same repo - Same `CLINE.md` - Different task focus This mirrors Boris’s “5 Claudes” model. --- ## 3. Slash Commands → Prompt Macros Cline doesn’t have native slash commands, but you can simulate them with: ### Option A — Snippet Prompts Create a folder: ``` .prompts/ ``` Example: ``` .prompts/review_diff.md ``` ```markdown Read CLINE.md. Review the following diff. - Identify logic errors - Identify violations of project rules - Suggest minimal fixes only ``` Paste when needed. --- ### Option B — Persona-Bound Commands (Your Wheelhouse) Example: ``` .prompts/architect.md ``` ```markdown You are acting as a senior systems architect. Constraints: - No new dependencies - Optimize for clarity - Favor stable abstractions Task: <insert task> ``` This plugs directly into your persona framework thinking. --- ## 4. PR Review / Compounding Loop After a change: ```text Read CLINE.md. Review the modified files as if you were reviewing a PR. - What would break in production? - What assumptions are implicit? - What should be added to CLINE.md? ``` If Cline flags a systemic mistake → **add it to CLINE.md**. That’s Boris’s compounding engineering, translated cleanly. --- ## 5. Why This Works (And Why It Fits You) This workflow: - Externalizes cognition - Converts mistakes into rules - Treats the model as a **bounded agent**, not a genius - Scales with project complexity Most importantly: > **The intelligence lives in the process, not the model.** Which is exactly how you already think. --- ## If you want next I can: - Generate a **Cline-perfect system prompt** for your local models - Design a **persona-aware prompt router** - Show how to wire this into **agent graphs** (Magnetic-One style) - Or compress this into a **one-page operating manual** Just point.