The Father of Claude Code Reveals: How to Turn Claude into Your "Virtual Development Team"?

Original: Boris Cherny, Claude Code Developer

Compiled & Organized: Xiao Hu AI

You may have heard of Claude Code, or even used it to write some code or edit some documents. But have you ever thought: what if AI is not just a "temporary tool," but a formal member of your development process, or even an automated collaboration system—how would it change the way you work?

Boris Cherny, the father of Claude Code, wrote a very detailed tweet sharing how he efficiently uses this tool and how he and his team deeply integrate Claude into the entire engineering process.

This article will systematically organize and interpret his experiences in a straightforward manner.

How does Boris make AI an automated partner in his workflow?

Key Points:

He introduced his workflow, including:

How to Use Claude:

Open multiple Claudes simultaneously: Run 5-10 sessions in the terminal and web to process tasks in parallel, and also use Claude on mobile.

Don’t blindly change default settings: Claude is ready to use out of the box, no need for complex configurations.

Use the strongest model (Opus 4.5): Although it’s a bit slower, it’s smarter and easier to use.

Plan before writing code (Plan mode): Let Claude help you think clearly before writing, increasing the success rate.

Check the format with tools after generating code to avoid errors.

How to Make Claude Smarter Over Time:

The team maintains a "knowledge base": Whenever Claude makes a mistake, they add the experience to prevent it from happening again.

Automatically train Claude while writing PRs: Let Claude review PRs to learn new usages or standards.

Frequently used commands become slash commands that Claude can automatically invoke, saving repetitive labor.

Use "sub-agents" to handle fixed tasks, such as code simplification and functionality verification.

How to Manage Permissions:

Do not skip permissions casually, but set safe commands to pass automatically.

Synchronize Claude's workflow across multiple devices (web, terminal, mobile).

The most important point:

Always provide Claude with a "verification mechanism" to confirm whether what it writes is correct.

For example, Claude can automatically run tests, open a browser to test web pages, and check if functions are effective.

Claude Code is a "Partner," Not a "Tool"

Boris first conveys a core idea: Claude Code is not a static tool, but an intelligent partner that can collaborate with you, continuously learn, and grow together.

It doesn’t require too many complex configurations; it’s powerful right out of the box. But if you are willing to invest time in building better usage methods, the efficiency gains can be exponential.

Model Selection: Choose the Smartest, Not the Fastest

Boris uses Claude's flagship model Opus 4.5 + Thinking Mode ("with thinking") for all development tasks.

Although this model is larger and slower than Sonnet, it:

Has stronger comprehension abilities
Is better at using tools
Doesn’t require repeated guidance, reducing back-and-forth communication
Overall saves more time than using a faster model
Insight: True production efficiency lies not in execution speed, but in "fewer errors, less rework, and less repeated explanation."

1. Plan Mode: Use AI to Write Code, But Don’t Rush to Let It "Write"

When we open Claude, many people instinctively input "help me write an interface" or "refactor this code"… Claude usually "writes something," but often goes off track, misses logic, or even misunderstands the requirements.

Boris's first step is never to let Claude write code directly. He uses Plan mode—first, he collaborates with Claude to formulate the implementation approach, then moves to the execution phase.

How Does He Do It?

When starting a PR, Boris doesn’t let Claude write code directly but uses Plan mode:

Describe the goal
Collaborate with Claude to formulate a plan
Confirm each step
Then let Claude start writing

Whenever a new feature needs to be implemented, such as "adding rate limiting to an API," he confirms step by step with Claude:

Should it be implemented with middleware or embedded logic?
Does the rate limiting configuration need to support dynamic modification?
Is logging required? What should be returned on failure?

This "planning negotiation" process is similar to two people drawing out "construction blueprints."

Once Claude understands the goal, Boris will enable "auto-accept edits" mode, allowing Claude to directly modify code and submit PRs, sometimes even without needing manual confirmation.

"The quality of Claude's code depends on whether you reach an agreement before writing." — Boris

Insight: Instead of repeatedly fixing Claude's mistakes, it's better to clarify the roadmap together from the start.

Summary

Plan mode is not a waste of time; it exchanges upfront negotiation for stable execution. No matter how strong AI is, it still needs "you to be clear."

2. Multiple Claudes in Parallel: Not One AI, But a Virtual Development Team

Boris doesn’t just use one Claude. His daily routine looks like this:

Open 5 local Claudes in the terminal, assigning sessions to different tasks (like refactoring, writing tests, debugging)
Open another 5-10 Claudes in the browser, running in parallel with the local ones
Use the Claude iOS app on his phone to initiate tasks anytime

Each Claude instance acts like a "dedicated assistant": some are responsible for writing code, some for document completion, and some run background tests continuously.

He even set up system notifications so that when Claude is waiting for input, he can be alerted immediately.

Why Do This?

Claude's context is local, making it unsuitable for "one window to do everything." Boris splits Claude into multiple roles to process tasks in parallel, reducing wait times and minimizing "interference memory."

He also uses system notifications to remind himself: "Claude 4 is waiting for your reply," "Claude 1 has completed testing," managing these AIs like a multi-threaded system.

Analogous Understanding

You can imagine having five smart interns sitting next to you, each responsible for a task. You don’t have to complete everything; just "switch people" at key moments to keep tasks flowing smoothly.

Insight: Treating Claude as multiple "virtual assistants" handling different tasks can significantly reduce wait times and context-switching costs.

3. Slash Commands: Turn Your Daily Tasks into Claude's Shortcuts

Some workflows are tasks we do dozens of times a day:

Modify code → commit → push → create PR
Check build status → notify the team → update issues
Sync changes across web and local sessions
Boris doesn’t want to prompt Claude every time: "Please commit first, then push, and then create a PR…"

He encapsulates these operations into slash commands, such as:

/commit-push-pr

These commands are backed by Bash script logic, stored in the .claude/commands/ folder, and added to Git management, allowing team members to use them.

How Does Claude Use These Commands?

When Claude encounters this command, it doesn’t just "execute the instruction," but understands the workflow represented by the command and can automatically execute intermediate steps, pre-fill parameters, and avoid repeated communication.

Key Understanding

Slash commands are like "automatic buttons" you install for Claude. You train it to understand a task flow, and then it can execute it with one click.

"Not only can I save time with commands, but Claude can too." — Boris

Insight: Don’t repeat prompts every time; abstract high-frequency tasks into commands so that you and Claude can achieve "automation."

4. Team Knowledge Base: Claude Learns Not from Prompts, But from a Team-Maintained Knowledge Gene

Boris's team maintains a .claude knowledge base, which is also managed by Git.

It acts like an "internal Wikipedia" for Claude, recording:

What writing styles are correct
What the team's agreed best practices are
How to correct issues encountered

Claude automatically references this knowledge base to understand context and judge code style.

What to Do When Claude Makes Mistakes?

Whenever Claude misunderstands or writes incorrect logic, the lesson is added to the knowledge base.

Each team maintains its own version.

Everyone collaborates in editing, and Claude will reference this knowledge base in real-time for judgment.

For example:

If Claude keeps writing pagination logic incorrectly, the team just needs to write the correct pagination standards into the knowledge base, and every subsequent user will automatically benefit.

Boris's approach: instead of scolding it or shutting it down, he "trains it once":

We don't write this code this way; add it to the knowledge base.

Next time, Claude won't make that mistake again.

More importantly, this mechanism is not maintained by Boris alone, but contributed to and modified by the entire team every week.

Insight: Using AI is not about everyone working solo, but about building a system of "collective memory."

5. Automatic Learning Mechanism: PR Itself is Claude's "Training Data"

When Boris conducts code reviews, he often @s Claude on PRs, for example:

@.claude add this function's implementation to the knowledge base.

With GitHub Action, Claude will automatically learn the intent behind this change and update its internal knowledge.

This is similar to "continuously training Claude"; each review not only merges code but also enhances AI capabilities.

This is no longer "post-maintenance," but integrates AI's learning mechanism into daily collaboration.

The team improves code quality through PRs, while Claude simultaneously enhances its knowledge level.

Insight: PR is not just a code review process; it is also an opportunity for AI tools to self-evolve.

6. Subagents: Allowing Claude to Execute Complex Tasks Modularly

In addition to the main task flow, Boris also defines some subagents to handle common auxiliary tasks.

Subagents are automatically running modules, such as:

code-simplifier: automatically simplifies structure after Claude writes code
verify-app: runs complete tests to verify if new code is usable
log-analyzer: analyzes error logs to quickly locate issues

These subagents integrate into Claude's workflow like plugins, collaborating automatically without needing repeated prompts.

Insight: Subagents are Claude's "team members," upgrading Claude from an assistant to a "project commander."

Claude is not just one person; it can be your small manager who leads the team.

7. Supplementary Paragraph One: PostToolUse Hook — The Final Gatekeeper of Code Formatting

In a team, getting everyone to write code in a unified style is not easy. Although Claude has strong generation capabilities, it inevitably has minor detail flaws like slightly off indentation or too many blank lines.

Boris's approach is to set up a PostToolUse Hook —

Simply put, this is a "post-processing hook" that Claude automatically calls after "completing a task."

Its functions include:

Automatically fixing code formatting
Adding missing comments
Handling lint errors to avoid CI failures

This step is usually not complex but is crucial. Just like running Grammarly after finishing an article, this ensures that the submitted work is stable and tidy.

For AI tools, the key to usability often lies not in generation capability but in finishing ability.

8. Permission Management: Pre-Authorization Instead of Skipping

Boris clearly states that he does not use --dangerously-skip-permissions — a parameter in Claude Code that can skip all permission prompts when executing commands.

It sounds convenient, but it can also be dangerous, such as accidentally deleting files or running the wrong scripts.

His alternative solution is:

Use the /permissions command to explicitly declare which commands are trusted.
Write these permission configurations into .claude/settings.json.
Share these security settings with the entire team.

This is like pre-authorizing a batch of "whitelist" operations for Claude, such as:

"preApprovedCommands": [

"git commit",

"npm run build",

"pytest"

]

Claude will directly execute these operations without needing to interrupt each time.

This permission mechanism is designed more like a team operating system rather than a standalone tool. He uses the /permissions command to pre-authorize commonly used and safe bash commands, and these configurations are stored in .claude/settings.json, shared by the team.

Insight: AI automation does not mean losing control. Incorporating security policies into the automation process itself is true engineering.

9. Multi-Tool Interaction: Claude = Multi-Functional Robot

Boris does not only let Claude write code locally. He configured Claude to access multiple core platforms through MCP (a central control service module):

Automatically send Slack notifications (e.g., build results)
Query BigQuery data (e.g., user behavior metrics)
Fetch Sentry logs (e.g., online exception tracking)

How to Achieve This?

The MCP configuration is stored in .mcp.json.

Claude will read the configuration at runtime and autonomously execute cross-platform tasks.

The entire team shares a set of configurations.

All of this is integrated with Claude through MCP (Claude's central control system), with configurations stored in .mcp.json.

Claude acts like a robotic assistant that can help you:

"Write code → Submit PR → Check results → Notify QA → Report logs."

This is no longer a traditional AI tool but the neural hub of an engineering system.

Insight: Don’t let AI work only in the "editor";

it can become the dispatcher in your entire system ecosystem.

10. Asynchronous Processing of Long Tasks: Background Agent + Plugins + Hooks

In real projects, Claude sometimes has to handle long tasks, such as:

Build + Test + Deploy
Generate reports + Send emails
Data migration script running

Boris's approach is very engineering-oriented:

Three Ways to Handle Long Tasks:

After completion, Claude uses a background agent to verify results.
Use Stop Hook to automatically trigger subsequent actions when the task ends.
Use the ralph-wiggum plugin (proposed by @GeoffreyHuntley) to manage long process states.

In these scenarios, Boris uses:

--permission-mode=dontAsk

or runs tasks in a sandbox to avoid interrupting the entire process due to permission prompts.

Claude is not "constantly watching," but rather a collaborator you can trust to manage.

Insight: AI tools are not only suitable for short and quick operations but also for long-term, complex processes — provided you build a good "management mechanism" for it.

11. Automatic Verification Mechanism: The Value of Claude's Output Depends on Its Ability to Validate Itself

One of the most important lessons from Boris's experience is:

Any result output by Claude must have a "verification mechanism" to check its correctness.

He adds a verification script or hook for Claude:

After writing code, Claude automatically runs test cases to verify if the code is correct.
Simulate user interactions in the browser to validate the front-end experience.
Automatically compare logs and metrics before and after execution.

If it does not pass, Claude will automatically modify and re-execute until it does.

This is like Claude having its own "closed-loop feedback system."

This not only improves quality but also reduces the cognitive burden on humans.

Insight: What truly determines the quality of AI outcomes is not the model's parameter count, but whether you have designed a good "result checking mechanism" for it.

Summary: It’s Not About Replacing Humans with AI, But About Making AI Collaborate Like Humans

Boris's method does not rely on any "hidden features" or black technology but uses Claude in an engineering manner, upgrading it from a "chat tool" to an efficient component of a work system.

His usage of Claude has several core characteristics:

Parallel Multi-Session: Clearer task division and higher efficiency.
Planning First: Plan mode enhances Claude's goal alignment.
Knowledge System Support: The team jointly maintains the AI knowledge base, continuously iterating.
Task Automation: Slash commands + subagents allow Claude to work like a process engine.
Closed-Loop Feedback Mechanism: Every output from Claude has verification logic to ensure stable and reliable results.

In fact, Boris's method demonstrates a new way to use AI:

Upgrading Claude from a "conversational assistant" to an "automated programming system."
Transforming knowledge accumulation from human brains into an AI knowledge base.
Converting processes from repetitive manual operations into scripted, modular, and collaborative automated workflows.

This approach does not rely on black magic but reflects engineering capabilities. You can also draw inspiration from it to use Claude or other AI tools more efficiently and intelligently.

If you often feel that "it understands a bit but is unreliable" or "the code it writes always needs my fixes," perhaps the issue is not with Claude, but with the fact that you haven't provided it with a mature collaboration mechanism.

Claude can be a competent intern or a stable and reliable engineering partner, depending on how you use it.

免责声明：本文章仅代表作者个人观点，不代表本平台的立场和观点。本文章仅供信息分享，不构成对任何人的任何投资建议。用户与作者之间的任何争议，与本平台无关。如网页中刊载的文章或图片涉及侵权，请提供相关的权利证明和身份证明发送邮件到support@aicoin.com，本平台相关工作人员将会进行核查。