# Build Dumb AI Loops That Ship

Chris Parsons, Cherrypick | AI Engineer Europe 2026 | 1:48:26

Source: https://www.youtube.com/watch?v=2TLXsxkz0zI
Channel: AI Engineer (https://www.youtube.com/@aiDotEngineer). Summarised by AIE Talks.
Page: https://aietalks.com/talks/build-dumb-ai-loops-that-ship
Published: 2026-05-04
Tags: agents, coding-agents, harness-engineering, reliability, workflows

## TL;DR
- A Ralph Loop can be as simple as repeatedly asking an AI to implement the next task, then using tests and feedback to catch what it missed.
- Sequential loops are often easier to manage than parallel agents because the AI can choose the next most important ticket from the current state.
- The loop only works as well as its instructions, validation, permissions, and stopping rules, which must be adapted to the project.

## Summary
Chris Parsons runs a practical workshop on using Ralph Loops with Claude Code and Codex. He starts with a small Pomodoro timer, a folder of tickets, and a basic command that asks the agent to implement a ticket. The simplest automation is a shell while-loop, but Parsons shows how the approach can grow into a system that selects the next important ticket, uses TDD, updates status, commits changes, and validates its own work. He argues that sequential work is a better starting point than coordinating many agents in parallel. Feedback matters, especially when it comes from a fresh sub-agent rather than the agent that wrote the code. Parsons also applies loops to newsletters, project management, email drafts, daily briefings, and startup planning. He is direct about the limits: humans still define quality, review security-sensitive changes, control irreversible actions, and decide when work is complete.

## Key ideas
### A simple loop can replace a brittle AI workflow
[00:14](https://www.youtube.com/watch?v=2TLXsxkz0zI&t=14s)
Parsons contrasts a complicated n8n newsletter workflow with a Claude Code skill. The old workflow took about a week to build and regularly failed at 2:00 p.m. on Mondays, forcing him to debug the broken node. His newer skill lets Claude read instructions, choose the next step, call tools, and continue until it produces a newsletter. He says the result is a better first draft and needs little manual maintenance. The underlying pattern is a loop: read context, take an action, return to the instructions, and decide what to do next.

### A Ralph Loop repeats work so the agent can find its own omissions
[08:42](https://www.youtube.com/watch?v=2TLXsxkz0zI&t=522s)
The name comes from Ralph Wiggum in The Simpsons, who keeps trying the same thing until it works. Parsons describes the method as asking the AI to build or change something, then asking it to do the same task again. On the second pass, the model may notice that it missed a requirement or failed to finish a related update. In the live demo, Claude first adds a status command to a Pomodoro timer and creates a test. On another pass, it notices that the ticket itself should be marked done. Newer models often need fewer repetitions, but the basic technique remains simple.

### The dumbest useful Ralph Loop is a while-loop over tickets
[17:37](https://www.youtube.com/watch?v=2TLXsxkz0zI&t=1057s)
Parsons shows a shell pattern equivalent to while true, run Claude, and ask it to implement a ticket. The workshop project stores possible changes as files in a tickets folder. A better instruction is to implement the next most important ticket using TDD principles and commit when finished. Claude reads several tickets, chooses one, writes the test first, implements the change, marks the ticket done, and continues. The loop can run in a fresh session each time or stay inside one Claude Code session. Parsons says the choice depends on how useful the accumulated context is.

### Choosing the next ticket is easier than planning every dependency in advance
[22:12](https://www.youtube.com/watch?v=2TLXsxkz0zI&t=1332s)
Parsons describes an unsuccessful experiment in which he asked Claude to split a large project into many tickets, map all dependencies, and coordinate six or seven agents in parallel. Agents collided over shared tickets and sometimes implemented the same work. He compares this with a waterfall process that tries to specify everything before development starts. His simpler approach gives the AI the whole ticket list and says to pick the next most important item. The model can inspect the current state and work out dependencies as it goes. He recommends starting with one sequential loop before adding parallelism.

### A loop needs project-specific instructions and feedback
[33:28](https://www.youtube.com/watch?v=2TLXsxkz0zI&t=2008s)
Parsons warns that a bare instruction such as 'build the next ticket' is too vague. A useful loop must explain how to test the project, how to refactor, how to mark work complete, how to handle Git state, and what to do after a crash. He adds instructions such as running the simplify skill and reducing duplication. Over time, the loop becomes a record of the project's working practices. It can use flat Markdown tickets, Beads, Linear, Jira, or another system that the agent can access. The prompt should evolve after reviewing what the agent actually produced.

### Fresh sub-agents can review code more honestly
[55:33](https://www.youtube.com/watch?v=2TLXsxkz0zI&t=3333s)
A participant reports that validation began finding problems after moving it into sub-agents. Parsons agrees that the same agent can show confirmation bias, effectively approving code it just wrote. A sub-agent starts with a smaller, separate context and can inspect the result from a different position. He points to Claude Code's simplify skill, which uses three sub-agents to examine recent changes and suggest improvements. He also describes using simulated audience personas to review newsletters from different perspectives. The same pattern can apply to software: have one agent build, another inspect, and pass the findings back for another iteration.

### Stopping rules should be based on irreversible actions and review points
[1:09:19](https://www.youtube.com/watch?v=2TLXsxkz0zI&t=4159s)
For open-ended work, Parsons does not rely on a universal KPI or a single stopping condition. Each loop needs its own boundary. His worker loop should stop when it runs out of context or reaches an irreversible action, then update the project file with its progress and hand the decision back to him. His personal rule is whether an action is reversible without embarrassing him. The agent can prepare an email or create a slide deck, but it cannot send messages or perform other actions he wants to approve. The human remains the final verifier for work that matters.

### Security requires limiting permissions, secrets, and untrusted input
[52:36](https://www.youtube.com/watch?v=2TLXsxkz0zI&t=3156s)
Parsons runs much of his work on a separate VPS with separate keys and read-only access where possible. He does not allow the agent to send email, and he is building Lockbox to restrict file-system access after untrusted input is read. He recommends Docker Sandbox for isolating code in a container, while noting that data can still leak between systems. He cites Simon Willison's 'lethal trifecta': untrusted tokens, internet access, and access to sensitive data in the same context. His advice is to reduce collisions between those capabilities and choose permissions according to the risk of the task.

### Knowledge management can stay in Markdown files and a searchable vault
[1:26:21](https://www.youtube.com/watch?v=2TLXsxkz0zI&t=5181s)
Parsons keeps a code directory and a vault directory. The vault contains thousands of Markdown files covering research, transcripts, notes, and work with Claude. He uses Obsidian alongside Claude and follows a Zettelkasten-style approach with one note per thought in a flat folder. Projects have their own files with context, questions, contacts, decisions, and progress. He also uses Lianne, a command-line embeddings tool, to search across the repository. A VCP command starts a new Claude Code session that loads the relevant project context. Fresh sessions force useful information from previous work into files that another session can find.

## Notable quotes
- "The dumbest Ralph loop is literally that just a while loop and it just goes through and implements stuff." (18:27)
- "There's no kind of magic to a Ralph loop, it's just a loop." (48:18)
- "My basic rule is, is this reversible without embarrassment to me? And, if the answer is no, don't do it." (1:11:29)
- "The constraint in those teams might be the review process. If you or the release process, if you release your code once a month, and you're shipping 200 PRs not 20 in that release, how do you think that's going to go?" (1:36:00)
- "If you're able to get an AI to click through your project to check that it works, that's really powerful." (1:24:26)

## Tools & references mentioned
- Claude Code
- Codex
- Cursor
- n8n
- Ralph Wiggum
- Matt Pocock
- Beads
- Steve Yegge
- Linear
- Jira
- Docker Sandbox
- Lockbox
- Simon Willison
- OpenClaw
- Anthropic
- Claude Opus 4.6
- Claude Sonnet 4.6
- GPT-5.1
- Nano Banana Pro
- Superpowers
- Playwright
- Obsidian
- Lianne
- Andrej Karpathy
- Ash Maurya
- The Goal
- Eliyahu Goldratt
- Air Skills

## Who should watch
- You are using Claude Code or Codex for software work and want a small, practical automation to process tickets.
- Your agent frequently declares work complete while missing tests, status updates, refactors, or user-facing behavior.
- You are considering multi-agent orchestration and want to understand the simpler sequential approach before adding parallel workers.

## Related talks

- [Loop Engineering from First Principles](https://aietalks.com/talks/loop-engineering-from-first-principles) (Kyle Mistele, HumanLayer, 17:57)
- [The Great Loops Debate](https://aietalks.com/talks/the-great-loops-debate) (Ali Howard & Ian Livingstone, Keycard & Geoff Huntley & Greg Pstrucha, Sentry & Dex Horthy, HumanLayer, 1:00:16)
- [Everything Is a Rollout](https://aietalks.com/talks/everything-is-a-rollout) (Alex Shaw & Ryan Marten, Laude Institute, 21:11)
- [BDD, ADR, PRD, WTF: Capturing Decisions for Humans and AI Alike](https://aietalks.com/talks/bdd-adr-prd-wtf-capturing-decisions-for-humans-and-ai-alike) (Michal Cichra, Safe Intelligence, 12:49)
- [Paperclip: Open Source Human Control Plane for AI Labor](https://aietalks.com/talks/paperclip-open-source-human-control-plane-for-ai-labor) (Dotta Bippa, Paperclip, 24:34)