← Jeremiah Walters

Field notes

Validate the Slice, Not the Vision

Big ideas are cheap now. Proof still isn't.

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.

Animated cartoon: a cheerful robot takes a bite of one real slice of pizza, wiggles happily, then glances nervously at a thought bubble showing a sprawling dashed-line blueprint of agents, a coordinator, a dashboard and a roadmap. Agent AAgent BAgent CCoordinatorDashRoadmap The vision The slice
The vision gets a page. The slice gets built.

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.

Illustrative chart: the cost to imagine a system drops steeply from before AI tools to now, while the cost to validate it stays flat. The space between them is labeled where projects go to die. moreless Before AI toolsNow where projects go to die Cost to validate Cost to imagine
Illustrative, not measured. AI tools made imagining cheap. Proving it still costs what it always did.

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

InterfaceLogicDataIntegrationsbeautiful, and nothing runs

A slice

InterfaceLogicDataIntegrationsinput in, result out
A slice is thin and complete. It touches every layer, crudely, so the whole path can be tested on real input.

A good slice has four properties:

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?

Diagram: the weekly nudge went to me first, then a pilot group, then everyone. Each step forward required a yes to: does it help? A no loops back to fix the message. Meaudience of onehelps?Pilot groupa few volunteershelps?Everyonethe whole team annoys? fix it before it reaches more people
Each slice earns the next. The audience only grows when the current one says it helps.

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]

Two doors. A two-way door, reversible in about a week: slice it. A one-way door, a quarter or more to undo: think first, then still find the smallest experiment. Two-way door Reverse it in a week? Slice it. One-way door A quarter to undo? Think first.Then find the smallest experiment.
The reversibility test, borrowed from Amazon's one-way and two-way doors. [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:

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

  1. Arkes & Blumer, The Psychology of Sunk Cost, Organizational Behavior and Human Decision Processes (1985).
  2. Clint Shank, Start with a Walking Skeleton, in 97 Things Every Software Architect Should Know (O'Reilly), crediting Alistair Cockburn.
  3. OpenAI, A practical guide to building agents.
  4. Anthropic Engineering, Building effective agents.
  5. Microsoft Learn, Azure Architecture Center, AI agent orchestration patterns.
  6. John Gall, Systemantics (1975). See Systemantics on Wikipedia.
  7. Jeff Bezos, 2015 letter to Amazon shareholders, summarized in One-Way vs Two-Way Door Decisions.