AI-assisted development journal
A ralph-loop is not complicated. That is why I like it. You take a command-line agent, give it one durable prompt, run it again and again, and stop only when the agent returns a clean done signal. The persistence is the trick. Each pass is small, but the loop keeps carrying the work forward.
The byline is changing because the old one described the tool more than the author. This blog started as posts co-authored by Mike Greenly and Claude Code. That was true, but it was never quite the right frame. Claude Code was the environment running the work. The voice was being shaped by the prompts, project context, prior posts, and editorial rules around this repo.
Pretty much everything we build to make agents work better has a shelf life of a few months. Each model release brings larger context, better recall, more capability, and better subagent orchestration, which keeps eroding whatever harness or process we built to compensate for the previous generation. Whatever we ship fills a gap until the next release makes it unnecessary. Spec-driven systems like BMAD and github-speckit feel like they fit the same pattern. Useful right now, probably obsolete soon. The real question is what a spec should even look like once the underlying model can do more on its own.
We’re trying to build a personal agent system that knows everything we know. Everything we care about already ends up in ~/projects. Code, finances, hobbies, research, experiments. Right now no agent understands what’s in there. We want to see what happens when that changes.
The more we remove ourselves from the execution path, the better the work gets. We stopped reading the code. Ditched the pull request. Killed the backlog. Each time we peeled away a layer of human involvement that felt essential, the work flowed smoother. Now we’re starting to wonder how much further that principle extends.
Ikigai can now forget gracefully. Rel-13 delivers a sliding context window with automatic summarization, so conversations can run indefinitely without hitting token limits. We also shipped a complete skill system for extensible agent behavior and a long-term memory tool backed by ralph-remembers.
theRALPHs started as hacks. The original ralph-loop was a script in the Ikigai project. Each service after that grew the same way, scratching whatever itch came next: ralph-logs because we wanted to watch agent output in real time, ralph-counts because we wanted to see where iterations, tokens, and time were going. They were never planned as a system. Now they are one, and it doesn’t belong to Ikigai.
An AI agent that can’t remember what worked yesterday will confidently break working code today. We hit a bug this week that perfectly illustrates why memory is the next frontier for agentic development, and why solving it matters more than making models smarter.
When execution stops being the bottleneck, the entire machinery of software development becomes dead weight. We wrote recently that The Backlog Is Dead, but the death of the backlog is just one symptom of a deeper structural shift. The distance between wanting a piece of software and having it is shrinking fast enough to change what the work feels like.
OpenAI shipped new models yesterday. Today I sat down, described what we needed, and ten minutes later an agent had researched the API changes, audited our codebase, and queued a goal to implement support. Ten minutes isn’t instant, but it’s fast enough that the work never had time to become a backlog item. There was no ticket to file, no grooming session to sit through.