I Tried an Autoresearch Loop. One Prompt Scored Higher.
I adapted a keep-or-revert loop to improve an email, then compared it with a single Claude prompt. The simpler approach scored higher.
I built an autoresearch-style loop to improve a deliberately bad email. After 20 iterations, its score went from 22.7 to 89.5 out of 100. Then I gave Claude the original email and the goals file in a single prompt. That version scored 99.
For this email, the straightforward prompt worked better than my loop. Building the loop was still useful: it gave me a much clearer understanding of what I was optimizing and how much the evaluator mattered.
This article combines my March 12 and March 13, 2026 write-ups into one account of the experiment.
What needed a GPU, and what didn’t
Andrej Karpathy’s autoresearch got me interested in the pattern. An agent changes training code, runs a short training experiment, measures the result, and keeps or discards the change before trying again.
The original implementation used PyTorch and CUDA for actual model training, with an NVIDIA GPU as a requirement. I had an AMD card and didn’t want to spend the experiment sorting out a different training setup.
But I didn’t need to train a model to try the same decision loop on something else. What if the artifact was a document, and the evaluation was a set of checks plus an LLM score?
My version ran Python locally and called the Anthropic API for editing and judging. It needed no local GPU and did no model training.
First, a document
I started with a Markdown product specification containing vague strategies, contradictions, and missing details. An editing call proposed one targeted change, a separate judging call scored the result against written goals, and git kept or reverted the edit.
After five iterations, the score rose from 62 to 72. Two edits were kept and three were rejected.

One rejected edit tried to resolve a contradiction between “real-time” health scores and nightly recalculation. The judge scored the edited version lower, so the loop threw it away. That made the mechanics easy to see: the keep-or-revert decision followed the score, rather than my opinion of the proposed fix.
The first prototype is on GitHub.
Then, an email
For the second version, I used a purposefully bad cold outreach email and combined five evaluators:
- A spam-trigger word checker.
- Structural checks for things such as an unsubscribe link and mailing address.
- Image alt-text coverage.
- A check for competing calls to action.
- An LLM judge scoring the email against a written rubric.
Each evaluator returned a score, and the weighted total determined whether an edit was kept. These were checks on the email’s content and structure, not a test of actual inbox placement.
I also added a meta-loop that reviewed the scoring rubric every five iterations and could revise it when progress stalled.
The 20-iteration run improved the reported score from 22.7 to 89.5. It cleaned up spammy language, consolidated calls to action, and added alt text.

It worked. The next question was whether I needed that much machinery for one email.
Comparing it with a single prompt
I uploaded the original email and goals.md to Claude and asked it to improve the email in one pass.


Then I ran the result through the experiment’s evaluators. It scored 99 out of 100, ahead of the loop’s 89.5.

I tried a simpler prompt without supplying the goals file as well.

That output scored 85: below the loop, but close, and with much less work.

| Approach | Reported score |
|---|---|
| Original email | 22.7 |
| 20-iteration loop | 89.5 |
| Single prompt with the goals file | 99 |
| Simpler prompt without the goals file | 85 |
These were results from a small experiment, not a repeated benchmark. The LLM judge could vary between calls, and the meta-loop could change its rubric. The numbers tell the story of these runs; they aren’t a universal ranking of the approaches.
What I took away
For a short email with obvious problems, giving Claude the goals and asking for one rewrite was the better approach in my test. I’d start there before building an optimization loop around a similar task.
The loop itself was interesting to build and watch. Every iteration had a proposed change, an evaluation, and a clear keep-or-revert decision. The evaluator controlled that decision independently of the editing call. The important design choice was what the score represented: a higher score meant the output satisfied those checks better, rather than proving every aspect of the email had improved.
I’m still interested in applying the pattern where there’s a useful, repeatable feedback signal and enough room to explore many changes. For this experiment, though, a clear goals file did more for the result than adding more iterations.