It goes AI native too.
Software production velocity is threatening to go vertical. We’re talking 10x–100x faster, factory line assembly style ‘compile’ of working software. The infrastructure to make this happen is being built right now, in public, by people who’ve figured out that the bottleneck was never the AI’s capability—it was how we deployed them.
So, hypothetically, if we can ship software 50x faster, what feeds it? And how does anyone—human or AI—keep up?
Coming Soon: The Software Factory
Right now most developers are still in “me plus one to three AI buddies” mode. It works. But it’s like having a factory where the foreman personally carries each widget through every machine. (I’ve been that foreman. I’m exhausted.)
The real unlock happens when you have 10, 20, 50 agents working in parallel, coordinated by systems designed for coordination. Agents execute. Humans review at gates. The machine runs.
Jess wrote about this recently and I think he nailed something important. The new SDLC isn’t going to be a process that developers shepherd tasks through. It’s an assembly line where tasks flow through stations. Each station gets optimized once, and that optimization compounds across every task forever.
The State of Orchestration
Under the hood, orchestrators address six problems:
- State management (agents forget everything)
- Task decomposition (complex work exceeds single sessions)
- Coordination (who works on what)
- Monitoring (detecting stuck agents)
- Communication (sharing context between agents)
- Output integration (merging without conflicts)
The approaches diverge on philosophy. Some systems simulate human org charts—analyst → PM → architect → developer → QA—recreating all the coordination friction we were trying to escape. Others treat orchestration as an operational problem: coordinators, workers, monitors. Designed for how AI actually works: parallel, stateless, fallible.
I think the operational approach should win and is winning unless a big underlying change happens at the model level – see Claude Flow (hive-mind swarm architecture) and Loom (Rust-based, 30+ crates, clean separation between LLM providers and tools) for sneak peaks at the near future.
The Contagion Opportunity
Here’s what the factory discourse hasn’t grappled with: compilation is only one of three core product functions:
- Design — Transform signals into specs (decide what to build)
- Build — Transform specs into code (compile software)
- Distribute — Transform code into signals (ship and collect feedback)
Build feeds from Design. Distribute feeds back to Design. It’s a loop—and Build is about to run 50x faster than the other two.
The orchestration patterns that make Build work aren’t Build-specific. Task decomposition, station specialization, parallel execution, human gates, state persistence—these apply to any transformation pipeline.
Design orchestration breaks signal processing into atomic tasks (summarize support tickets, analyze adoption metrics, scan competitors), runs them in parallel through specialized agents, and surfaces synthesized options for human priority decisions. The human gate moves from “process this feedback” to “here are three response options with tradeoffs—decide.”
Distribute orchestration breaks deployment into atomic steps (staging, canary, monitor, rollout), runs monitoring and feedback collection in parallel, and surfaces anomalies for human go/no-go decisions. The human gate moves from “watch this dashboard” to “here’s what I’m seeing and my recommended response—decide.”
Same primitives. Different transformations. The contagion is structural. Our hypothesis is that the specific shape and flavor of the transformation will be a reaction to whatever the product org adopts as their core build platform.
So, assuming all of these hypotheticals—now every sector of the product function is moving at hyperspeed. This creates a new, arguably bigger issue: maintaining real-time product organization alignment.
The Alignment Opportunity
When you have 50 agents and 12 humans working across Design, Build, and Distribute at 10x+ throughput, how do they make aligned decisions?
Choices that don’t conflict with strategy. Don’t repeat past failures. Don’t break adjacent systems. Don’t violate platform philosophy. Apply the key learning from 10 minutes ago that used to take 2 months to disseminate.
Current orchestrators manage operational state—the workflow graph, what’s in progress, what’s blocked. Procedural memory.
What they don’t manage is semantic state—the meaning behind the work. Why does this feature exist? What did we try before? What’s adjacent? What strategy does this serve?
I’ve been calling this the Context Library—a five-dimensional knowledge graph with an AI librarian providing 24x7 curation and gap assessments while also being available to assemble task-specific context on demand across the entire product org.
You can read more about the design & architecture here, but the core insight is this:
Most teams have some WHAT (specs) and HOW (code, docs). The missing bundle is WHERE (ecosystem context), WHEN (evolutionary context), and WHY (objectives context). That’s where implicit knowledge lives—the context humans absorb by osmosis, and agents usually never see.
The Library provides the semantic substrate that modern day orchestrators are missing.
Bringing it All Together
First, orchestration is evolving from “how do I coordinate agents during coding” to “how do I coordinate this software factory.” The winning approaches will treat orchestration as an operational problem, not a simulation of human hierarchy. Coordinators, workers, monitors—not fake org charts.
Second, Design and Distribute will follow Build. The contagion is inevitable.
Third, operational orchestration isn’t enough. Agents and humans need semantic context to make aligned decisions. The teams that figure out how to externalize institutional knowledge—making the implicit explicit, making the tribal queryable—will pull ahead.
The hot take: We are in the early innings of building AI native software factories, which means we are <36 months away from the truly AI native organization—because that’s what it will take to keep pace with maximum productivity.
(Jess & I are building this at SocioTechnica / LifeBuild right now. We’ll see how it goes.)