Latent Space

Zach Lloyd on the software factory you define in code

Zach Lloyd· Founder & CEO at Warp
·~35 min·English·Latent Space
AgentsAI InfrastructureBusiness StrategyLLM
TL;DR

Warp's CEO reframes agentic coding as an engineering discipline: define your software factory in code, store and measure every agent run, and tune it like any other system — the payoff is a self-improving pipeline, and a new job called factory engineering.

01Core Mental Model

A Factory You Define in Code

A software factory is not “we use agents a lot” — it is a concrete system defined in code, one per product surface, that you can orchestrate, measure, and tune.

you should actually think of a software factory as a very specific thing like you should define your factory in code

— Zach Lloyd, Latent Space
Key Insight
Defining the factory in code is the move that unlocks everything else. You can only version, branch, revert, measure, and let agents improve a thing that exists as a concrete artifact — the “vibe” version can't be optimized because there is nothing for an optimizer to point at.
02Architecture

The Factory Stack

Treat the factory as a stack of pluggable layers — a declarative definition at the foundation, then data, compute, inference, an improvement layer, an orchestrator, and access points on top.

the analogy is like terraform here. You get the same benefits but actually more.

— Zach Lloyd, Latent Space
Key Insight
Spelling the stack out is itself a strategic move. It sits one layer behind CI/CD, and if a format like this becomes standard developer infrastructure, the team that defines it sets the terms for everyone building on top — which is the point of Lloyd's stated “power move”: thought-lead so hard that teams end up building Warp even if they never buy it.
03The Closed Loop

The Factory That Rewrites Itself

Because the factory is defined in code, coding agents can grade their own past runs and open pull requests against the factory definition to make it better.

because you have your whole factory defined as code and these are coding agents they can essentially make a pull request against the factory definition to try to improve the factory itself

— Zach Lloyd, Latent Space
Key Insight
Self-improvement by pull request means the optimization loop inherits the code's own guardrails. A proposed change to the factory is reviewable and revertible like any other commit, so a bad “improvement” can be rolled back — the loop is auditable, not a black box quietly mutating itself.
04Proof in Numbers

$80 a PR Became $15

Tuning the factory cut Warp's cost per merged PR from about $80 to roughly $15 to $20, while throughput rose about 40% and the revert rate stayed flat.

when we first started using the factory approach it was costing us about $80 per PR because we were using like opus where we shouldn't have

— Zach Lloyd, Latent Space
Key Insight
This number is the real product demo. It proves the thesis that agentic coding is now an optimization problem, and the biggest lever was not a smarter agent but a cheaper model in the right place — a high-powered model on the triage step was simply the wrong tool, visible only once the cost was measured per PR.
05Measurement

Your Own SWE-Bench

Replaying your own agent runs across a matrix of models and harnesses gives you SWE-bench-style results on your real codebase, which you feed straight into routing.

a result that looks very similar to like the published results for SWE or Terminal Bench, but on your company's own real runs

— Zach Lloyd, Latent Space
Key Insight
Public benchmarks rank models on someone else's tasks; running the same measurement on your own repos turns benchmarking from marketing into a routing decision. The right model stops being the one at the top of a leaderboard and becomes the cheapest one that clears your bar on your code.
06Business Strategy

You Can't Build on Tokens

Subscriptions can be far cheaper than paying by API — five to 50 times, by one estimate in the interview — so a coding agent built on raw API tokens can't compete, which is why Warp sells optimization, not tokens.

you can't build a competitive coding agent on top of a thing that costs so much more money

— Zach Lloyd, Latent Space
Key Insight
The subsidy gap is structural, not a temporary discount. It means the margin in “a coding agent” belongs to the model lab, so the durable business is the layer above the model — where measurement and tuning create value the lab cannot capture. Lloyd reads Cursor's pivot into a model lab as the same realization.
07The New Job

Factory Engineering Is the Job

The job splits in two: product engineers ship features through the factory, and factory engineers build and tune the system that builds the software.

How do you as an engineer build the right skills so that you're engineering the system that builds the software and not just building the software directly?

— Zach Lloyd, Latent Space
Key Insight
If the work shifts to engineering the system that builds software, the scarce skill stops being writing code and becomes designing, measuring, and tuning the pipeline. It is the same shift that turned skilled craftsmen into process engineers on a physical factory floor.