---
type: raw-x-post
source_type: x
category: raw
domain: enterprise-adoption
status: captured
captured: 2026-06-02
published: 2026-06-02
confidence: medium
tags:
  - alex-lieberman
  - businessbarista
  - software-factory
  - code-factory
  - agentic-ai
  - enterprise-adoption
  - workflow-migration
  - verifiability
source: https://x.com/businessbarista/status/2061573150719021542
related_digest:
  - "[[08 Reference/2026-06-02 Alex Lieberman - Software Factory Ladder - Digest]]"
---

# Alex Lieberman - Software Factory Ladder

Source: https://x.com/businessbarista/status/2061573150719021542  
Author: [[05 People/Alex Lieberman]] / @businessbarista  
Published: 2026-06-02 01:18  
Captured: 2026-06-02

> Raw X Article captured from logged-in controlled-browser visible text. Treat as founder/operator field note and transformation framing, not as independent benchmark evidence.

## Browser-visible source context

Alex Lieberman published an X Article titled "What the hell is a Software Factory?" aimed at non-technical leaders.

His core framing: a software factory is not "engineers using AI." It is an engineering organization where software delivery behaves more like a production line than a craft process. Humans design the line, set guardrails, and handle exceptions; agents increasingly write, review, test, ship, monitor, and triage.

Lieberman disclosed that one of the things his company Tenex Labs now does is help enterprises build these systems: infrastructure/tooling setup, assessment, training, and change management. He says the gap between what CEOs think they have and what they actually have is enormous.

## Claimed proof points

The post cites several proof points that should be treated as source claims unless independently verified:

- Anthropic is described as attributing more than 90% of production software to AI.
- Google is described as saying 75% of new code is AI-generated, up from 25% a year earlier.
- OpenAI is described as having 95% of engineers use an internal agent, with heavier users opening 70% more pull requests.
- Ryan Carson is described as running a "Code Factory" where agents write code, review it, run tests, triage errors, and watch production under guardrails.
- StrongDM is cited via Simon Willison as an extreme factory example built around the principles that code should not be written or reviewed by humans.
- Microsoft, Chamath Palihapitiya, Garry Tan, Simon Willison, Peter Steinberger, Lenny Rachitsky, Santiago, Andrej Karpathy, and DORA are named as adjacent voices or sources to watch.

## Software Factory Ladder

Lieberman offers a five-level ladder:

- **Level 0 - Artisan:** a customer bug moves through human support, human reproduction, human code, human review, human testing, and human deploy.
- **Level 1 - Assisted:** the same human process exists, but the engineer uses an AI copilot to write faster. Most companies are here.
- **Level 2 - Delegated:** an engineer gives a complete bug or ticket to an agent, which writes the fix and opens a pull request. Humans still review every PR.
- **Level 3 - Supervised Factory:** production monitoring, triage, coding, review, tests, and low-risk deploys can run through agents under human-set guardrails. Risky work escalates.
- **Level 4 - Autonomous Factory:** the system catches, fixes, reviews, tests, and ships routine problems before the team knows they happened. Lieberman says almost nobody is genuinely here.

## Assessment questions

The post suggests diagnostic questions for leaders:

- What percentage of pull requests ship without human review?
- Does the first version of a small feature or bug fix come from a person or from a person directing an agent?
- Can an agent open a pull request on its own?
- Are there rules that auto-ship low-risk changes and escalate risky ones?
- Does a person or a system first notice production breakage?
- Do tests run automatically on every change and block bad changes?
- If an agent ships something wrong, how fast can it be caught and undone?
- Can AI tools securely see internal code, docs, and systems?
- Is there an internal platform agents plug into, or does each engineer wire up their own tools?
- If AI tools were removed, would the process itself break or only slow down?
- Has the bottleneck moved from writing code to reviewing and shipping it?

## Climbing the ladder

The post's practical migration path:

- **Level 0 to 1:** put approved AI tools in engineers' hands and remove legal/security friction around real codebase use.
- **Level 1 to 2:** let agents own complete, low-risk tickets, starting with well-tested parts of the codebase.
- **Level 2 to 3:** remove the human-review bottleneck for low-risk changes by defining risk rules, adding a second reviewing agent, requiring automated tests, and auto-merging work that clears the bar.
- **Level 3 to 4:** close the loop with production monitoring agents that detect breakage, open tickets, and run the line. Lieberman cautions that most companies should not sprint here, especially around trust, money, or safety.

## Next factory criterion

Lieberman argues engineering is only the first factory and points to Ryan Carson's "Company Factory" idea. The readiness criterion is **verifiability**:

- traditional software automates what can be specified
- AI automates what can be verified
- functions become factory-ready when work has verifiable outputs, digital inputs/outputs, repeated volume, and reversible mistakes

His proposed readiness spectrum:

- Most ready: software engineering, QA, data pipelines, analytics, DevOps
- Increasingly ready: parts of finance/accounting, customer support, and operational sales/marketing
- Least ready for now: strategy, design taste, novel architecture, executive judgment, relationship/trust-building

## KB interpretation

This is a strong enterprise-adoption framing because it turns "AI coding" into an operating-model maturity ladder. It gives the KB a concrete distinction between:

- tool adoption
- delegated ticket execution
- governed software production lines
- autonomous operations loops

The durable signal is that software engineering is advancing first because it has explicit artifacts, tests, version control, monitoring, and rollback. That makes it a natural migration template for other functions, but only where verifiability, digital workflow surfaces, volume, and reversibility exist.

For enterprise leaders, the key question is not "how much code was AI-written?" It is "which parts of the delivery line run without a human, under what guardrails, with what evidence, and how quickly can the system catch and reverse bad work?"

## Caveats

- Several quantitative claims are cited as industry proof points but are not independently verified inside this capture.
- The post is partly Tenex Labs category positioning because Lieberman says his company helps enterprises build software factories.
- The framework is useful for executive diagnosis, but Level 3 and Level 4 maturity should be tested against actual CI quality, rollback paths, monitoring, auditability, and incident outcomes.

## Related notes

- [[08 Reference/2026-06-02 Alex Lieberman - Software Factory Ladder - Digest]]
- [[05 People/Alex Lieberman]]
- [[03 Research/Agentic AI/Agentic AI Overview]]
- [[03 Research/Enterprise Adoption/Enterprise Adoption Overview]]
- [[06 Theses/The Workflow Migration Thesis]]
- [[06 Theses/The Control Surface Thesis]]
- [[09 Implications/Migrate Workflows Not Seats]]
- [[09 Implications/Pair Governed Runtimes With Workflow Owners]]
