TL;DR. Most first AI initiatives in mid-sized businesses don't fail because of the technology, but because of how they are scoped: they are planned as six-month projects, sprawl in breadth and end up in a drawer as half-finished prototypes. This article's counterthesis is simple: treat your first pilot like a geological core sample — not like an excavation pit. Instead of twenty features that all stay on the surface, you take one narrow, complete cut through every layer: from real data to the real decision made by the real user. Three rules hold it together: six weeks, a defined go/no-go gate before the first line of code, a narrow cut instead of a broad surface. And a human in the loop from day one. The result is not a finished product — it is something more valuable: an honest, evidence-based answer to the question of whether this use case holds up.
At this point, the use case is already settled (how to choose it), and the fundamental question of build, buy or compose has been answered (along your own vertical integration). Now comes the part where mid-sized businesses most often stumble: execution.
Why six months is the most comfortable way to fail
Half a year sounds like diligence. In reality, it leaves plenty of room for four patterns that repeat themselves with alarming reliability.
- Scope creep. During the concept phase, “one use case” turns into five. Every department adds another requirement, the first real test keeps slipping further away, and in the end you build a platform because “X could be added later.”
- No success metric defined up front. If nobody writes down at the start how success will be recognized, the pilot can never be finished — only worn out. What remains is a “sort of works.” How to choose the one right metric, set it against a baseline in advance and secure it with a guardrail is covered in depth in The one note: exactly one success metric per use case.
- No owner. A pilot without a named person responsible for it is a pilot nobody brings to completion. A steering committee owns nothing; it meets.
- The covert leap into production. The pilot is quietly expected to become the live system. That loads the full weight of production — availability, data protection, rollback — onto a phase that was meant for learning. Doing both at once smothers the learning.
Six months are not the problem in themselves. The problem is breadth: lots of surface, little depth, and in the end a prototype that does many things halfway and nothing completely. Speed is therefore not a matter of rushing, but a matter of trust. A small, visible win after six weeks convinces an organization more than the perfect concept after six months — because people believe results, not slides.
The guiding idea: a drill core, not a pit
When a geologist wants to know what lies beneath a field, they don't dig up the whole field. They extract a drill core — a narrow column that reaches through every layer: topsoil, clay, rock. From this single, thin cylinder they read the entire structure. A single point, but across the full depth.
That is exactly what your first AI pilot should look like: one complete end-to-end case, from the real input to the real result in day-to-day work. Not “the assistant can handle every invoice type,” but “the assistant processes this one supplier document from receipt to a draft posting.” A thin vertical cut through all layers — data, model, process, human, decision — at a single point. In software development, this pattern is called a walking skeleton: a skeleton that already walks before it has muscles. It forces every integration question to the surface early instead of postponing it to the end of the project, where it gets expensive.
Wherever possible, compose the narrow path from existing parts — a model API, an existing data export, a mailbox — instead of building a surface of features that never goes all the way through anywhere. Breadth can be added later. A cut that never gets all the way through cannot be repaired.
Drill core instead of pit: depth beats breadth
The pit
wide and shallow: many features, none finished
The core
narrow and deep: one cut through every layer
The gate comes before the build
The most important sentence of the entire initiative is written in week one. Before anything is built, the owner writes down one sentence that contains a measurable threshold and a date:
“The pilot counts as a success if, by the end of week 6, it completes specific task X under condition Y more reliably or faster than the current approach — tested on real cases.”
This threshold is the gate. It is agreed in advance and not watered down after the fact. That is the most uncomfortable and at the same time the most important discipline, because it keeps the pilot honest. And the uncomfortable truth behind it: The pilot is allowed to fail. A clear no after six weeks that stops the wrong use case is not a lost project — it is the cheapest lesson you will ever buy. The only expensive pilot is the one that fails and keeps running anyway out of inertia.
The process: six weeks, four phases, hard gates
This is a rhythm, not a form to fill in. Shift the weeks to suit your case — but keep the order and the gates.
- Weeks 1–2 — Data & definition. Cut the one end-to-end case sharply. Write down the success criterion, in black and white. Get real sample data — the data that actually exists, not the data that should exist, and nothing constructed. Gate 1: Do we have clean data and a sharply defined case? If not, stop here; don't keep building.
- Weeks 3–4 — Build or compose along the thinnest cut. Only the skeleton, only this one path. Human in the loop is built in, not bolted on: the AI proposes, a human confirms. The radius of impact — the blast radius — stays small: the pilot touches ten transactions, not ten thousand; one mailbox, not the ERP; nothing irreversible.
- Week 5 — Real user test. The person who actually handles the case uses the skeleton on real transactions. Not the project manager, not IT, not the team praising its own work — the business user. Gate 2: Does it hold up against real input?
- Week 6 — Measure & go/no-go. Hold the result against the threshold defined in week 1. Gate 3: Go, no-go or a deliberately justified “one more round of refinement.” A decision, not a request for an extension — and no invented numbers, only what the real cases show.
Six weeks, four phases, hard gates
Human in the loop, from day 1
Criterion fixed in week 1
Go: on into operation. No-go: stopped deliberately, which is a result too.
Anti-patterns: which shortcuts are allowed — and which never are
A good pilot takes shortcuts deliberately. A bad one takes them in the wrong places.
Shortcuts you may take deliberately: hardcoding instead of a configuration UI. One data type instead of all of them. Manual triggers instead of automation. Rented building blocks instead of building your own. All of this is scaffolding that comes down later — and that is exactly what a pilot is for.
Shortcuts you must never take: the success criterion defined in advance. The human in the loop. The small blast radius. And honest measurement with the real user. Cut corners here, and you cut out precisely the insight the entire pilot exists to deliver.
The rule of thumb: Drill a core, don't dig a pit — and the no is defined before the build.
The quietest trap: a pilot is not operations
Passing the go gate means: the case works. It does not mean that the system is production-ready. A drill core proves that the layer holds — it is not yet a foundation. If the core holds, the temptation is great to simply “leave it live,” and this is exactly where everything can still tip over in the end.
Operational readiness is a separate stage, with its own planning: monitoring, failure behavior under load, permissions, clean handoffs to people, data protection in continuous operation, scaling beyond the one case. None of this emerges in the pilot, and none of it may be quietly skipped. Anyone who simply opens the narrow core up for live operation runs straight into the operations gap — the leap from a working pilot to reliable continuous operation, where most AI solutions believed to be in production fail.
Where to go from here
If you want to follow this path step by step:
- Choosing the first use case — finding the layer that is worth drilling into at all.
- Build, buy or compose along your vertical integration — deciding what to extract the core with.
- This pilot — the narrow, complete cut in six weeks.
- The map from pilot to production — the complete overview of all five stages up to a reliable agent, with a door to each one.
- Closing the operations gap — the deep dive into precisely the first, hardest leap: from a passed pilot to robust continuous operation.
Six weeks won't give you a finished product. They give you an evidence-based answer before you invest months — and protect you from the most expensive drawer of all: the one that stays open. This is how we work, and how we think about pilots: narrow, deep, honestly measurable (the azena way). If you want to set the first core together — we'll help with the cut.
Part of the adoption map: Rolling out AI in mid-sized businesses — from idea to adopted solution.
