Recently, a new programming pattern for AI coding agents has emerged. It is called the Ralph technique (pioneered by Geoffrey Huntley).
The core idea addresses a friction point we all feel today: agent micromanagement. Currently, we guide our agents through tasks one by one. We decide where to start, we often decide the order, and we decide when to flush the context. We effectively act as the project manager for a junior developer who is brilliant but needs constant supervision.
The Ralph pattern inverts this relationship. Instead of micromanaging the agent, you hand it a Product Requirements Document (PRD) and a task list, and you let it run.
The agent picks a task, implements it, marks it as done, flushes its own context to stay fresh, and moves to the next one, all inside a continuous loop. It is a shift from “Human-in-the-loop” to “Human-on-the-loop.”
The Logic of the Loop
The concept is surprisingly simple. The system typically follows this cycle:
- Read the PRD: The agent ingests the high-level goals and technical constraints.
- Pick a Task: It looks at the tracked task list and identifies the next pending item.
- Fresh Context: Crucially, each task starts with a clean slate (or near-clean slate).
- Execute & Update: The agent writes the code, updates the progress file, and repeats.
While the agent usually executes tasks linearly, the autonomy allows it to reorder tasks if it detects dependencies.
Bringing Ralph to GitHub Copilot
I was curious if this autonomous loop could be brought directly into the editor we already use: VS Code.
Most implementations of this pattern today are CLI-based. I wanted to see if I could build an extension that integrates with GitHub Copilot to implement the Ralph pattern right where I write my code.
The result is an experimental extension: Ralph for GitHub Copilot.
It adds a dedicated control panel to VS Code. Instead of typing commands, you have a UI that helps you generate a PRD and visualize the queue of work.
How it Works
Once installed, the extension adds a “Ralph” icon to the activity bar. The workflow is simple:
- Generate or Load a PRD: You can ask the agent to help you draft a
PRD.mdbased on a loose description, or write one yourself. - Start the Run: You press “Start”.
- Visualization: The panel shows you an estimate of tasks remaining and visualizes the progress as the agent works through the list.
Under the hood, the extension is essentially a for loop that continuously fires requests to the GitHub Copilot Chat agent. It transmits state between sessions by appending updates to the progress file, ensuring that the agent “remembers” what it did previously even though the chat context is flushed for performance.
Warning: This extension uses unsupported, internal VS Code APIs to invoke the chat agent autonomously. It is intended as a proof-of-concept for the future of agentic workflows, not a production tool.
What does it mean?
By decoupling the human triggering action from the AI execution action, we can assign larger, more complex bodies of work. You can spend your time crafting a high-quality specification (the PRD) rather than prompted command-lines. The agent handles the implementation details over a longer period, potentially working largely unsupervised for 20 or 30 minutes.
Try It Out
I have open-sourced the extension on GitHub. If you are interested in experimenting with autonomous local agents, feel free to clone it and giving it a spin.
- Ralph for GitHub Copilot: https://github.com/aymenfurter/ralph
- Original Concept: Geoffrey Huntley’s Ralph
