How Stacks Labs Is Building an AI Software Factory for Bitcoin Infrastructure

How Stacks Labs Is Building an AI Software Factory for Bitcoin Infrastructure

Adriano Di Luzio
November 17, 2026

Software engineering is changing: rather than building software directly, teams will engineer software factories that automate the development process and deliver software that meets a desired goal and quality bar, faster. At Stacks Labs, we’ve started building ours, because for a small team writing security-critical Bitcoin infrastructure, speed only matters if quality holds. 

AI and the individual

Like lots of colleagues, I use AI through individual workflows. I start with a prompt, run automated reviews, then review changes myself before merging. Unless an agent’s work is constrained in other ways, those reviews are essential. Without them, an agent would easily develop a prototype or prove a point, but the resulting code is unlikely to be maintainable. When forced to review the code, I am the bottleneck limiting how quickly an agent can deliver changes.

We need to extend each individual's workflow into a team development process that can scale through automation, avoid bottlenecks, and produce high-quality software.

The bitter tension

Left unchecked, agents usually need correcting on style, tradeoffs, interfaces and security. LLMs are people-pleasers: during training, they are rewarded when they reach goals. No matter how loosely we define goals, an agent will get there somehow. Sometimes, it will make choices that we'd reject in review.

The challenge with building software factories is steering agents to autonomously achieve the goals we set at the quality we deem right. This requires us to make our quality standards explicit while keeping our instructions to the agent minimal. Additional workarounds can backfire: they limit an agent’s autonomy or go stale when more capable models arrive.

Instead of spending effort on yet another harness, we need to prepare codebase and docs to welcome automated contributions. That means treating an AI agent like an external contributor: skilled, but unfamiliar with the team’s practices and values. Our job is to write skills that spell out how we'd like things to be done and structure checks and balances that automatically enforce our rules (linters, static analyzers, automated tests, etc).

Some of the resulting work will remain local to each team or product. Much of this work applies across Stacks Labs, codifying the engineering practices and values that will be followed both by humans and agents.

Arts and crafts

Ideally, an agent's PR should be as good as one from a skilled teammate. It should feel like it has gone through review, incorporated feedback, and is ready to be merged. Review time is already scarce. More agents' contributions will increase its demand.

We need to turn the art of preparing good PRs into a reproducible process, where a change goes through multiple agentic reviews before being presented to a human. The process should produce changes that are very likely to meet our quality standards. We will observe the process to improve it, and experiment with it. In due time, we could be comfortable enough with our factory to only request human review on code we deem critical.

This work requires engineering judgement to turn the probabilistic path taken by the agent working on the task into reliable software. Expecting perfect results would be a mistake. The output should be as good as our own would be, and ours wouldn't be perfect either. We'd make mistakes and fix them, or pick tradeoffs between delivery velocity and quality. We need to show agents our quality bar, teach them to reach it, and then push them past it.

Rather than adopting a harness or development process without evaluating it, we’re building our factory through experimentation and measured improvements. We agree on a set of benchmarks representative of our development. Then, we’re only adopting those changes (skills, tools, checks and balances) that improve on the current process. Periodically, we'll compare results against a minimally configured agent, serving as baseline, that ensures our steering is minimal.

Accelerating

For our factory to succeed, we'll need to be deliberate, skilled, open. Deliberate, so we evaluate the factory as a whole without being fooled by it; that evaluation is the foundation, and it can’t be shaky. Through skills, we'll turn our expertise into reliable engineering that will accelerate improvements and processes. We'll need to be open to recognizing that our field is changing, but that by working as a team a factory becomes bigger than the sum of its parts (the individual workflows).

Models and tools change. A team that has learned to build a software factory and evaluate its performance will hold a lasting advantage. The factory itself is leverage: enabling small teams to build reliable software, faster.

References and examples

  1. Stripe Minions: one-shot, end-to-end coding agents (part 1 and part 2)
  2. Anthropic: solving code review and building agents
  3. Irrational Exuberance on software factories, GrokBot at 2500 PRs/month, Rewriting Prime Agent in Rust
← Previous Post
Next Post →

Get more of Stacks

Get important updates about Stacks technology, projects, events, and more to your inbox.