For the past year, he hasn't written a single line of code by hand.
He submits dozens of PRs every day, and one day hit 150, setting a personal record.
What's even more outrageous is that he has hundreds of AI agents running simultaneously on his side, and thousands more work the night shift for him.
This was personally stated by Boris Cherny, the father of Claude Code, during a recent public discussion with developers.
He has the Claude app open on his phone, with a small code tab on the left, containing 5 to 10 concurrent sessions.
Under each session is a cluster of agents, hundreds running during the day, and once night falls, thousands start doing deeper work.
The models write all the code, he doesn't touch a single line.
For him, the task of programming has been solved.
How Can One Person Manage Thousands of Agents?
One person manages thousands of agents, having them all modify code in the same repository simultaneously, without losing control, fighting each other, or creating piles of garbage.
Boris's secret lies behind one word: Loop.
He says a Loop is the simplest yet most useful thing he's seen; Loops are the future.
The essence of a Loop is letting Claude schedule a repeatable task using a cron job—every minute, every five minutes, daily, as you set it. Once it's running, it basically requires no management.
He has dozens of Loops running perpetually:
One specifically monitors his PRs, automatically fixing continuous integration (CI) and rebasing;
One is responsible for keeping CI healthy, fixing any unstable tests itself;
And another scrapes user feedback from X every 30 minutes, clusters and organizes it, then submits it to him.
More crucially, later on, even the step of initiating a Loop rarely requires Boris to speak up.
Once he just asked the model to run a data query, and the model replied: "I noticed this data keeps changing, so I'll start a Loop and give you a report every 30 minutes."
He said okay, just send it to my Slack. The model then handled the matter.
Not long ago, Boris also mentioned he no longer writes prompts, only loops.
Soon, he might not even need to write loops.
Agents
Are Redefining "Getting Work Done"
Behind this, "getting work done" itself is changing.
In the past, it was you writing a line, AI answering, you writing the next line; now, it's you building a small system that can find work, do it, and submit it on its own, then you walk away.
Anthropic recently launched Routines, moving the same mechanism to the server side. Close your laptop, and it still runs.
The role of "engineer" is also being rewritten in Boris's case:
The model writes the code, he's responsible for building the system and acceptance testing. Dozens to hundreds of PRs emerge daily from the agents. His real job is deciding which can be merged and which need to be sent back.
In his words, this is not "AI replacing engineers," but humans transitioning from operators and executors to designers of automated systems: the focus shifts from "writing this line of code correctly" to "building a system that can write code correctly on its own."
He even predicts that in another year, security steps like prompt injection protection, command validation, and manual approval will become less important because models will become increasingly conscientious about doing the right thing.
And this approach is no longer just his personal play.
According to Boris, there's hardly any manual coding left in the company; even SQL is written by models. It's hard to find a few lines of code still typed by a human in the entire company.
Even more surreal is another scene. When his Claude agents are writing code in a Loop, they'll go to Slack themselves, chat with colleagues' Claude agents, aligning on things no one has figured out yet.
A group of AIs holding meetings in a Slack channel, dividing up the work, and going back to do it—this is daily routine at Anthropic.
Even more intense is the team composition: engineering managers, product managers, designers, data scientists, finance, user researchers—everyone is writing code.
The functions remain, but everyone has gained an extra layer of general capability: "orchestrating AI to get work done," becoming cross-disciplinary generalists.
From Writing Prompts to Writing Loops
The Gap Lies in a Step Called Acceptance
How can an AI that works autonomously infinitely not be a machine producing bugs at high speed?
The answer lies in a step most people overlook: acceptance.
A Loop can run autonomously without going off the rails, relying on a "goal-driven" mechanism, corresponding to the /goal command in Claude Code.
You give it a goal, like "All unit tests under /tests/ pass, linting clean." After each step, a separate, smaller model judges: Is it done? If not, keep going; if yes, stop.
This "supervising model" responsible for scoring is not the one doing the work.
This simple design is precisely the heart of the entire loop.
Without it, a Loop running all night could very well be a machine that's asleep yet still bulk-submitting garbage code, and doing so righteously.
Boris verified this long ago.
When sharing his workflow previously, he gave this piece of advice: the most important step to squeeze the utmost out of Claude Code is to give it a way to verify its own work.
Once this feedback loop is established, output quality typically improves by 2 to 3 times.
A single action of "making AI check itself" is equivalent to upgrading a generation of models.
This Cycle is Usable by Ordinary People Too
The aforementioned cycle has been turned into a product; ordinary people can use it just the same.
After the release of Fable 5, a widely circulated tutorial on X stated, after three weeks of hands-on testing by the author: Most people use Fable 5 like they use ordinary Claude, which is a complete waste of what truly makes it worth paying for.
The author first points out three capabilities that distinguish Fable 5 from all previous Claude models.
The three major capabilities of Fable 5 summarized in the tutorial: Long-term autonomous work, self-verification, understanding dense charts.
First, it can work continuously for days, not minutes.
Previous models were sprinters; Fable 5 is the first model built for "long-term autonomous work."
In Claude Code, you can give it an entire multi-day project; it plans in phases itself, dispatches sub-agents, and keeps working until the goal is met.
Second, it checks its own work. After finishing a task, it doesn't rush to deliver; it first writes tests, runs them, catches errors, fixes them, and only then says "done."
Third, the ability to understand dense charts.
According to the author's tests, for tables in financial reports, charts embedded in PDFs, architecture diagrams, dashboard screenshots—areas where Opus 4.8 occasionally misidentified columns or confused axes—Fable 5 can read them accurately and consistently.
And to truly utilize these capabilities, it relies on two commands: /goal and /loop.
Without them, you're paying double the price for a chatbot; with them, you're buying an autonomous working employee.
/goal runs towards the finish line and stops itself when reached; /loop runs repeatedly on schedule until you tell it to stop.
The mechanism of /goal is: you define the result, it's responsible for iteration. Whether it runs well follows an ironclad rule: write the "completion criteria" concretely, and must include an exit strategy for failure.
For example, "Improve this piece of code" is a bad goal because it's unverifiable; "All tests under /tests/ pass, only files in /src are allowed to be modified, stop and report if still failing after 3 fixes" is a good goal because each point can be verified.
/loop doesn't target a specific endpoint; it runs repeatedly on schedule until you stop it.
For example, check error logs every 30 minutes, pick out severity-level ones and report them in plain language; or scan the inbox every hour, summarize new emails, and draft replies for those needing responses.
The division of labor mantra is three sentences: For a clear endpoint, use /goal; for periodic repetition, use /loop; to keep running until a condition is met, combine both.
Before letting go, there's one more piece of very practical advice: set the spending limit first. An uncapped /goal hitting a difficult problem can burn through tokens frighteningly fast.
Making It Remember You: 20 Minutes of Local Configuration
The tutorial also mentions a step most guides skip, which is precisely the most crucial.
Fable 5 won't remember you. Every new session, it knows nothing about your business, writing style, clients, or preferences, starting from zero each time.
The solution is to set up a local context system on your own machine, which takes only 20 minutes.
One folder, two markdown files, and a set of skills—that's all the configuration needed for Fable 5 to "know you."
It's done in four steps.
Step one, create a context folder, e.g., named `fable-workspace`, serving as the "single source of truth" it must read before starting any work.
The folder can contain items like: a one-page summary of business and priorities, standard operating procedures for frequent tasks, key information for ongoing projects, often-referenced strategic documents, plus a decision log.
Keep each file to one page; too much content eats up the context window.
Step two, create a memory file `claude-memory.md`, and leave an instruction: Whenever I mention important information about business, preferences, or situation, update the key points into it, keep it brief, and date it.
From then on, it updates itself. Mention a new client once, and it already knows in the next session.
Step three, create an instruction file `claude-instructions.md`, clearly stating behavioral rules for each session: read the memory file before starting work, check past decisions before giving advice, ask if unsure—don't guess, proactively report after finishing work and mark areas needing human review.
Step four, in Claude Code, use `/add` to point to this folder, or write into CLAUDE.md. Once connected, at the start of every session, it already comes loaded with your full context.
This configuration has another benefit: if you switch to another AI tool someday, you can directly package and take your context with you.
Regarding saving money, there's an 80/20 approach: only use Fable 5 for that 20% of tasks that truly leverage its strengths.
In Claude Code, Fable can also dispatch cheaper sub-agents to do rough work: it comes up with the plan, Sonnet, Haiku, etc., execute it, and finally, it returns to validate.
At this point, you'll realize Boris's "Night Shift AI Army" breaks down to just three things:
A model that works autonomously, a set of standards defining "done," and a cycle that runs on schedule.
The model and the cycle are already in place.
What's truly scarce is the person who can clearly explain to the model "what a finished task looks like."
References:
https://safe.ai/blog/significant-increase-in-digital-labor-automation
https://x.com/free_ai_guides/status/2073050543027638443
https://youtu.be/SlGRN8jh2RI
https://x.com/bcherny/status/2007179861115511237
This article is from WeChat public account "Xinzhiyuan", edited by: Yuanyu
