The First Signs Something Isn’t Adding Up
If you spend enough time in AI pre-sales, you start noticing the micro-glitches before anything officially “breaks.” It’s never the dramatic stuff. It’s always something small—a pause on a slide that should have been straightforward, or a sentence that loops back on itself like the speaker realised halfway through that they don’t fully believe what they’re saying. Sometimes it’s someone nodding too quickly. Sometimes it’s the way a question gets dodged, not intentionally, but in that way people avoid opening a door they know leads to a very cold room.
Everything around those moments still looks perfectly fine. The deck looks polished. The conversation stays upbeat. The client nods because that is what clients do during pitch calls. Sales keep the optimism dialled up. Delivery stays quiet because the quickest way to sound “negative” is to say something accurate too early. Procurement repeats phrases like “alignment” and “timeline integrity,” and nobody wants to unpack what those actually mean. Everyone leaves the meeting believing things are on track. But the people who have been through enough cycles know the truth: the deal is already drifting, even though the metrics still look green.
The Quiet Fiction That Every Pipeline Depends On
Pre-sales, by default, operates inside a polite shared fiction. No one lies. They just tilt the truth a little. They phrase uncertainties like they are known quantities. They sand down the edges of complex problems because complexity slows the conversation, and slowing the conversation feels like losing momentum. And momentum is the unofficial currency of every deal cycle.
The strangest part is that the fiction is not malicious; it is structural. Teams soften everything to keep things moving. People make a feature sound simpler because explaining the real complexity would require another thirty minutes. Someone says, “We can probably do that” because they want the meeting to end on a high note. If you stack these small distortions across three weeks of pre-sales calls, the project quietly becomes a mirror image of itself, recognisable but not real.
You start noticing the fiction creeping in when no one actually remembers the original problem the client came with. The conversation shifts from the need to the narrative. The pain point becomes a backdrop for the pitch instead of the reason the pitch exists. And by the time the proposal hits someone’s inbox, the version of the product being described only exists inside the comfort zone created by the call recordings.
How Scope Turns Into a Moving Target Nobody Acknowledges
Scope rarely explodes. It just stretches. A little here, a little there. Someone adds a “tiny” requirement that is clearly not tiny. Someone reframes a constraint because the original wording sounded too limiting. Another person expands the definition of the MVP because “the client might expect it.” Nobody pushes back because pushing back introduces friction, and friction in pre-sales feels like sabotage.
The MVP becomes a moving target disguised as clarity. Every addition sounds harmless. Everything sounds like “just a minor extension.” And everyone who has ever delivered anything knows exactly what these phrases translate to: the scope now depends on a set of systems that have never cooperated before, and no one wants to admit it because the proposal is already being drafted.
By the time the final deck goes out, the scope is a stitched-together hybrid of assumptions, optimism, and whatever made the last meeting feel smoother. It doesn’t resemble the original ask. It doesn’t resemble anything physics can support. But it does resemble something that helps the deal stay alive, and that is enough for everyone in the pipeline to pretend it’s feasible.
The Timeline That Begins as Negotiation Instead of Reality
Timelines inside the deal cycle behave like rubber bands. Someone says twelve weeks because twelve sounds like a serious number. Someone else counters with eight because eight sounds aggressive in a way clients interpret as “hunger.” Neither person has looked at the data. Neither knows the system dependencies. Neither has any idea how many approvals it takes for a single internal decision. But the timeline gets decided anyway, because in the early stages, time is not a constraint—it’s a negotiation.
Engineers listen in silence because pushing back too early marks you as “blocking momentum.” Leadership nods because the number doesn’t feel real yet. It becomes real the moment the contract gets signed. At that point, the timeline that was invented casually becomes the baseline every downstream team is held accountable to. And delivery ends up paying the interest on a number that was chosen for its emotional appeal, not its feasibility.
The RFP That Breaks Reality in Slow Motion
Then comes the RFP, which is where the illusion becomes harder to ignore. RFPs treat AI like traditional IT: predictable, deterministic, schedulable. They demand experimental systems that carry zero risk, custom systems that deploy in weeks, autonomous systems that are fully controllable, and cheap systems that behave like premium ones. The contradictions are not subtle. If you read most RFPs closely, they sound like someone took five different wish lists from five different departments and merged them into a single fantasy document.
Everyone notices the contradictions. Everyone chooses to ignore them. Challenging an RFP feels like jeopardising the deal, so people respond with diagrams that look perfect—flows with neat arrows, clean boundaries, and a level of architectural harmony that would require several miracles back-to-back in the real world. Those diagrams are not wrong; they’re simply not true. And the whole process continues as if truth is optional at this stage.
Kickoff: The Moment the Illusion Expires
Kickoff meetings always start the same way: upbeat intros, a confident reminder of the vision, and a general sense that things are finally moving. And then someone asks a question like, “Where does this field actually come from?” What happens next is predictable for anyone who has ever been in a real AI delivery.
Silence.
Not the comfortable kind.
The kind that tells you nobody validated the input layer.
The kind that tells you the data maturity was assumed, not checked.
The kind that tells you the deal cycle agreed to build something on top of data no one inspected, because doing so earlier would have slowed things down.
What follows is an unravelling that feels almost mechanical. The client assumed one reality. The vendor assumed another. Sales are committed to a third. Architecture guarded a fourth. Governance demands a fifth. Delivery is suddenly responsible for reconciling all five, even though they had no part in creating the contradictions.
This is the moment every collapsing AI project traces back to—not the moment it fails in delivery, but the moment it reveals it was never structurally possible in the first place.
The Slow Disintegration Everyone Mistakes for “Normal Challenges”
Once delivery begins, the story starts to wobble in slow motion. Engineers quietly rewrite assumptions that should have been validated months earlier. Architects redraw boundaries that conflict with what was sold. Governance adds new checkpoints that no one budgeted for. Leadership asks questions rooted in expectations that came from pitch-room enthusiasm, not technical reality.
The project doesn’t crash dramatically. It just dissolves, meetings loop without progress. Milestones become flexible interpretations. People start losing track of who is blocking whom because the actual dependency map was never drawn, honestly. And yet somehow the blame always gravitates toward AI itself, as if the model chose the wrong timeline or expanded the scope by itself.
The real villain is the pipeline. But the pipeline has no face, so people blame the part of the system that cannot argue back.
The Only Fix That Has Ever Worked
Teams keep searching for a procedural fix, standardised templates, better governance, new process rituals, stricter checklists, fancier documentation. None of that solves the core issue. AI projects survive only when someone in pre-sales refuses to negotiate with physics.
The cure is unglamorous: define the MVP before you discuss cost, inspect the data before you promise a timeline, validate assumptions before you draw architecture, and force clarity before enthusiasm rewrites the problem. Everything else is theatre designed to make meetings feel smoother rather than make the program viable.
The industry likes to pretend AI complexity is the reason projects fail. It isn’t. The reason is simpler and far less flattering: too many deals are negotiated in an alternate reality, and the project never manages to re-enter the correct one.
The Truth the Industry Still Doesn’t Want to Confront
AI does not take down AI projects; the pipeline does, the illusion does, the optimism does, the refusal to ground truth early does. Deals do not fail at deployment. They fail the moment someone decides to win the room instead of describing what is actually possible, until organisations stop writing promises that physics refuses to honour, delivery teams will continue inheriting outcomes they never had a chance to fix.