the book · available now
The Bottleneck Is Never the Stack
Building Software in the Agentic Era
Execution got cheaper. Clarity did not.
AI did not create the real bottleneck in software. It made the old one impossible to hide.
Brookfield Press · Kindle, paperback & hardcover · 152 pages
about the book
What it argues
For decades, engineering organizations treated code as the durable asset and implementation speed as the constraint. In the agentic era, that assumption is breaking. When AI can turn a clear specification into working software with increasing speed, the scarce work moves upstream: framing the problem, defining intent, enforcing standards, evaluating outputs, and owning the consequences.
The Bottleneck Is Never the Stack is a collection of essays about building software when agents become part of the delivery system. It argues that the next advantage will not come from chasing the newest tool, model, framework, or cloud service. It will come from clearer specs, stronger systems, better judgment, and operating models that make good decisions repeatable.
This is not a tool survey. It is an operating argument for leaders and builders trying to make AI useful without turning their codebase, culture, or delivery process into a faster mess.
The bottleneck is never the stack. It is the clarity of intent, the discipline of decision, and the quality of the conversation about what we are actually building.
inside the book
Six arguments it makes
- 01
Why "the spec is the product" and code is becoming downstream of intent
- 02
How agentic development changes the software delivery life cycle
- 03
Why personal agents decay, but team-owned systems can compound
- 04
How platform teams can encode standards, security, and compliance into the pipeline
- 05
What humans still own when execution becomes cheaper
- 06
Why leadership in the agentic era requires honesty about the work AI reshapes
the chapters
Thirteen essays, one arc
It opens with an introduction and a short guide to four reading paths, then moves through four parts.
the big picture
See the whole book as one mind map
Six branches on one page: the central argument, the three pillars, the agentic SDLC, the dark factory model, the human role, and metrics & governance.
View the mind mapOpening
The Bottleneck Is Never the Stack
A year of writing, one argument, and a working theory of where software is going.
How to Use This Book
Four reading paths through the same argument.
Part I · The New Bottleneck
The Frame Is the Bottleneck
As agents get better at execution, the constraint moves upstream to the human framing of problems.
Part II · The System
The Dark Factory Model
Most engineers treat AI-generated code like work from a junior developer they do not trust. There is a better mental model.
The Agentic SDLC: Uniting the AI Tool Sprawl
Every tool in your pipeline is now an AI agent trying to do everything. Here is how to draw the boundaries.
The Spec Is the Product
Code used to be the durable asset. In an agentic SDLC, the code is exhaust and the spec is the product.
Spec, Standards, Specialists
One spec, one standards file, a handful of specialist agents: the whole workflow, including the five costs it charges.
Part III · The Practice
Case Study: From Vague Request to Verified Change
A small notification-preferences feature, followed from idea to release.
The Confident Defect
What happens when the loop does not work, and what a useful post-mortem looks like in an agentic system.
Part IV · Accountability
Pipeline-First Is Not a DevOps Initiative
The pipeline is the artifact. The culture is the product.
Redesign the Work, Not the People
The first AI reorg that works redraws workflows, decision rights, ownership, and evaluation loops before it redraws the org chart.
Whose Code Is It Anyway?
Provenance, liability, and the conversation enterprise legal is already having about the code your agents generate.
The Bargain Underneath
The subsidy that made AI feel free is ending, and the bill lands on the people building the systems.
formats
Three ways to read it
the author
Who wrote this
Vinny Carpenter has spent more than thirty years building software and leading platform and engineering teams. He is a Vice President of Engineering at a Fortune 100 company, leading Cloud, Platform & DevOps.
He writes at vinny.dev on agentic development, spec-first delivery, and the human bargain behind automation. This book grew out of that public writing practice: a year of essays sharpened into one argument. He lives in Brookfield, Wisconsin.
Start where the book started
The book grew out of a year of essays. Read the one that first named the argument, then take the whole thing with you.
where the royalties go
I didn't write this book to make money. I wrote it to prove something to myself and to put down ideas I'd been circling for years.
So the little it earns should do some good. 100% of my royalties from this book go to Girls Who Code. They help young women build the skills and confidence to thrive in tech.
If this book nudges one more person toward building, and helps fund a few more who want to start, that's a trade I'll take. Thank you for reading.