Factory says its software factory concept can take a Sentry alert, diagnose it, write the fix, review it, test it, and monitor the release. The claim rests on a simple observation: median time to review a pull request and repair time dwarf the minutes spent actually typing the change.
What is a software factory?
A software factory is a system of AI agents that takes input signals such as bug reports, alerts, and user feedback and produces production code, from triage through deployment and monitoring. Davis Palmie, a member of technical staff at Factory, the company behind the Droids agent platform, presented the model in a talk recorded at the AI Engineer World's Fair 2026 in San Francisco. The engineer's job shifts from typing code to governing agents: keeping guardrails tight, catching code drift, and setting high-level priorities.
Palmie's background shapes the pitch. Before Factory he co-founded Lummetric, an agent platform for investment teams that went through Y Combinator and was later acquired by Factory, and he previously led engineering for Slalom's innovation lab. His argument is that AI engineering has climbed an abstraction ladder, from tokens to files to context, and is now reaching entire systems.
Three eras of AI engineering, and what changed for engineers
The software factory framing rests on three eras of AI-assisted development. In each one, the engineer kept control but moved further from the keystroke.
- Tab autocomplete: next-token prediction where the engineer stayed firmly in the driver's seat.
- Whole-file generation: the engineer became, in Palmie's phrase, a discerning copy-paster, still controlling the output.
- Agents coupled to the codebase: systems that gather their own context, call tools, and debug their own output.
Palmie's claim, offered as speaker experience rather than measured data, is that each move up the ladder has made engineers more valuable, and the next step is organizing agents into one governed system.
That last step changes the organization too. Team boundaries blur, context has to flow across them, and information silos that slowed human teams slow agents even more. Palmie argues every team shares responsibility for the factory's pillars rather than owning isolated layers.
Why coding was never the bottleneck
Coding was the easy part, according to Palmie, because context is already written in natural language and models handle generation well. The real drag sits in the surrounding stages: pull request review time, bug reproduction, debugging, stale documentation, and test-suite maintenance. He points to DORA metrics as the honest check, arguing that the time from code written to code in production dwarfs the time spent making the change itself.
The claim matters because it sets the automation target. A factory that only writes code faster does not fix the expensive stages. Palmie's list of where agents help an AI-native organization includes triaging incoming signals, proactively scanning for secrets and vulnerabilities, maintaining tests, keeping docs in sync with code and with meeting channels, reviewing code, and monitoring rollouts. Each improvement is transitive across sub-teams: fixing docs helps review, which helps deployment.
Four questions every leader asks about agent-driven development
Palmie structured his talk around the objections that come up once AI systems produce more code than humans. His answers are Factory's positions, not independent study results.
- How do I prevent cost overruns? Stay model-agnostic so each task gets the minimum effective model. He cites two headline examples of runaway AI spending without endorsing them as typical: reports of Uber's CTO exhausting a yearly AI budget by April, and Microsoft clawing back Claude Code licenses to cut spend.
- How do I always access the best model? He calls picking one vendor a false choice, especially as open-source models improve, and favors routing tasks to the right tool dynamically.
- What happens to engineers? The role evolves toward building and maintaining the system that builds production code; judgment and prioritization beat mechanical implementation skill.
- What happens to the org chart? Governance is defined once and standardized, which Palmie describes as moving coordination pain from O(N) to O(1), an editorial framing rather than a measured result.
Four design principles for a software factory
Factory argues a software factory should satisfy four principles. The first two carry the speaker's cost claims, which are vendor-reported figures from his own team's code-review experiments, not independent benchmarks.
- Model-agnostic. Palmie reports his team achieved the same code-review performance with GPT-5.2 as with the latest Opus models at half the price, and that open-source alternatives can run 10 to 30 times cheaper. Treat both as Factory's internal findings.
- Sovereign deployment. Choose your workspace and deployment model, from fully managed to bring-your-own-machine to entirely air-gapped, so security architecture does not bend around the AI vendor.
- Integrated across the SDLC. Docs, planning, code, tests, and monitoring inform each other instead of being separated by communication layers.
- Surface-agnostic. Agents should be available in the CLI, in Slack, and on remote machines, sharing one underlying harness and context so teams keep their existing tooling.
| Principle | What it prevents |
|---|---|
| Model-agnostic | Vendor lock-in and cost overruns |
| Sovereign deployment | Security and policy compromises |
| SDLC-integrated | Stale docs and siloed teams |
| Surface-agnostic | Forced tooling migrations |
Eight pillars of agent readiness
Agent readiness is Factory's diagnostic for whether a codebase can support agents at all. Palmie frames it as paving roads that both agents and human engineers walk, so the work pays off twice. The eight pillars, in his order, are:
- Validation: linting and formatting guardrails in place.
- Build system: build commands and CI well documented.
- Feedback loops: tight unit and integration tests, plus docs like READMEs and AGENTS.md files.
- Reproducible environments: dev environments an agent can spin up cleanly.
- Modular code: clear boundaries and rules against sprawl.
- Observability: fast answers to why something went wrong.
- Security scanning: proactive checks so secrets and vulnerabilities surface early.
- Governance: auditable actions, role-based access control, and least privilege for every agent.
The practical advice is to roll out incrementally. Start with something narrow and verifiable, such as letting an agent read a Sentry alert, pull traces, and post a diagnosis in Slack for human review. Build trust pillar by pillar before looping the pipeline end to end.
Measure outcomes, not tokens
Token counts and lines of code are gameable metrics, Palmie argues, and internal token leaderboards encourage wasteful spending. Once you measure token usage, engineers optimize for token usage and the metric stops meaning anything, which he calls Goodhart's law in real time. The point is leverage per unit of spend, not the size of the spend.
The metrics Factory favors instead are signal-to-production time, human intervention count, median time to repair, shelf life of code, and cost per pull request. Each ties agent output back to an observable engineering outcome. His closing caution is that precise execution does not prevent poor design: humans remain validation gates for architecture, strategy, and direction, and agents need the same governance as engineers, including access levels and review systems, before being turned loose in a codebase.
FAQ
- What is a software factory in AI engineering? It is a system of AI agents that converts input signals like bug reports and user feedback into production code across the full software development life cycle. Humans govern it by setting guardrails, priorities, and risk parameters.
- Does a software factory replace software engineers? No. In Factory's framing, engineers build and maintain the factory itself, exercise judgment on architecture and strategy, and act as validation gates. Judgment and prioritization become the differentiating skills.
- Where should a team start with agentic automation? Factory recommends one narrow, verifiable workflow such as incident triage, where the agent reads an alert, gathers context, and posts a diagnosis for human review. Automate individual pillars before looping the whole pipeline.
- Why are token-based AI metrics considered bad? Because they are gameable: engineers optimizing for token usage inflate spend without improving outcomes. Outcome metrics like signal-to-production time, intervention count, and cost per pull request track actual engineering value.
From talk to article: turning video knowledge into writing
Palmie's core insight applies to content as much as code: the valuable part is the signal, not the transcription effort. A 19-minute conference talk holds an argument, evidence, and caveats that most viewers will never search for unless someone turns it into a written, structured article.
If you have knowledge sitting in YouTube videos, whether interviews, explainers, or conference talks, Skala Blog converts a video URL into a transcription and then into a structured draft article you can review and publish. Paste the link, let the pipeline do the mechanical work, and spend your judgment on the editing, the same division of labor the software factory argues for.
Fork this article
Start a new branch from the same video, shaped your way. You keep the credit; the original keeps the attribution.
A fork in another language is filed as a translation of this article, so the two pages point at each other. You can unlink it later from the editor.
0/240
You are creating
- Format
- For
- Language
- Source
- Your angle
You will be asked to sign in before it is generated.
Buy credits