THE
MANGROVEMANIFESTO
AI commoditised both the production and the knowledge of software engineering.
What remains scarce is domain knowledge, judgment, and context.
01
Working code
over artefacts
PROCESS
02
Full context
over coordination
ORGANISATION
03
Accountability
over estimation
CONTRACT
01 / The Root
One thing changed.
AI commoditised both the production and the knowledge of software engineering.
Two dimensions. Both matter.
PRODUCTION CAPACITY
Building is cheap
AI writes code fast. What took a team weeks takes hours. The raw cost of turning an idea into working software collapsed. This is the dimension most people notice first.
ACCUMULATED KNOWLEDGE
Expertise is abundant
AI knows every architecture, every language, every design pattern, every security vulnerability, every testing strategy, every deployment pattern. It has read, effectively, every technical book ever written.
What remains scarce.
The human's role isn't “person who writes code with AI help.”
It's “person with domain judgment directing an AI that has comprehensive technical knowledge.”
02 / The Consequence Tree
Everything else is derivative.
First, second, and third-order consequences, traced to their root.
The bottleneck shifted to direction and comprehension
One person + AI replaces a team
BROOKS'S LAW
The best software teams used to be seven people. Now they are one or two, plus AI.
7±2 →1 or 2
People on the team
21 → 1
Lines of communication · n(n-1)/2
Seven, plus or minus two, was never about the work. It was a ceiling on coordination. Communication channels grow as n(n-1)/2: every person you add taxes every person you have. A team of seven carries twenty-one lines of communication. A pair carries one.
Those channels existed to move knowledge between specialists: the architect explaining the design to the backend developer, the backend developer explaining the API to the frontend developer, everyone explaining everything to the tester. AI holds the knowledge now. The channels have nothing left to carry.
Twenty-one lines of communication collapse to one. The team collapses with them, from 7±2 to one or two seniors plus AI. The coordination tax isn't managed better. It's deleted. This is the operating model YC describes for AI-native companies; we run it end to end.
Iteration becomes nearly free
03 / Three Values
Three root values.
Each addresses a different domain. Everything else derives from these.
01
PROCESS
Working code over artefacts
The foundational shift. Building is the discovery. When a working prototype costs less than the meeting to discuss the specification, the spec becomes the build. But it goes deeper: artefacts didn’t just exist because building was expensive. They existed to transfer knowledge between people; architecture documents shared decisions, coding standards ensured consistency, design reviews transferred expertise. If AI holds that knowledge and one person directs, the transfer function of these artefacts disappears too.
Replaces: spec-first development, knowledge-transfer documents, design-by-committee
02
ORGANISATION
Full context over coordination
The human’s value isn’t technical knowledge anymore; AI has that. The human’s value is domain knowledge and judgment. A small senior team directing AI is a more capable unit than a big team coordinating specialists. AI’s knowledge is broader than any individual specialist’s, and one mind’s judgment is more coherent than a committee’s. This is why experience matters more, not less. AI amplifies judgment. A junior directing AI gets technically correct code that misses the point.
Replaces: Scrum ceremonies, specialist silos, knowledge as competitive advantage
03
CONTRACT
Accountability over estimation
When building is cheap, commitment is honest. T&M contracts existed because uncertainty was genuine; nobody could predict what building would cost. Now discovery is faster and more thorough: AI brings knowledge to exploration, knows what questions to ask, what patterns apply, what risks to flag. You build to discover scope, then commit to delivering it. Fixed price becomes honest. The buyer gets what the original Agile Manifesto promised but rarely delivered: real accountability.
Replaces: T&M billing, estimation theatre, scope creep as business model
04 / What It Means
What this means for you.
If you’re buying software
- →Demand working prototypes before committing budget, not slide decks
- →Expect fixed-price commitments based on proven scope
- →Look for partners who demonstrate, not who present
- →Your leverage increased; building is cheap, mediocre isn’t acceptable
If you’re building software
- →Your value is domain knowledge and judgment, not keystrokes or technical trivia
- →AI amplifies good architecture and bad equally; your judgment is the filter
- →Experience matters more, not less; a junior gets correct code that misses the point
- →Ship working software early; the cost of being wrong is a conversation, not a quarter
If you’re running a team
- →A small team with full context and AI outperforms a big team coordinating fragments
- →Process overhead has a new, much lower, break-even point
- →Hire for judgment and domain depth, not just technical skill
- →The org chart that made sense when building was expensive may not make sense now
The problems haven't changed.
The economics of solving them have.
AI commoditised both the production and the knowledge of software engineering.
Three values capture what that means. Everything else is commentary.
See this in action
We deliver software using this methodology. Fixed price. Clear spec. Money-back guarantee.