"The AI now improves itself" is a powerful sentence.

But that phrase alone invites a misleading picture:

AI
  ↓
edits its own weights
  ↓
stronger AI
  ↓
edits its own weights again
  ↓
infinite loop

The reality in 2026 looks different.

AI already automates a large share of AI research and development. But Anthropic is explicit: we have not reached full recursive self-improvement yet.

So where are we now?

Define recursive self-improvement narrowly first

A simplified full loop looks like this:

AI_0
  ↓
designs and builds a better AI
  ↓
AI_1
  ↓
AI_1 designs its own successor
  ↓
AI_2
  ↓
...

The key point is not simply "AI writes code."

For the loop to close, the system must autonomously decide the successor's:

  • research direction
  • experiment design
  • implementation
  • training
  • evaluation
  • next improvement direction

That full loop is not automated yet.

But AI is already deep inside AI development

Anthropic's 2026 report When AI builds itself describes how much Claude is used in its own AI development.

As of May 2026, over 80% of merged code in Anthropic's codebase was authored by Claude.

In Q2 2026, merged code per engineer was roughly 8x higher than in 2024.

Anthropic also warns against reading that number as "8x productivity." Lines of code do not measure quality.

The real shift is this: the range of work you can hand off without implementing everything yourself keeps growing.

How far has research itself come?

Anthropic's distinction simplifies into three stages.

1. Running defined experiments

Human: sets goal and evaluation criteria
AI: edits code → runs → measures → repeats

This area is already strong.

Anthropic reports that recent internal models found much larger speedups than older models when optimizing small-model training code through repeated experiments.

2. Proposing which experiments to run

Find problem
  ↓
Generate hypothesis
  ↓
Select experiment
  ↓
Analyze result
  ↓
Next hypothesis

This stage is improving fast too.

Anthropic published cases where agents designed and iterated through multiple hypotheses and experiments on AI safety research problems.

3. Deciding what to research

Here the gap with humans is still large.

Which problem matters most?
Which objective should we optimize?
Which trade-offs should we accept?

That kind of direction-setting is far harder than implementation.

This gap is the key distance between today's AI-assisted R&D and full recursive self-improvement.

Do not confuse self-improving agents with recursive self-improvement

In practice, you will meet a smaller meaning of "self-improving agent" too.

For example, a PR review agent can collect human corrections and improve its next review rules:

Agent output
  ↓
Human correction
  ↓
Store failure pattern
  ↓
Propose skill / instruction update
  ↓
Eval
  ↓
Apply to next version

That is a useful self-improvement loop. But it lives on a different layer from full recursive self-improvement, where a system trains its own successor foundation model.

Anthropic's Warp case points in the same direction: an agent uses team corrections as a learning signal to improve skills.

CodeBridge Mini Lab: Build a safe self-improvement loop

You do not need to build full RSI.

Pick one small agent and start with a verifiable improvement loop.

Assume a PR review agent.

Step 1. Make a fixed eval set

20 PRs

- 8 with real bugs
- 8 normal changes
- 4 ambiguous changes

Write the expected result for each PR.

Step 2. Store failures

{
  "case": "pr_014",
  "failure": "missed_bug",
  "reason": "null handling path not checked"
}

Step 3. Ask the agent to propose skill fixes

Example:

Look at the current review instructions and the failure logs.
Propose the smallest rule change that would reduce
the same type of error on the next run.

Step 4. Do not ship it straight to production

This step matters most.

candidate skill
  ↓
held-out eval
  ↓
check regressions on prior successes
  ↓
human approval
  ↓
promotion

Just because a system "improves itself" does not mean it should deploy itself.

Separate proposal rights from rollout rights. That separation lets improvement accumulate while staying controlled.

Why is self-improvement risky without evals?

Even if an agent can edit its own prompt or skills, it will drift without a clear definition of "better."

Give a PR review agent only this goal:

Find more issues

You may get a flood of false positives.

So an improvement loop needs at least this much:

Success metric
Regression set
Cost limit
Change log
Rollback
Human approval boundary

That structure is closer to a harness and loop design problem than a model intelligence problem.

What is the real bottleneck for recursive self-improvement?

If you look only at coding ability, progress is very fast.

But building a successor model on its own raises bigger problems.

Goal setting

A good benchmark score is not the same as a genuinely better model.

Experiment selection

The experiment space is huge. You must judge where compute is worth spending.

Evaluation

If AI evaluates AI-made models, judge bias and reward hacking can creep in.

Safety and control

Performance alone cannot be the only goal.

So as RSI gets closer, human work is less likely to disappear than to move from implementation toward verification, goal-setting, and supervision.

Conclusion: AI-assisted AI development has started, but the loop is not closed

The most accurate summary for 2026 is this:

AI is automating AI research and development quickly, but it does not yet set goals for its successor, design it, train it, verify it, and build the next version in a fully recursive loop.

Do not miss the current shift while staring only at the final stage.

Already today, much of this chain is automated:

Human goal
  ↓
Agent implementation
  ↓
Experiment
  ↓
Evaluation
  ↓
Iteration

The practical question is not "When will AI fully build itself?" It is what evals and controls you will put around the automated loop.

Related posts

References

Go deeper with a course

If you want hands-on practice with safe loops, harnesses, and graph-style agent workflows in a real repository, learn by building.