Anthropic’s Boris Cherny Reveals Game-Changing AI Workflow, Sparking ‘ChatGPT Moment’ for Software Development

When the creator of the world’s most advanced coding agent speaks, Silicon Valley doesn’t just listen – it takes notes. The engineering community has spent the past week rigorously dissecting a thread on X from Boris Cherny, the influential creator and head of Claude Code at Anthropic. What began as a seemingly casual sharing of his personal terminal setup has rapidly escalated into a viral manifesto on the future of software development, with numerous industry insiders hailing it as a watershed moment for the startup and a potential paradigm shift for the broader tech landscape.

The immediate and widespread reaction underscores the significance of Cherny’s insights. "If you’re not reading the Claude Code best practices straight from its creator, you’re behind as a programmer," asserted Jeff Tang, a prominent and respected voice within the developer community. Echoing this sentiment, Kyle McNease, another keenly observant industry analyst, went even further, proclaiming that with Cherny’s "game-changing updates," Anthropic is "on fire," potentially experiencing "their ChatGPT moment." This comparison is particularly weighty, drawing parallels to the revolutionary impact of OpenAI’s ChatGPT, which significantly accelerated public and industry awareness of generative AI’s capabilities.

The profound excitement surrounding Cherny’s revelations stems from a compelling paradox: his workflow, at its core, appears remarkably simple, yet it empowers a single human operator to achieve an output capacity typically associated with a small, dedicated engineering department. This exponential leap in productivity has captivated developers. As one user noted on X after successfully implementing Cherny’s distinct setup, the entire coding experience "feels more like Starcraft" than traditional software development. This analogy to the real-time strategy video game vividly illustrates a fundamental shift: from the manual, syntax-heavy act of typing code to the strategic command and orchestration of autonomous units – in this case, sophisticated AI agents. This article delves into an in-depth analysis of this groundbreaking workflow, directly from its architect, exploring the methods that are poised to reshape how software is built globally.

How running five AI agents at once turns coding into a real-time strategy game

The most striking and transformative revelation from Cherny’s disclosure is his departure from linear coding methodologies. In the conventional "inner loop" of software development, a programmer typically follows a sequential process: writing a function, meticulously testing it, and only then moving on to the next task. Cherny, however, adopts a fundamentally different role, operating as a strategic "fleet commander" rather than a singular coder.

"I run 5 Claudes in parallel in my terminal," Cherny explicitly stated in his thread. He further elaborated on his systematic approach: "I number my tabs 1-5, and use system notifications to know when a Claude needs input." This seemingly straightforward organizational technique, powered by iTerm2 system notifications, enables Cherny to simultaneously manage five distinct and active work streams. While one AI agent might be diligently running a comprehensive test suite, another could be engaged in refactoring a complex legacy module, and a third might be in the process of drafting essential project documentation. This parallel processing capability is a cornerstone of his amplified productivity.

Beyond his local terminal setup, Cherny also maintains "5-10 Claudes on claude.ai" in his browser, leveraging a "teleport" command to seamlessly hand off active sessions between his web interface and his local machine. This fluid transition capability further enhances his ability to manage multiple concurrent AI-driven tasks. This highly efficient, multi-agent orchestration directly validates the "do more with less" strategy championed by Anthropic President Daniela Amodei earlier this week. While formidable competitors such as OpenAI are reportedly pursuing massive, trillion-dollar infrastructure build-outs to scale their AI capabilities, Anthropic is demonstrating a compelling alternative: that superior strategic orchestration and intelligent utilization of existing, powerful models can yield exponential productivity gains without necessarily requiring a commensurate investment in new physical infrastructure.

The counterintuitive case for choosing the slowest, smartest model

In a move that runs counter to the prevailing industry obsession with minimizing latency and maximizing speed, Cherny made a surprising revelation: he exclusively employs Anthropic’s heaviest and slowest model, Opus 4.5. This choice challenges conventional wisdom, which often prioritizes faster, lighter models for iterative development tasks.

"I use Opus 4.5 with thinking for everything," Cherny explained. He passionately defended his decision, stating, "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." This insight is particularly critical for enterprise technology leaders grappling with the practicalities of integrating AI into their workflows. Cherny’s experience highlights that the primary bottleneck in modern AI-assisted development is not merely the speed at which tokens are generated by the model. Rather, it is the substantial human time and effort spent correcting the AI’s mistakes, refining its output, and guiding it through complex tasks. Cherny’s workflow offers a compelling argument: by deliberately incurring a higher "compute tax" – the upfront cost associated with utilizing a more powerful, intelligent, and computationally intensive model – developers can effectively eliminate or drastically reduce the subsequent "correction tax," which represents the significant human cost of rectifying errors and iterating on subpar AI output. This strategic decision ultimately leads to a faster overall development cycle, despite the initial latency of the chosen model.

One shared file turns every AI mistake into a permanent lesson

Cherny also provided valuable insights into how his team effectively addresses one of the persistent challenges of large language models (LLMs): the problem of "AI amnesia." Standard LLMs typically lack a persistent memory, meaning they do not inherently "remember" a company’s specific coding style, architectural decisions, or established best practices from one interaction or session to the next. This limitation often forces developers to repeatedly provide context and instructions to the AI.

To counteract this, Cherny’s team has implemented an ingenious and highly effective solution: they maintain a single, dedicated file named CLAUDE.md, which is committed and tracked within their main git repository. "Anytime we see Claude do something incorrectly we add it to the CLAUDE.md, so Claude knows not to do it next time," he wrote. This practice transforms what would typically be a fleeting error into a permanent, actionable lesson for the AI. The codebase itself evolves into a self-correcting organism. When a human developer reviews a pull request and identifies an error or a deviation from established guidelines, their action isn’t limited to merely fixing the code. Crucially, they also update the CLAUDE.md file, effectively tagging the AI with new instructions and guardrails to prevent similar mistakes in future interactions. "Every mistake becomes a rule," perceptively noted Aakash Gupta, a product leader who analyzed the thread, highlighting the cumulative learning effect. The longer the team collaborates using this system, the more intelligent and aligned the AI agent becomes, consistently reducing the frequency of repetitive errors and improving the quality of its output over time.

Slash commands and subagents automate the most tedious parts of development

The seemingly "vanilla" yet incredibly powerful workflow that has garnered so much praise is underpinned by a rigorous and pervasive automation of repetitive and time-consuming tasks. Cherny extensively utilizes "slash commands" – custom shortcuts that are themselves checked into the project’s repository. These commands enable him to execute complex operations with remarkable efficiency, often requiring just a single keystroke.

He specifically highlighted a command named /commit-push-pr, which he invokes dozens of times throughout a typical day. Instead of manually typing out a series of git commands, crafting a detailed commit message, and then separately initiating the process of opening a pull request, the AI agent, triggered by this simple command, autonomously handles the entire bureaucratic overhead of version control. This significantly frees up developer time and mental bandwidth.

Furthermore, Cherny strategically deploys "subagents" – highly specialized AI personas – each designed to manage distinct phases or aspects of the development lifecycle. For instance, he employs a dedicated code-simplifier subagent to meticulously clean up and refactor the architectural design of the codebase once the primary development work has been completed. Another specialized agent, a verify-app agent, is tasked with running comprehensive end-to-end tests, ensuring the application’s integrity and functionality before any code is shipped to production. This modular approach allows for parallelization and specialization of AI capabilities, mirroring the division of labor in a human team.

Why verification loops are the real unlock for AI-generated code

If there is a single, paramount reason why Claude Code has reportedly achieved the significant milestone of $1 billion in annual recurring revenue so rapidly, it is almost certainly the strategic implementation of robust verification loops. This approach elevates the AI beyond a mere text generator, transforming it into a proactive and diligent tester of its own output.

"Claude tests every single change I land to claude.ai/code using the Claude Chrome extension," Cherny revealed, outlining a critical component of his workflow. He elaborated on the automated process: "It opens a browser, tests the UI, and iterates until the code works and the UX feels good." This continuous, self-correcting feedback mechanism is profoundly impactful. Cherny emphatically argues that empowering the AI with the capability to verify its own work – whether through sophisticated browser automation, the execution of shell (bash) commands, or the running of comprehensive test suites – demonstrably improves the quality of the final result by a factor of "2-3x." The core principle here is transformative: the AI agent is not merely tasked with writing code; it is also responsible for proving that the code it generates actually functions as intended, significantly reducing the burden on human developers for quality assurance and debugging.

What Cherny’s workflow signals about the future of software engineering

The overwhelming and enthusiastic reaction to Boris Cherny’s X thread signals a pivotal and irreversible shift in how developers and the broader tech industry perceive their craft. For many years, the concept of "AI coding" primarily referred to relatively simplistic functions like autocomplete in a text editor – essentially, a faster way to type existing code. Cherny, through his demonstrated workflow, has shattered this limited perception, unequivocally proving that AI can now function as a comprehensive "operating system for labor" itself.

As Jeff Tang succinctly summarized on X, "Read this if you’re already an engineer… and want more power." This sentiment encapsulates the empowering nature of Cherny’s approach. The tools and methodologies required to multiply human output by a factor of five, or even more, are no longer theoretical concepts; they are demonstrably here and accessible. They require, however, a fundamental mental adjustment: a willingness to stop thinking of AI as merely an assistant that helps with isolated tasks and to begin treating it as a dynamic, autonomous workforce that can be commanded and orchestrated. The programmers who make this crucial mental leap first will not only experience dramatically increased productivity and efficiency but will also find themselves playing an entirely different game in the competitive landscape of software development. While they command fleets of intelligent agents, everyone else will still be, quite literally, typing.