# It's Not That Hard to Build Recursively Self-Improving AI

There's a question that comes up constantly in AI discourse, usually framed with appropriate gravitas: *How far away are we from recursively self-improving AI?*

The implied answer is always "far enough that we don't need to panic yet." The concept gets discussed in the context of superintelligence timelines, foom scenarios, and the kinds of capabilities that would require massive breakthroughs in architecture, training, or reasoning. It's treated as a threshold, a bright line between "interesting tool" and "existential concern." And most people, even people who think about AI risk seriously, tend to place that line comfortably in the future.

I want to offer a small piece of evidence that the line is closer than you think. Maybe not in the "superhuman intelligence recursively bootstrapping itself to godhood" sense. But a sense that matters for updating your models about what's coming.

The Experiment
--------------

I have no formal software engineering background. I'm a person who finds AI interesting and has access to Claude Code. Over a weekend, I built a system called [Autofiction](https://github.com/charlessanders72/Autofiction) that does the following:

1.  It writes a piece of fiction based on an autogenerated prompt.
2.  It analyzes the fiction it just wrote, evaluating prose quality, narrative structure, thematic coherence, and other dimensions.
3.  It uses that analysis to rewrite its own prompt, attempting to correct for the weaknesses it identified.
4.  It loops. Indefinitely.

That's it. That's the whole system. Write, evaluate, improve the instructions, repeat. Each cycle, the prompt that generates the fiction is slightly different — informed by the system's own assessment of what went wrong last time.

This is, by any reasonable structural definition, recursive self-improvement. The system is modifying the parameters that govern its own behavior based on its evaluation of its own outputs. It doesn't require human intervention. It runs continuously.

Yes, I Know
-----------

I can hear the objections forming already, and I want to be clear: they're mostly correct.

This is a toy model. The "self-improvement" is happening at the prompt level, not at the level of weights or architecture. The evaluation function is itself an LLM, which means it inherits all the limitations and blindspots of current language models. The fiction probably converges on some local optimum rather than improving forever. There is no risk here. Nobody needs to worry about Autofiction taking over the world.

All of that is true. And all of that somewhat misses the point.

The Update
----------

Here's what I think the takeaway should be: the *scaffolding* for recursive self-improvement is not hard to build. A person with no software background, using publicly available tools, can create a system that exhibits the core loop — act, evaluate, modify, repeat — in a weekend.

The usual story about recursive self-improvement involves a long list of prerequisites: the system needs to understand its own architecture, it needs to be able to modify its own code or weights, it needs a reliable evaluation function, it needs to avoid reward hacking, and so on. And for the scary, world-ending version of RSI, those prerequisites are real. But the structural pattern? The loop itself? That part turns out to be trivially achievable with current tools.

This matters because of a general heuristic I think is underappreciated in forecasting: *things that are easy to do in toy versions tend to become easy to do in serious versions faster than expected.* The gap between "proof of concept" and "real capability" is often smaller than the gap between "impossible" and "proof of concept." We've crossed the second gap. The first gap is a matter of degree, not kind.

I think the right Bayesian update from a project like Autofiction is this: if your model of "how hard is recursive self-improvement" was calibrated based on the assumption that the basic loop is an unsolved engineering problem, you should move your probability mass. The mundane version of a thing often precedes the transformative version by less time than we expect. Keep your eyes open.