Core Thesis
The common narrative is that AI will make large engineering organizations more productive. More developers, augmented by AI, should produce more software.
This is directionally correct but structurally incomplete.
AI does not scale organizations linearly. It compresses the cost of producing code while leaving coordination costs largely intact. As a result, the binding constraint in software development shifts from writing code to aligning systems, decisions, and intent.
In that environment, smaller teams gain a structural advantage.
The Old System
Historically, software delivery was constrained by the throughput of engineers writing and maintaining code.
Large teams existed for a reason:
- More engineers meant more code produced
- Specialization improved efficiency (frontend, backend, infra, QA)
- Management layers coordinated work across functions
- Process (tickets, standups, reviews) ensured output consistency
Coordination was expensive, but it was justified. The bottleneck was production.
You accepted organizational overhead because it enabled more code to be written.
What Changed
AI fundamentally alters the production function of software.
Code generation, refactoring, and even system scaffolding are now cheap and increasingly automated. A single engineer can produce what previously required a team.
This does not eliminate engineering work. It changes its shape:
- Less time spent writing boilerplate
- Faster iteration cycles
- Lower cost to explore solution space
- Higher surface area of possible changes
The system now produces more code than organizations can absorb.
This is the inversion.
The New Constraint
As production becomes abundant, coordination becomes the bottleneck.
Not coordination in the abstract, but in very specific forms:
- Decision alignment — what should be built, and why
- Interface stability — how systems connect without constant breakage
- Context sharing — ensuring engineers (and AI systems) operate with the same mental model
- Change management — controlling the blast radius of rapid iteration
Large organizations amplify these costs:
- More stakeholders → slower decisions
- More boundaries → more integration overhead
- More parallel work → more conflicts and rework
- More process → slower feedback loops
AI does not reduce these costs. In many cases, it increases them by accelerating the rate of change.
This is why adding more AI-assisted engineers does not linearly increase output. It increases coordination load.
Implications
Small teams benefit because they minimize the new constraint.
They operate with:
- Shared context by default
- Fewer communication edges
- Faster decision cycles
- Tighter feedback loops between idea and production
In a world where code is cheap, these properties matter more than raw engineering capacity.
This does not mean large organizations disappear. It means their internal structure must change.
The advantage shifts toward:
- Modular architectures that reduce coordination surfaces
- Clear system boundaries with stable interfaces
- High-trust teams with end-to-end ownership
- Tooling that encodes context (not just code generation)
Without these, scale becomes a liability.
System Insight
AI does not simply make engineers faster. It changes what the system is optimizing for.
The historical system optimized for code throughput.
The emerging system optimizes for coordination efficiency.
Small teams win not because they are more talented, but because they are structurally aligned with the new constraint.