topic: software-engineering
author: Crashtech Editorial
published: Nov 17, 2026 · read: 4 min
---
How Stripe's Minions Ship 1,300 PRs a Week: Unattended Coding Agents on Enterprise Monoliths
Inside Stripe's Minions: how unattended coding agents safely author, test, and merge 1,300 production pull requests weekly on a massive Ruby monolith.
On this page
At Stripe, the engineering team maintains one of the largest monolithic codebases in the technology industry: hundreds of millions of lines of Ruby (strictly typed via Sorbet), powering over $1 trillion in annual global payment transactions.
On a typical workday, an on-call engineer might notice a flaky integration test, identify an unmigrated legacy API endpoint, or review a security dependency update. Instead of manually opening an editor, checking out a branch, and writing code, the engineer sends a one-line prompt to an internal Slack bot:
“@minion migrate the billing webhook controller to use the v3 schema, update the Sorbet type signatures, and verify with tests.”
The engineer closes Slack and returns to their primary task.
Thirty minutes later, an automated pull request lands in their inbox: complete with clean file diffs, passing CI test runs, updated type checks, and a comprehensive architectural summary.
This is Minions: Stripe’s internal platform for unattended autonomous coding agents.
Today, Minions authors, tests, and merges over 1,300 production pull requests every week with zero human-written code.
+-------------------------------------------------------------------------------+
| STRIPE'S MINIONS AGENT ARCHITECTURE |
+-------------------------------------------------------------------------------+
[Engineer Slack Prompt / Automated JIRA Bug / Deprecation Scanner]
|
v
[Minions Task Coordinator & Dispatcher]
|
v
[Ephemeral Remote Development Box (Cloud Sandbox preloaded with Monolith)]
|
+---> [Agent Orchestrator Loop (Anthropic Claude / OpenAI Frontier)]
| |-- Code Search: Custom Sorbet LSP & Stripe Semantic Index
| |-- Patch Generation: AST-Anchored Structured Edits
| |-- Type Verification: Runs `srb tc` (Sorbet Typechecker)
| \-- Test Verification: Executes localized test suites in sandbox
|
v (Iterates autonomously until typecheck and test suites PASS)
[GitHub Pull Request Created + Formatted Architectural Summary]
|
v
[Human Engineer Code Review & One-Click Merge Gate]
1. Attended vs Unattended Coding Agents
The software industry has heavily focused on attended coding agents (e.g., Cursor Composer, GitHub Copilot Chat). In an attended workflow, a human sits in front of the screen, watching the model stream tokens, approving individual file edits, and stepping in when the agent stumbles.
Stripe identified that attended workflows have a cognitive ceiling: they still consume human attention.
Minions was engineered as an unattended system:
+-------------------------------------------------------------------------------+
| ATTENDED vs UNATTENDED AGENT WORKFLOWS |
+-------------------------------------------------------------------------------+
Attended Workflow (Cursor / Copilot):
Developer Prompts -> Watches Editor Stream -> Approves Diff -> Fixes Error
* Human is synchronously blocked during generation.
* Ceiling: 1 task at a time per engineer.
Unattended Workflow (Stripe Minions):
Developer fires 5 tasks via Slack -> System executes asynchronously in cloud ->
Developer reviews 5 complete, tested pull requests hours later.
* Human attention is required ONLY at the final code review gate.
* Ceiling: 10x multiplier on developer output.
2. Why Minions Succeeded: Human Infrastructure Foundations
A common industry mistake is assuming that building an autonomous coding agent is purely a model problem.
Stripe’s critical insight was that unattended AI agents cannot function without world-class developer infrastructure built originally for humans:
- Strict Static Typing via Sorbet: In dynamic Ruby, an agent can hallucinate non-existent methods that only fail at runtime. Stripe’s custom type checker, Sorbet, acts as an instant, deterministic compiler gate:
srb tcverifies type safety in seconds, giving the agent unambiguous feedback on whether its edits broke downstream method contracts. - Sub-Minute Localized Test Suites: Running tests across a 100-million-line codebase takes hours in standard CI. Stripe invested years engineering test-selection tooling that predicts and runs only the specific test suites impacted by a diff in under 30 seconds.
- Pre-Warmed Ephemeral Remote Environments: Minions does not clone repositories from scratch. Every task boots inside a pre-warmed remote development container where the entire repository, gems, and databases are already mounted and ready to execute.
3. The Autonomous Iteration Loop
When a Minion begins a task, it does not expect to write perfect code on the first attempt. It executes an autonomous ReAct iteration loop:
+-------------------------------------------------------------------------------+
| MINIONS AUTONOMOUS REPAIR LOOP |
+-------------------------------------------------------------------------------+
[Task: Update PaymentMethod Controller]
|
v
[1. Agent inspects files & generates initial search-and-replace patch]
|
v
[2. Agent executes `srb tc` (Sorbet Typecheck)]
|
+---> Type Errors Found! (Missing parameter in signature)
| Agent inspects Sorbet error output -> rewrites signature -> re-runs.
v
[3. Agent executes `pay-test test/controllers/payment_test.rb`]
|
+---> Unit Test Fails: Expected HTTP 200, Got 422 Unprocessable.
| Agent inspects test failure assertion -> adjusts controller logic.
v
[4. Tests Pass & Typecheck Clean!]
|
v
[5. Emit Git Commit & Push Pull Request]
By having access to the compiler and test runner inside its sandbox, the Minion self-corrects syntax errors, missing imports, and logic regressions without paging a human engineer.
4. The Human Review Gate and Safety Boundaries
Minions is strictly forbidden from merging code autonomously to production branches.
The system enforces a Non-Bypassable Human Review Gate:
- Minions generate real pull requests with clean commit messages.
- Pull requests run standard enterprise CI pipelines (security scans, linting, regression suites).
- A human engineer must review and approve the diff before the PR can merge into
main.
Because the Minion provides passing tests, clean typechecks, and a structured summary of trade-offs, human review takes minutes rather than hours.
Production Results
| Engineering Metric | Manual Human Workflow | Stripe Minions Workflow |
|---|---|---|
| Weekly Machine-Authored PRs | 0 | 1,300+ PRs per week |
| Task Execution Model | Synchronous developer attention | Asynchronous unattended cloud batching |
| First-Pass Success Rate | N/A | ~70% of tasks pass tests without human aid |
| Developer Role | Authoring lines of code | Reviewing verified pull requests |
Summary and Key Takeaways
- Unattended agents multiply leverage: Shift from attended streaming editors to asynchronous cloud agents that deliver complete, tested pull requests.
- Static typing is the bedrock of agent reliability: Strict type checkers like Sorbet provide immediate, deterministic compiler feedback that prevents hallucinated interfaces.
- Fast local feedback loops are mandatory: Agents require sub-minute test runners to iterate and self-correct errors autonomously.
- Pre-warm ephemeral development sandboxes: Isolate agent execution in pre-warmed cloud containers to eliminate setup overhead and protect host security.
- Always preserve the human review gate: Automate authoring, testing, and documentation, but keep human engineers in full control of the final merge decision.
/* Comments */
Comments are offline right now — we reconnect automatically, nothing is lost.