When Boris Cherny, the creator of Claude Code, shared his daily workflow on X, the development community took notice. Not because of some revolutionary technique or complex setup, but for the opposite reason: his approach is remarkably straightforward. And that’s precisely why it works.
If you’re looking to supercharge your development workflow with AI, here’s how one of the people building these tools actually uses them.
The core philosophy: Parallelism over speed
Boris runs approximately 10 Claude sessions in parallel at any given time. Instead of babysitting each one, he relies on system notifications to alert him when human input is needed. This approach transforms AI from a back-and-forth conversation tool into something more akin to having a team of junior developers working simultaneously on different tasks.
The key insight here is understanding that AI assistance doesn’t have to be sequential. You’re not limited to one task at a time. By spinning up multiple sessions, you’re essentially multiplying your capacity to tackle problems.
Opus 4.5 with thinking: Slower tokens, faster results
While many developers gravitate toward faster models for quick iterations, Boris exclusively uses Claude Opus 4.5 with thinking enabled. Yes, it’s slower per token. But here’s the counterintuitive truth: it’s faster overall.
Why? Because it requires far less human steering. When you use a more capable model that can reason through problems, you spend less time course-correcting, clarifying, and re-explaining. The AI gets it right more often on the first try, which means you’re not stuck in revision loops.
Think of it like hiring: you might pay more per hour for a senior developer, but they’ll complete the project in a fraction of the time a junior would need.
The 2,500-token secret weapon
The Claude Code team maintains a single shared Claude.md file, checked directly into their Git repository. Whenever Claude behaves incorrectly or misunderstands something, they add a new instruction to this file.
The surprising part? After continuous refinement, this file sits at just around 2,500 tokens. That’s remarkably concise for a document that encodes the team’s entire workflow, conventions, and common pitfalls.
This approach is brilliant in its simplicity. Instead of re-explaining your coding standards, architectural decisions, and preferences in every new conversation, you build up a knowledge base that travels with your code. It’s version-controlled, it’s collaborative, and it evolves with your project.
Plan first, execute once
Boris starts most sessions in plan mode. He iterates on the plan until it feels solid and well-thought-out. Only then does he switch to autonomous mode.
The result? The task usually gets done in one shot.
This two-phase approach mirrors how experienced developers naturally work. You don’t just start coding immediately. You think through the problem, consider edge cases, map out the architecture, and only then do you write code. By forcing this separation with AI, you ensure the execution phase has clear direction.
Sub-agents for specialized tasks
Rather than using Claude as a monolithic tool, Boris employs specialized sub-agents for specific purposes:
Code Simplifier handles post-generation cleanup, refactoring verbose code into something more maintainable.
Verify App runs end-to-end testing to ensure the generated code actually works in practice.
This division of labor is another stroke of genius. Different tasks require different contexts and goals. By creating specialized agents, you’re optimizing each one for its specific role rather than trying to make a single prompt do everything.
Let Claude verify its own work
Perhaps the most interesting aspect of Boris’s workflow is his strong belief in letting Claude verify its own work. He allows it to use a Chrome extension to open a browser, test the UI, and iterate until the code actually functions correctly.
This creates a feedback loop that’s incredibly powerful. Instead of you manually testing and reporting back what’s broken, the AI can see the results of its work and self-correct. It’s the difference between giving someone directions and letting them use GPS.
The output: 50–100 pull requests per week
With this setup, Boris completes approximately 50 to 100 pull requests per week. Let that sink in. That’s anywhere from 10 to 20 PRs per day.
For context, many developers consider 5–10 meaningful PRs per week to be highly productive. Boris is operating at roughly 10x that rate.
Why vanilla workflow works?
In the comments on his original post, many people pointed out that his workflow is pretty vanilla and straightforward. There’s no exotic prompting technique, no complex orchestration system, no proprietary tooling.
And that’s exactly why it works so well.
The most sustainable, scalable workflows aren’t built on clever hacks or cutting-edge techniques that might break with the next model update. They’re built on solid principles: parallelism, proper planning, specialization, and verification.
Key takeaways for your workflow
If you want to adopt Boris’s approach, here are the core principles to implement:
Run multiple sessions in parallel. Don’t wait for one task to complete before starting another. Let the AI work on several things simultaneously while you focus on high-level orchestration.
Invest in better models upfront. The most capable model with extended reasoning might seem slower, but it saves time by getting things right the first time.
Build and maintain a project-specific instruction file. Create your own Claude.md that captures your conventions, common issues, and preferences. Keep it concise and version-controlled.
Separate planning from execution. Get the plan right before switching to autonomous mode. A solid plan executed once beats a vague idea iterated ten times.
Create specialized agents. Instead of one general-purpose prompt, build focused sub-agents for cleanup, testing, and other recurring tasks.
Enable self-verification. Give your AI the tools to check its own work and iterate without constant human intervention.
The future is already here
What’s remarkable about Boris’s workflow isn’t that it’s revolutionary. It’s that it’s achievable today, with tools that are publicly available. You don’t need to wait for the next model release or some breakthrough in AI capabilities.
The gap between where most developers are and where they could be isn’t technological. It’s methodological. Boris has simply figured out how to structure his work to leverage AI’s strengths while minimizing its weaknesses.
The best part? His approach isn’t proprietary or complex. It’s vanilla. It’s straightforward. And that means you can start using it today.
What aspects of this workflow are you most excited to try?
Have you experimented with running multiple AI sessions in parallel?
Share your thoughts and experiences in the comments.
Top comments (0)