There's a way of building software that's unusual in product engineering and central to forward deployed work: build a running demo of the whole end-to-end system very early, and organize every engineering decision around it.
Bob McGrew calls it demo-driven development. Early Palantir had one demo, an analyst stopping a terrorist plot, and every capability had to make sense inside that flow.
It sounds naive. It isn't. A capability-first approach asks what each piece does. A demo-first approach asks what the customer sees, and whether it makes them want it. The second question catches a kind of design failure the first one misses every time. In an FDE engagement, the demo is the operating contract. The customer signs off on a flow, the FDE builds against it, validation tests it, and delivery hands it over running on production data.
Start smaller than feels comfortable
The first slice should be the smallest piece of work that makes a complete demonstration. It starts at a customer input and ends at a customer output. It touches every layer the production system will touch, however thinly. It doesn't have to handle every case. It has to handle one case completely.
Anthropic's "Building Effective Agents" essay gave the canonical version of this for the agent era: start with direct API calls and the simplest workflow that works, and reach for an agent only when the path genuinely can't be known in advance. The reason is failure surface. A workflow usually breaks in one identifiable place. An agent can break anywhere along the path it chose. Early in delivery, failures you can locate are worth a lot.
My own first versions are a literal sequence of API calls with no agent framework and no abstractions. On a contract-review deployment for a commercial real estate firm, the entire first slice was three weeks of work and three Python files: a sixty-line main.py, a parser of about 140 lines (where most of the complexity lived), and a forty-line formatter. Plus version-controlled prompts and the eval suite. No orchestration library, no vector store. The deputy general counsel could read every prompt in fifteen minutes. The firm's IT lead could run it on his laptop in another fifteen.
Dex Horthy's 12-Factor Agents captures the habits that make a slice production-ready instead of demo-fragile. Own your prompts and version them like code. Own your context window rather than letting a framework spend it. Treat tool calls as structured outputs, the testable boundary between the probabilistic and deterministic parts. Make state explicit. And design the human-in-the-loop hook from the first commit. You can remove the human later. You can't easily add the hook later.
Hand over the keyboard
The best slices show the user a familiar problem in a form they recognize, do something they didn't believe was possible, and collapse the time between problem and answer to seconds. In AI work that means real customer data, output in the customer's own format, and the same flow they'd use in production. Realism is expensive, but it pays: the customer's objection reflexes, trained on years of generic vendor demos, never fire. They're watching their own data processed by software that didn't exist last week.
Then give them the keyboard. The demo for that contract-review slice ran on a Friday afternoon, on the deputy GC's own laptop, with five real contracts from her inbox that morning. Each took about fourteen seconds. Two of the five had problems: a missed auto-renewal clause and a wrong risk grade on an indemnity. She flagged both within ninety seconds, and they became eval cases #43 and #44 before the meeting ended. Within a month the slice had grown into a full workflow that pulled contracts from email and posted memos into the firm's case management system.
The narrated walkthrough, where the vendor types and the customer watches, gets polite applause and not much else.
The temporary fix that isn't
Speed has a failure mode, and Vinoo Ganesh owns the best story about it. Early in a Palantir engagement he wrote a quick Groovy script as a stopgap for a data-retention problem. Twelve months later it was load-bearing for a customer of nearly a hundred thousand people. The filename became his nickname inside the company, and guests at his wedding wore shirts printed with it.
"The most dangerous words in forward deployed engineering," he says, are this is just temporary. "If it solves a problem, it's not temporary. It will live forever." So ship the slice fast, but ship it as if it will run for eighteen months, because it probably will. His pre-ship check is four questions: Will I get a 2 a.m. call about this in six months? What did I trade away to move this fast? Who do I hand it to? What happens when it breaks?
The AI-era version is restraint. Decagon's Sunny Rekhi says that when a big customer wants something by Friday, the temptation is to prompt a coding agent into a one-off, and that the scarce skill now is not doing that. Code has become the cheap part. Cognition's Jia Wu estimates writing code faster is usually only about 20 percent of the problem. The rest is how it gets tested, reviewed, deployed, and maintained.
When the demo bombs
The first slice fails on customer data more often than anyone admits. The instinct is to apologize, promise a fix, and rescue the meeting. Don't. Pull up the prompt in front of the customer and ask what it failed to anticipate about the input. They'll tell you, and that conversation is worth more than a clean demo, because they learn the system was built to be debugged in front of them.
If your first demo can't fail without the engagement collapsing, it isn't a demo. It's a sales artifact.
Thinking about moving into this work?
I wrote a free guide for people considering forward deployed engineering: what the 4.6x growth figure means, how to tell a real FDE role from a renamed sales job, and a 30-day plan that ends with your first piece of proof.