我如何跨仓库每天交付 100+ PR 并保持对进展的理解

Hey everyone, so as AI keeps getting better and better and coding has been 'solved' (to some extent), I keep asking myself how to actually automate end-to-end development with AI. Like most people in this sub I'm pretty pro-AI, but writing a single prompt, waiting for the AI to finish and then shipping the work has always slowed me down. People have built basic loops (such as the 'old school' Ralph loop), but lately they're getting more and more advanced.

With the likes of Bun having most of its work shipped with Claude nowadays, or OpenClaw shipping in the same way, I've always wondered how their loops work, how they automate the majority of their workflows and what they actually do.

Neetcode (from 2 months ago) mentioned that most people are being pretty secretive about how they actually ship with their loops: https://www.youtube.com/watch?v=xhIQ-ijUmB4 (maybe it's to stay ahead of the game, IDFK).

As my tools have gotten better (along with my own learning), I'm now shipping over 100 (quality) PRs per day across my repos and different orgs, and i'd like to share how I actually do it.

Bit of backstory: yes, I'm a full time SWE and have been for a couple of years. I've built alot of tools and I believe I've landed on a pretty solid solution. Like many people here, I started with a single prompt and hoped for the best, then introduced some skills, MCPs, etc. and slowly progressed. But fast forward to today, I've got a whole workflow that could be pretty useful to some - as I know, a lot of people don't actually share their workflows. Here's a breakdown of my actual flow nowadays that lets me ship so much:

TLDR version

• Set up a looping flow with pre-defined prompts
• Tell the agents in that flow to file any issues, ideas, etc. they spot in the apt place
• Categorise those to decide whether they're actually worth doing
• Set up a cron job that automatically starts the flow again
• Cycle.

This is easier said than done, so the full breakdown::

Data is key

Before I go over my workflow, one extremely important thing I want to bring up is about storing data. Inspired by compound engineering (or as I like to call it, optimistic engineering - original source: https://every.to/guides/compound-engineering), the premise is that you store your data in the hope that technology can one day utilise it effectively to advanced your own systems (or you figure out what to do with it yourself).

For me, I've built my own custom harness and do a form of 'CI at commit'. This means I have a bunch of AI reviewers, deterministic gates and a whole chain of reviews at commit level (through the likes of Husky), so I can be somewhat certain the agents are doing a good job by the time the work is actually submitted for review. Everything within this chain I store - all of its telemetry. Token consumption, time to ship, how many failed attempts it had, what errors the reviewers raised, which errors were waived, etc. Slowly but surely I'm improving my custom harness on top of Claude and getting more confident in what I ship, albeit when I ship more blindly. Every N ships I gather the latest telemetry, run X benchmarks and iterate on what I learn.

I do still have CodeRabbit etc. on top, but the number of comments I get per 1K LOC shipped has been slowly going down, irrespective of what model I use. I.e. Opus 5.5 without my harness produces more bugs and 'slop' per 1K LOC shipped than with it turned on.

So please, store as much data as possibl, it will help. 🤠

Looping

Now that I'm getting more confident in the work I ship, I'd like to talk about my actual flow. As per NeetCode's video (ref above), a lot of people who are considered 'pretty far ahead' with AI development are being pretty secretive. "Create loops"... bruh, what... What does create loops meannn

For me, I built a desktop app for exactly this. You build a flow as a graph of blocks (a trigger, then whatever steps you want) and it runs on your own machine (i'm moving it to the cloud soon too). Here's what one cycle of my loop looks like:

1. Something kicks it off

Every flow starts from a trigger. Mine is a webhook, when a piece of work gets assigned to me in my me, the flow starts. Many AI tools already have this (a webhook prompts an agent to do something), but that's usually where they stop. Triggers can also be a schedule (cron), a Sentry error, a PostHog event or any webhook or any other third-party integration you desire.

2. The graph:

Instead of one huge prompt, each step is its own block (a list of pre-defined prompts + other tools I use in a workflow):

• Agent blocks with pre-defined prompts, so a specific agent does a specific job (plan, implement, test, etc.)
• Command blocks that run my scripts in my shell (not via the agent) at a specific point in the flow. If a script prints JSON, every key becomes a variable for the next step ({{previous.count}} etc.), so the deterministic stuff stays deterministic
• Conditions to branch (e.g. tests failed → hand it to a fix-up agent, else do something else), approval steps where it stops and asks me, and for-each blocks to fan out over a list
• Custom nodes - little JS scripts (considered plugins) that show up as their own blocks. I use them for things like updating all my localhost apps without ever touching an agent

Every agent works in its own git worktree, so parallel runs never step on each other. There's a lot more here such as pre-defined briefings across flows, DAG, etc.

Essentially, my own fine-grained flow to be run be ru just the way I like it - always.

3. Ship through the harness

When the work is 'done', the agent is told to ship it through my review harness . It only ships after a successful run (as per my data is key section). Agents also signal how they finished: done, blocked, needs input, partial- instead of just going quiet, so I know if it's actually finished or waiting on me. (This then can be pinged to my phone if needed so I can review the blocks in the flow rather than trying to re-prompt everything).

4. File what it found

Last step: the agent is told to file a ticket for anything it spotted along the way. Bugs outside its scope, ideas, missed edge cases. This is what keeps the loop fed.

5. Triage in a seperate flow

New tickets get picked up by a second flow. It pulls in anything new, checks it against local state, judges it, rated and ranked by a custom Jev node (a small classifier model I run through OpenRouter). The noise gets binned and the real work gets routed to the right repo and assigned on my kanban board.

6. Cron closes the loop

Once tickets are ready, a cron job auto-assigns them to me, which fires the webhook from step 1, and the whole cycle starts again.

So simply, the workflow goes: -> pre-defined prompts, tasks, shell commands, etc. -> run on one flow -> The agent may add follow ups. -> These get categorized -> dropped or assigned to me -> the cycle continues until we're out of work -> For new work I just create new tickets and assign them to myself (or get an agent to create the ticket for me).

Running lots of them at once

For bigger chunks of work (say an epic with 20 tickets), one agent plans a batch. It splits the work into stages: runs inside a stage go in parallel, and a stage that depends on another waits for it. Each later stage starts from the merged branches of the ones before it, so it builds on everything upstream, and the final stage opens one PR for the whole chain. There's a machine-wide concurrency cap so my laptop doesn't melt, and anything over it just waits in the queue. (again, i'm going cloud soon... but will do for now).

The Work Queue

All of this lands in one place: the Work Queue. Every run across every project (running, ready for review, needs attention, queued) with a badge when something needs me. If an agent gets stuck it parks in Needs Attention rather than failing silently, and if a step fails the flow can pause so I can retry or skip that one step instead of starting over. I can pause the whole queue or reorder what runs next. For automations I trust (like nightly triage), runs can auto-accept so they close themselves.

The mobile app

As per above, everything gets also pinged to my mobile app - so I simply have to respond to agent's blocks instead of prompting my entire day's work. Super convient and tbh, I barely prompt anymore.

I genuinely believe this is super handy, and unlike a lot of other AI tools out there (think Codex, Claude Code, T3 Code, Orca, etc.) the app's main focus is fine-tuned automation. It runs on your existing Claude Code or Codex login (antigravity, etc. soon as i'm using more and different tools), and everything stays local on your machine.

The question always goes: if AI is so good, why hasn't it taken our jobs yet? I believe this app is a step in that direction.

After feedback I've removed account sign-in and made it completely open source under MIT... so check it out: https://github.com/benord-labs/frink