Over the past few weeks, a new iterative technique for AI-assisted coding has attracted a great deal of attention online. Originally created by Geoff Huntley in May last year, it proposes a different way of using command-line AI tools such as Claude Code to generate working software as quickly as possible. Although it is most commonly discussed in the context of Claude, the same approach can be applied to other AI command-line interfaces, with the usual trade-offs in cost, configuration, and output quality. Unsurprisingly, the companies providing these tools are enthusiastic, as the technique consumes tokens at a remarkable rate, so users should be aware of the cost implications.

The approach has become known as “Ralph”, named after Ralph Wiggum from The Simpsons, because of its relentlessly optimistic and somewhat naïve persistence in pursuing a task until it meets the user’s definition of acceptable quality. Why this can work will become clearer shortly, but it is useful first to understand what the technique looks like in practice.

The underlying idea is straightforward. Instead of working interactively inside a single AI session, the user repeatedly feeds the AI its own output, along with failures, error messages, and other diagnostics, in a continuous loop. This process continues until the output satisfies the stated success criteria. At its simplest, this can be implemented as a shell loop that repeatedly passes a prompt file into the AI tool, with the user manually stopping execution once the result appears complete.

The reason this approach can be effective comes down to context. Every AI model has a fixed maximum context window that limits how much information it can consider at one time. When that limit is exceeded, earlier instructions and constraints can be forgotten, some of which may be essential. At the same time, each new interaction typically includes the entire prior conversation, steadily increasing token usage and cost. One way to deal with this is to ask the AI to summarise the current state and then start a new session using that summary. Claude can even do this automatically. However, summarisation is not always reliable, and important design principles or constraints may be lost in the process.

The “Ralph” technique avoids this by ensuring that each iteration begins with a fresh context. Because the loop runs outside the AI tool, the AI sees each execution as a new session. By designing the prompt so that it explicitly includes the results of previous runs, such as recent commits, test failures, and the definition of success, the process can gradually converge on an acceptable solution. Some users extend this by asking the AI to maintain a separate progress file that records its reasoning and decisions, although how effective this is depends on how well the prompts are constructed. The number of iterations required, and the number of tokens consumed, tends to come down to experience and judgement.

There is no shortage of online commentary claiming that this is a powerful new way to build software, although it is not always clear how many of those advocating it are working in professional enterprise environments. That said, the idea has gained enough traction that Claude Code now includes an official plugin inspired by the same principles.

This plugin introduces a more structured, disciplined version of the approach. Instead of relying on manual intervention, it uses a stop mechanism that halts execution once clearly defined completion criteria have been met. The user specifies what success looks like in advance, and the AI evaluates its own output against those conditions on each iteration. Output can be forced into a structured format, such as JSON, before being fed back into the next cycle, and a maximum number of iterations can be enforced to prevent runaway execution. Unlike the original Ralph approach, however, this plugin does not fully reset context between iterations. Instead, it automatically summarises and discards older context. As a result, it represents a more enterprise-friendly adaptation rather than a strict implementation of the original idea, though it still consumes tokens at a rapid pace.

In both cases, one of the most important practical lessons is the value of structured, machine-readable output. Encouraging the AI to write its non-code output in a consistent format makes it easier to understand what progress has been made and why certain decisions were taken. Similarly, providing the AI with clear reference files that describe the application’s purpose, principles, and constraints helps guide the process and reduce ambiguity. Ultimately, working effectively with AI-assisted coding tools is largely an exercise in careful context creation and management. Clear success criteria and precise instructions matter just as much as the choice of model or tooling.

Whether this approach genuinely improves outcomes is still open to debate. While there are credible examples of successful use, there are also many cases where the resulting code is difficult to read, overly complex, or makes poor use of modern language features. For this reason, a more traditional human-in-the-loop approach often remains preferable. In this model, the developer actively steers the process, reviews output as it is produced, and relies on the AI primarily to generate and execute tests or explore implementation options. This makes it far easier to explain and maintain the codebase later, particularly during handover, where simply asserting that large sections of code “work” but are hard to understand is rarely acceptable.

For those interested in experimenting with these techniques, free-tier AI accounts are unlikely to be sufficient. Higher-tier subscriptions are increasingly becoming a practical requirement for developers who want to use AI extensively. Even so, it is possible to explore these ideas meaningfully over a short period with a professional-level account, making it a worthwhile weekend experiment for those curious about the limits of AI-assisted development.

About Riskcare

Riskcare, part of the BIP Group, is a specialist financial services consultancy and technology partner at the forefront of FinTech innovation. With over 30 years of UK financial services experience, Riskcare delivers world-class trading and risk technology, complex software engineering, and quantitative financial modelling to clients across the capital markets, including investment banks, institutional investors, hedge funds, exchanges, commodities firms and insurance organisations.

Following its acquisition, Riskcare strengthening BIP’s xTech end-to-end Financial Services proposition and acting as a key differentiator in the market. The combination of Riskcare’s deep capital markets and risk engineering expertise with BIP’s scale, sector depth and transformation capabilities uniquely positions BIP to deliver complex, technology-led change across Financial Services.

With deep technical expertise and a collaborative, project-based delivery model, Riskcare helps clients solve their most challenging engineering, data and technology problems — from early-stage innovation and prototyping through to full implementation and enterprise-grade integration. Its globally distributed teams balance high-quality delivery with long-term service life, creating sustained value for clients and their customers.