Every ambitious engineer knows the feeling. Three days into a problem, you can suddenly see the whole thing. Not just the fix. The platform. Agents that each own a workflow. A coordinator routing between them. A dashboard that shows leadership the state of the world. Clean interfaces, a roadmap, a name.
It's a great feeling. It's also the most dangerous moment in the project.
I've learned to treat that moment as a warning sign, not a green light. Not because the vision is wrong. It might be exactly right. But a vision is a stack of assumptions, and until something real runs against real input, you don't know which ones are load-bearing and which are fiction.
So my rule is simple: validate the slice, not the vision.
Why the Grand Vision Fails
Big plans rarely fail because the idea was bad. They fail for boring reasons.
Feedback arrives last. Build the whole system before anything runs end to end, and the first real signal shows up after most of the budget is gone. If an assumption at the bottom of the stack is wrong, everything above it is wrong too.
Sunk cost takes over. After five components, you stop asking "is this right?" and start asking "how do I make this work?" Those are very different questions. Researchers have measured this since the 1980s: the more we've already put in, the more likely we are to keep going. [1]
Trust erodes before you ship. People can only hear "it'll be ready when the rest of it lands" so many times. The vision asks for faith. A working slice earns it.
And there's a newer problem. AI tools made the grand vision feel almost free. You can sketch an architecture, scaffold a dozen services and generate a convincing design doc in an afternoon.
The cost of imagining collapsed. The cost of validating didn't. That gap is exactly where projects go to die.
Lesson: A vision is a stack of assumptions. Find out which ones hold weight before you build on top of them.
What a Slice Actually Is
A slice is not a demo that only works on stage. It's not one layer of the architecture built to perfection either. Alistair Cockburn called it a walking skeleton: a minimal, end-to-end implementation that connects the main parts. [2]
One layer, perfected
A slice
A good slice has four properties:
- It runs end to end, narrowly. Input goes in, a result comes out, and every stage in between exists, even if it's crude.
- It touches real input. Not mock data shaped to make it pass. Real cases, with all their mess.
- It has a pass/fail test you can't argue with. Decide in advance what result tells you to stop. If you can't name one, you're not validating anything. You're decorating.
- It's cheap to throw away. If deleting it would hurt, it's too big.
OpenAI's guide to building agents gives the same advice for AI work: "Start small, validate with real users, and grow capabilities over time." [3]
Three Slices That Taught Me Something
A triage system that only proposed
The vision: an intelligent system that sorts findings and routes them to the right owners automatically. The slice: plain, rule-based checks that proposed a classification and left the decision to a person. No AI in the decision path at all.
It ran on a small set of real findings. The numbers were tiny, and that was the point. They showed whether the rules matched how people actually triage, before anything got built on top of them.
A demo that ran offline first
I wanted to show a pattern for keeping AI agents in check. The tempting version called a live model and coordinated a whole set of agents. The slice was a small program that replayed recorded model responses and ran deterministic checks on them.
No live model. No dependencies. Anyone could run it on a laptop in a minute. It proved the pattern was understandable before I tried to prove it was scalable.
An automation whose first audience was me
The vision: a weekly nudge that keeps a whole team's work tracker clean. The slice: the same nudge, sent only to me. Then to a small pilot group. Then to everyone. Each stage answered one question: does this message help, or does it annoy?
None of these slices were impressive. All of them were informative.
Lesson: That's the trade. Give up impressive to get informative.
How to Resist the Vision Without Killing It
The answer isn't to stop having big ideas. It's to change what you do with them.
Write the vision down, then park it. Give it a page. Let it be ambitious. Then close the doc. The vision is a direction, not a build plan.
Turn the vision into questions. Every component in the grand design rests on a belief: "people will trust automated proposals," "the data is clean enough," "other teams will plug in their own checks." Each belief is a candidate slice.
Make each slice earn the next one. The next slice gets built only when the current one passes its test. If it fails, you learned something cheaply, and the vision gets revised instead of defended.
The people building the models agree. Anthropic recommends finding the simplest solution that works and adding complexity only when it demonstrably improves outcomes. [4] Microsoft's architecture guidance for agents says it in one line: "Use the lowest level of complexity that reliably meets your requirements." [5]
Show slices, not slides. A small thing that runs beats a beautiful diagram in almost every room. It changes the conversation from "do you believe me?" to "what should we try next?"
John Gall wrote it down in 1975: "A complex system that works is invariably found to have evolved from a simple system that worked." Fifty years later, still undefeated. [6]
Lesson: Keep the vision. Just make it earn its way into the build, one slice at a time.
When Slicing Is the Wrong Call
To be fair, some decisions can't be sliced. A data model everything else depends on. A security boundary. A platform that's expensive to leave. These need upfront thinking, and pretending otherwise is its own kind of recklessness.
Jeff Bezos drew the same line in Amazon's 2015 shareholder letter. Reversible decisions are two-way doors: make them fast. Consequential, nearly irreversible ones are one-way doors: slow down. [7]
My test: if you can reverse the decision in a week, slice it. If reversing it would take a quarter, think harder first. Then still look for the smallest experiment that reduces your uncertainty before you commit.
A Checklist for Your Next Big Idea
Before you build the grand version, ask:
- Can I run something end to end on real input this week?
- What result would make me stop or change direction?
- What's the one assumption that, if wrong, breaks everything? Am I testing that one first?
- Could I delete this slice without regret?
- Who will see it, and what decision will it help them make?
If you can answer those, you're ready to build. Small.
The vision will still be there when you're done. It'll just be better informed.
References
- Arkes & Blumer, The Psychology of Sunk Cost, Organizational Behavior and Human Decision Processes (1985).
- Clint Shank, Start with a Walking Skeleton, in 97 Things Every Software Architect Should Know (O'Reilly), crediting Alistair Cockburn.
- OpenAI, A practical guide to building agents.
- Anthropic Engineering, Building effective agents.
- Microsoft Learn, Azure Architecture Center, AI agent orchestration patterns.
- John Gall, Systemantics (1975). See Systemantics on Wikipedia.
- Jeff Bezos, 2015 letter to Amazon shareholders, summarized in One-Way vs Two-Way Door Decisions.