Anthropic is testing how far Claude Code can automate routine software maintenance by allowing the AI coding agent to work on the company’s own applications every day. Over the past few weeks, Claude has created 388 pull requests across Anthropic’s repositories, with 180 eventually merged after automated and human review, giving the system a 46% merge rate.
The experiment is being led by Boris Cherny, the Anthropic engineer who created Claude Code. The system uses a collection of automated maintenance routines that operate across Anthropic’s iOS, Android, desktop, web, CLI and Agent SDK platforms. The results suggest that AI agents can already handle a meaningful share of repetitive engineering work, although the fact that more than half of the generated pull requests were not merged also highlights the limitations of fully autonomous software maintenance.
Claude Code Takes Over Daily Maintenance Tasks
Anthropic has been using Claude Code to perform repetitive maintenance work that would otherwise require engineers to spend time on relatively mechanical changes.
The system operates through a dedicated Slack workflow and runs a collection of specialised routines on a daily basis.
Rather than simply asking Claude to write code, Anthropic gives it specific maintenance objectives and allows the agent to inspect real applications, identify problems, make changes and create pull requests.
How the System Works
Daily maintenance task
↓
Claude Code routine
↓
Inspect Anthropic software
↓
Identify issue or improvement
↓
Modify code
↓
Run checks
↓
Create pull request
↓
Claude review
↓
Human review
↓
Merge or reject
This workflow allows Anthropic to evaluate whether AI agents can become a persistent part of software maintenance rather than being used only when developers actively request assistance.
Twelve Routines Handle Different Maintenance Jobs
Anthropic has created a set of specialised routines designed to address different categories of software maintenance.
These routines target problems ranging from application crashes and logic bugs to dead code, flaky tests and unnecessary abstractions.
| Routine | Function |
|---|---|
| Crash Fuzzer | Finds application crashes and generates fixes |
| Ant-only Shipper | Delivers or removes forgotten internal features |
| Logic Simplifier | Simplifies complicated business logic |
| Logic Bug Fixer | Finds and fixes errors in complex logic |
| Dup Unifier | Identifies duplicate implementations |
| Dead-Code Remover | Removes code that is proven to be unreachable |
| Useless Test Pruner | Removes tests that can never fail |
| Shipped-Feature Inliner | Removes feature flags from fully released features |
| Flaky-Test Fixer | Identifies and fixes unstable tests |
| Abstraction Improver | Simplifies over-engineered abstractions |
| Abstraction Police | Addresses architectural layer violations |
The routines are designed to perform relatively focused tasks rather than attempting to independently manage an entire software project.
Claude Can Search for Real Application Crashes
One of the more ambitious routines is the Crash Fuzzer.
The system opens Anthropic applications in a simulator and interacts with them in an attempt to trigger crashes.
When it finds a failure, Claude analyses the problem, identifies a likely root cause and creates a proposed fix.
Crash-Fuzzing Workflow
Open application
↓
Interact with the app
↓
Trigger unexpected behaviour
↓
Identify crash
↓
Analyse root cause
↓
Generate fix
↓
Create pull request
This gives Anthropic a way to automate part of the traditionally repetitive process of finding and fixing application crashes.
The System Uses Real Apps Instead of Mocks
Anthropic’s Claude Code creator said the maintenance routines were instructed to use real applications rather than mocks for certain tasks.
That distinction matters because simulated environments do not always reproduce the conditions under which software fails in production.
By interacting with actual applications, Claude can potentially uncover problems that would not appear in simplified test environments.
Real-World Testing
Mock environment
↓
Limited simulation
↓
Potentially fewer failures
VS
Real application
↓
Actual user interface
↓
Real interactions
↓
Potential crashes
↓
AI-generated fixes
This approach could make autonomous maintenance more useful for large software projects.
Claude Also Removes Dead Code
Another routine focuses on identifying code that is no longer reachable.
Software projects accumulate unused code over time as features are removed, replaced or redesigned.
Removing this code can make a codebase easier to understand and maintain.
However, incorrectly deleting code can introduce bugs.
Dead-Code Removal
Codebase
↓
Find potentially unreachable code
↓
Check whether code is actually unused
↓
Remove confirmed dead code
↓
Create pull request
For suspicious cases, the routine can first add logging and observe whether the code is used before removing it.
This demonstrates how AI agents can use an iterative approach instead of making an immediate irreversible change.
Claude Can Fix Flaky Tests
Anthropic also uses a Flaky-Test Fixer to identify unstable tests.
Flaky tests are tests that sometimes pass and sometimes fail without a meaningful change to the underlying software.
They can slow down development and make continuous integration systems less reliable.
Flaky-Test Workflow
Test fails intermittently
↓
Claude investigates
↓
Identifies likely cause
↓
Modifies test or implementation
↓
Runs test again
↓
Creates pull request
↓
Human review
Automating this work could reduce the amount of engineering time spent investigating recurring test failures.
Another Routine Removes Duplicate Code
The Dup Unifier routine searches for different implementations that perform essentially the same function.
Over time, large software projects can accumulate multiple versions of similar abstractions.
Combining them can reduce complexity and make future maintenance easier.
Code Duplication
Implementation A
+
Implementation B
+
Implementation C
↓
Similar functionality
↓
Claude identifies overlap
↓
Proposes unified implementation
↓
Review
↓
Merge
This is an example of maintenance work that is well suited to AI because it requires searching across large codebases and identifying structural similarities.
Claude Can Simplify Complex Logic
The Logic Simplifier routine looks for unnecessarily complicated business logic.
Complex code can increase the risk of future bugs and make it harder for developers to understand how a system behaves.
Claude can analyse the existing implementation and propose a simpler version.
Logic Simplification
Complex implementation
↓
AI analysis
↓
Identify unnecessary complexity
↓
Simplified implementation
↓
Automated testing
↓
Human review
↓
Merge
The process allows engineers to focus on higher-level decisions while the AI handles some of the repetitive code cleanup.
Anthropic Says Prompt Engineering Is Minimal
An important detail about the experiment is that Anthropic is not relying on elaborate prompt engineering for these routines.
Cherny shared examples of simple natural-language instructions used to tell Claude what the routines should do.
For example, Claude can be instructed to run daily crash-fuzzing routines on iOS, Android and desktop, use real applications, investigate crashes and create pull requests with fixes.
Simple Instructions
“Run daily crash fuzzing”
↓
Use real applications
↓
Trigger crashes
↓
Find root causes
↓
Create fixes
↓
Open pull requests
The simplicity of the instructions suggests that the capability is increasingly coming from the underlying AI agent and its ability to operate tools rather than from highly complex prompts.
Claude Created 388 Pull Requests
The most significant result from the experiment is the number of pull requests Claude generated.
Across Anthropic’s repositories, Claude created 388 pull requests during the first few weeks of the experiment.
That represents a substantial amount of software-maintenance activity performed without developers manually initiating every individual task.
Output From the Experiment
388 pull requests created
↓
180 merged
↓
208 not merged
↓
46% merge rate
The results show both the productivity potential and the current limitations of autonomous coding agents.
180 Pull Requests Were Merged
Of the 388 pull requests created by Claude, 180 were eventually merged.
That gives the system an approximately 46% merge rate.
The figure does not mean that Claude independently shipped 46% of its work directly into production. The pull requests went through automated Claude review and human review before being merged.
Review Process
Claude creates pull request
↓
Automated review
↓
Human review
↓
Approved
↓
Merged
OR
↓
Rejected
The human review stage remains an important safety mechanism.
More Than Half of Claude’s Pull Requests Were Rejected
The 46% merge rate also means that 208 of the 388 pull requests were not merged.
This is an important qualification to the productivity story.
Claude was able to generate a large amount of potentially useful maintenance work, but a majority of its proposals did not ultimately make it into the codebase.
What the Numbers Show
388 pull requests
↓
46% merged
↓
54% not merged
↓
AI is productive
BUT
↓
Human oversight remains important
The result suggests that autonomous coding is not yet equivalent to fully reliable engineering automation.
Claude Often Gets the Work Right on the First Attempt
According to Cherny, Claude generally produces the correct solution on its first attempt.
When the system does fail, Anthropic modifies the relevant routine so that Claude can perform better during the next run.
This creates a feedback loop in which the automation itself is continuously improved.
Improvement Loop
Claude runs routine
↓
Pull request rejected
↓
Anthropic analyses failure
↓
Routine is adjusted
↓
Claude runs again next day
↓
Performance improves
The tuning process can sometimes take several days.
Anthropic Is Trying to Speed Up the Merge Process
The company is now investigating ways to make the review and merge process faster for these types of mechanical changes.
The objective is not necessarily to eliminate human review immediately, but to reduce the amount of time required to evaluate straightforward AI-generated maintenance work.
Current Process
AI generates change
↓
Automated review
↓
Human review
↓
Merge
Potential Future Process
AI generates change
↓
Automated validation
↓
High-confidence changes
↓
Faster approval
↓
Merge
The challenge is determining which changes are safe enough to move through the pipeline more quickly.
Why a 46% Merge Rate Matters
A 46% merge rate may initially appear low compared with the standards expected from human engineers.
However, the experiment is not simply measuring whether Claude can write correct code.
The system is operating continuously and generating pull requests for tasks that engineers may otherwise not have time to prioritise.
Traditional Maintenance
Engineer identifies task
↓
Prioritises task
↓
Works on issue
↓
Writes code
↓
Tests
↓
Creates pull request
↓
Review
AI Maintenance
Routine runs automatically
↓
Claude identifies task
↓
Writes code
↓
Tests
↓
Creates pull request
↓
Review
↓
Reject or merge
The second model could generate useful work at a much larger scale even if only part of the output is eventually accepted.
AI Agents Can Work While Engineers Focus Elsewhere
One of the main advantages of automated routines is that they can run without requiring a developer to sit in front of a computer.
An engineer can focus on product development or more complex technical work while Claude handles background maintenance.
Division of Labour
Claude
↓
Routine maintenance
+
Testing
+
Code cleanup
+
Bug discovery
VS
Human engineers
↓
Architecture
+
Product decisions
+
Complex debugging
+
Review
This could become an increasingly common model for software engineering teams.
Autonomous Maintenance Could Become a New Software Workflow
Traditional coding assistants generally wait for a developer to ask a question or assign a task.
Autonomous maintenance systems reverse that relationship.
Instead of waiting for instructions, the AI regularly searches for work that needs to be done.
Traditional AI Coding
Developer
↓
Assigns task
↓
AI writes code
↓
Developer reviews
Autonomous Maintenance
Schedule
↓
AI searches for maintenance opportunities
↓
AI writes code
↓
AI tests changes
↓
AI creates pull request
↓
Developer reviews
This moves coding agents closer to autonomous software operations.
The Experiment Builds on Anthropic’s Broader Claude Code Strategy
Anthropic has been steadily expanding Claude Code beyond basic code generation.
The company has introduced features that allow Claude Code to operate development servers, interact with applications, respond to events and run scheduled tasks.
The maintenance experiment is another step toward making Claude Code an active software-engineering agent.
Evolution of Claude Code
Code generation
↓
Repository editing
↓
Tool use
↓
Application interaction
↓
Scheduled tasks
↓
Autonomous maintenance
↓
Continuous software engineering
This trajectory reflects the industry’s broader movement toward agentic AI.
Software Engineering Is Currently the Leading AI Agent Use Case
Software development has emerged as one of the areas where AI agents are already being used at scale.
Coding environments provide clear objectives, structured feedback and automated tests, making them particularly suitable for agentic systems.
Why Coding Works Well for Agents
Clear task
↓
Code change
↓
Automated tests
↓
Pass or fail
↓
Feedback
↓
AI improves
The availability of automated validation makes it easier for an AI agent to work autonomously than in many other professional fields.
Testing Provides a Feedback Mechanism
One reason AI coding agents can work effectively is that software provides objective feedback.
A change can be compiled, tested and checked against existing behaviour.
If the test fails, the agent can attempt another solution.
Agent Feedback Loop
Write code
↓
Run tests
↓
Tests pass
↓
Potentially correct
OR
↓
Tests fail
↓
Analyse failure
↓
Modify code
↓
Run tests again
This feedback mechanism is critical for autonomous software development.
But Tests Are Not Perfect
Passing tests does not guarantee that software is completely correct.
Tests may fail to cover unusual scenarios, security vulnerabilities or unexpected user behaviour.
This is why Anthropic continues to use human review for Claude-generated pull requests.
AI Validation Limits
AI change
↓
Tests pass
BUT
↓
Potential hidden bug
OR
↓
Missing test coverage
OR
↓
Architectural problem
↓
Human review required
The 46% merge rate should therefore be viewed in the context of this layered review process.
The Experiment Could Reduce Maintenance Debt
Software maintenance often competes with new product development for engineering resources.
Teams may postpone refactoring, dead-code removal, flaky-test fixes and small bugs because more visible projects take priority.
AI routines could continuously work through this backlog.
Maintenance Debt
Small bugs
+
Dead code
+
Duplicate code
+
Flaky tests
+
Complex logic
↓
Growing maintenance backlog
↓
AI routines
↓
Continuous cleanup
↓
Lower maintenance burden
If successful, this could improve software quality over time without requiring dedicated engineering teams for every task.
AI Could Increase the Amount of Code Maintained
There is also a broader implication.
If AI makes maintenance cheaper, companies may become more willing to maintain larger and more complex codebases.
This could potentially create a cycle in which AI generates more software and then helps maintain that software.
AI Software Cycle
AI generates more code
↓
Larger software systems
↓
More maintenance work
↓
AI maintenance routines
↓
Lower maintenance cost
↓
More software development
The result could be a significant increase in the amount of software produced and maintained by relatively small engineering teams.
Human Engineers Still Set the Rules
Despite the autonomy of the routines, Anthropic’s engineers remain responsible for defining what Claude is allowed to do.
The routines have specific objectives and are subject to review.
This means the experiment is better described as supervised autonomy than completely independent software development.
Supervised Autonomy
Human defines objective
↓
AI operates independently
↓
AI proposes changes
↓
Automated checks
↓
Human review
↓
Production
This model allows organisations to gain some of the benefits of autonomous agents while retaining human control.
What It Means for Software Developers
For developers, the experiment suggests that some traditional maintenance responsibilities could increasingly be delegated to AI.
Routine tasks such as fixing flaky tests, cleaning up dead code and simplifying implementations may become less dependent on manual engineering time.
Developers could increasingly focus on:
- Architecture
- Product development
- Complex debugging
- Security
- System design
- Reviewing AI-generated changes
- Setting engineering standards
The role of the software engineer could therefore shift from writing every change manually toward supervising larger amounts of AI-generated work.
What It Means for Engineering Teams
Engineering teams could potentially increase their output without increasing headcount at the same rate.
AI routines can run continuously and create pull requests while human engineers work on other priorities.
However, teams will need effective review systems to prevent low-quality AI output from creating additional work.
Engineering Team Model
Human engineers
+
Claude Code routines
↓
More maintenance activity
↓
More pull requests
↓
Automated filtering
+
Human review
↓
Higher engineering throughput
The effectiveness of the model will depend on how efficiently teams can separate useful changes from unnecessary ones.
What It Means for Anthropic
For Anthropic, the experiment has particular significance because the company is using its own software as a testing ground for Claude Code.
This gives Anthropic an opportunity to identify weaknesses in its coding agent under real production-development conditions.
It also creates a feedback loop between Claude Code’s capabilities and Anthropic’s internal engineering practices.
Anthropic’s Internal AI Loop
Claude Code
↓
Maintains Anthropic software
↓
Engineers observe performance
↓
Identify weaknesses
↓
Improve Claude Code
↓
Better maintenance
↓
More internal adoption
This could accelerate development of Anthropic’s own coding products.
The Experiment Could Influence Enterprise Adoption
Businesses evaluating AI coding agents will likely pay attention to Anthropic’s internal results.
A real-world example involving hundreds of pull requests is more informative than benchmark scores alone because it demonstrates how an AI agent performs inside a large software organisation.
Enterprise Question
Can AI generate code?
↓
Yes
↓
Can AI complete coding tasks?
↓
Increasingly yes
↓
Can AI maintain production software?
↓
Anthropic is testing this now
↓
Can companies trust it without human review?
↓
Still an open question
The experiment could therefore serve as a reference point for other enterprises considering similar deployments.
Security Will Remain a Major Concern
Giving an AI agent permission to modify production code introduces security risks.
A compromised tool, malicious dependency or incorrect AI-generated change could potentially affect important systems.
Organisations adopting autonomous maintenance will need strong permission controls, testing environments and review processes.
Secure AI Maintenance
AI agent
↓
Limited permissions
↓
Sandboxed environment
↓
Automated tests
↓
Security checks
↓
Human review
↓
Production deployment
The more autonomy AI agents receive, the more important these safeguards become.
AI Agents Could Eventually Handle Larger Software Tasks
The current experiment focuses heavily on maintenance.
But the same infrastructure could eventually be applied to larger engineering projects.
An agent might eventually be able to monitor a codebase, identify priorities, implement features, test them and prepare changes for human approval.
Future Software Agent
Monitor repository
↓
Identify issue
↓
Plan solution
↓
Write code
↓
Run tests
↓
Review own work
↓
Create pull request
↓
Human approval
↓
Deploy
That would represent a much broader transformation of software development.
Key Numbers at a Glance
| Metric | Figure |
|---|---|
| Pull requests created | 388 |
| Pull requests merged | 180 |
| Merge rate | About 46% |
| Pull requests not merged | 208 |
| Maintenance period | A few weeks |
| Platforms covered | iOS, Android, desktop, web, CLI and Agent SDK |
| Maintenance routines | 12 |
| Human review | Yes |
| Automated Claude review | Yes |
Infographic: How Claude Maintains Anthropic’s Software
ANTHROPIC SOFTWARE
↓
12 MAINTENANCE ROUTINES
↓
CRASH FUZZING
+
BUG FIXING
+
DEAD-CODE REMOVAL
+
FLAKY-TEST FIXES
+
CODE SIMPLIFICATION
+
DUPLICATE CODE REMOVAL
↓
CLAUDE CODE RUNS DAILY
↓
388 PULL REQUESTS
↓
AUTOMATED + HUMAN REVIEW
↓
180 MERGED
↓
46% MERGE RATE
↓
ROUTINES IMPROVED FROM FAILED ATTEMPTS
↓
CONTINUOUS AI-ASSISTED MAINTENANCE
What Investors Should Watch
Investors and technology companies should watch whether Anthropic can increase the percentage of AI-generated changes that are successfully merged.
Important indicators include:
- Pull requests generated per week
- Merge rate
- Human review time
- Automated testing success
- Number of bugs discovered
- Maintenance backlog reduction
- Engineering productivity
- Cost per successful change
- Security incidents
- Expansion to larger engineering tasks
AI Engineering Productivity
More autonomous routines
↓
More maintenance work
↓
More pull requests
↓
Higher merge rate
↓
Less human review time
↓
Greater engineering productivity
If Anthropic can substantially improve the merge rate while maintaining software quality, autonomous maintenance could become an important component of modern software engineering.
The Bigger Picture
Anthropic’s Claude Code experiment shows that AI coding agents are moving beyond helping developers write individual functions or fix isolated bugs. The company is now allowing Claude to continuously search its own software for maintenance opportunities, interact with real applications, identify crashes, simplify code, remove dead code and fix unstable tests. In just a few weeks, the system created 388 pull requests, with 180 merged after automated and human review.
The 46% merge rate is significant because it demonstrates both the potential and the limitations of autonomous software maintenance. More than half of Claude’s proposals were not merged, meaning human engineers still play an essential role in deciding which changes are safe and useful. However, the ability to generate hundreds of maintenance proposals automatically could change the economics of software engineering if AI agents become better at filtering their own work and producing higher-confidence changes.
Looking Ahead
Anthropic’s experiment suggests that the next stage of AI coding may involve continuous software maintenance rather than simply responding to developer prompts. Claude Code can already run scheduled routines that search for crashes, simplify logic, remove unnecessary code, fix flaky tests and create pull requests without an engineer manually initiating each task. As these systems improve, engineering teams could increasingly rely on AI to handle routine maintenance while developers focus on architecture, product decisions, security and complex technical problems.
The biggest challenge will be increasing reliability without removing necessary human oversight. A 46% merge rate means Claude is producing substantial useful output, but it is also generating a large amount of work that still requires rejection or modification. Anthropic’s plan to improve routines based on failed pull requests could gradually raise the success rate. If that feedback loop works, autonomous AI maintenance could become a standard part of software development, allowing relatively small engineering teams to maintain larger and more complex software systems.
Get the day’s top stories in your inbox
One concise email. No spam, unsubscribe anytime.
