Handwave AI

A note on building with AI

The destination vs the journey

A way of thinking about when to trust what AI hands you.

Aaron Nelson · Founder & CEO, Handwave AI

We can reach our destinations incredibly fast with AI. Ask for a feature, a report, a segment, an analysis, and in seconds you have something that looks right. That speed is real, and it's a genuine gift. But there is a trap folded inside it, subtle enough that any team can walk into it at full speed.

A plausible-looking result and an actually-correct one are indistinguishable by looking at them. The only way to tell them apart is to see the work.

AI optimizes for the destination: asked for an answer, it produces a confident, well-formed one, whether or not it did the reasoning that answer requires. It skips the middle and hands you a clean-looking arrival, and because the arrival looks clean, nothing warns you the journey didn't happen.

Destination versus journey

  • The destinationThe output: the feature, the chart, the answer. AI reaches it fast, and it always looks finished.
  • The journeyThe stops along the way, each one critical to the destination's accuracy: did it read the actual inputs, did each step do what it claims, what did it skip, what did it assume. Correctness lives here, and AI skips it unless something forces it to show the stops.

The teams that win with AI aren't the ones that reach the destination fastest. They're the ones who make the AI show its journey, so a fast result is also a trustworthy one.

How AI skips the journey

It isn't malice, and it usually isn't a bug. It's what “reach the destination” rewards: asked for a convincing output, the fastest path is to produce one, and the reasoning that would have earned it is optional. So the corners it cuts are predictable.

  • Manufactured confidenceThe tone of certainty is generated alongside the answer, not derived from it. A guess and a fact arrive wearing the same voice.
  • Plausible invented detailA number, a citation, a field that fits the shape of the answer and was never actually in the inputs. It reads right because it was built to.
  • Papered-over gapsWhere a step was hard or the data was missing, a smooth surface appears instead of a flag. The absence of a warning is not the presence of a check.

The tells: spotting it before it bites

You can catch destination-without-journey early, if you know the signals. They're consistent.

  • It can't trace itselfAsk how it got there and you get a restatement of the answer, not a path. Real reasoning can walk you back through its steps; confabulation can only repeat the conclusion.
  • It gets vaguer under pressureProbe a specific claim and the response softens and generalizes rather than sharpening. A sound result gets more precise when you push on it, not less.
  • It's unstableAsk the same thing twice and get materially different answers. A result grounded in the data is stable; one improvised to satisfy the prompt drifts.

Honesty is not the same as trust

It is entirely possible for an AI system to be perfectly honest and still not trustworthy. Honest means it isn't lying about what it did: the pipes are real, the data is real, the labels are true. Trustworthy means the answer was actually earned from your inputs. A system can have the first without the second, a real result, honestly served, that was never derived from your data. So the question to ask isn't just “is this real?” It's “can you show me the journey that produced it?”

What changes when you demand the journey

The fix is cheap and it costs no speed; it changes what you require of the output, not how fast you move. Asking for the journey is as much a cultural shift as a technical one, from “did the AI produce something” to “can it show its work.” Three questions turn a plausible destination into a trustworthy one.

  • Show me the journeyWhat steps produced this, and what happened at each one? A result that can trace its own path is one you can stand behind.
  • Where did this come fromEvery number, every claim, back to the input that produced it. If it can't be traced, it wasn't earned.
  • What did it skip or assumeThe honest failures are the ones the system tells you about. The dangerous ones are the gaps it papered over to hand you a clean answer.

How to put this to work

None of this requires new tools or new headcount; it changes two things you already do, how you prompt, and how you hand work off.

  • In your prompts, ask for the journeyInstead of “give me the segments” or “write the analysis,” add the clause that forces the work into the open: “and show me how you got there, what data you used, what you assumed, and what you could not verify.” The answer takes the same few seconds; now it arrives with its receipts.
  • In your handoffs, make the receipt a deliverableBriefing a person, a contractor, or an AI agent, write it into the instructions: deliver the result with every number traced to its source, every assumption flagged, and anything you could not confirm marked unverified rather than smoothed over. A handoff that requires the journey cannot quietly hand you a skipped one.
  • Treat polish as a prompt to checkThe more finished a result looks, the more it is worth asking to see the work, because a clean surface is exactly what hides a missing step. Make “can it trace itself” your condition of done, so the discipline lives in how work ships and not in your own vigilance.

Why this matters more the faster you move

The faster an organization ships with AI, the more this compounds, in both directions. Move fast with the journey shown, and you get a genuine multiplier: real velocity you can trust. Move fast with only the destination, and you get a bill that comes due later, the rebuild, the months-to-make-it-real, the quiet discovery that the impressive thing was standing on a step nobody actually took. Same speed, opposite outcome, and the only difference is whether the journey was shown along the way.

Loops are your friend, with a human in them

Every mature profession already solved this. Auditors don't sign their own work; editors don't proof their own copy; good engineering reviews code before it ships. The discipline is the loop: the thing that makes the work gets checked by something that didn't. AI is no different, and the same tool that skips the journey is the one you point at the check.

  • Have AI check AI's workAfter a result comes back, run a separate pass whose only job is to verify it: trace the numbers to the source, flag the assumptions, find what the first pass skipped. A one-way output becomes a loop that inspects itself.
  • The checker must be independent of the doerDon't ask the same pass “did you do this right?” It will tell you yes the same confident way it gave you the answer. Give the check a fresh start and a sharper question: not “is this good?” but “verify this against the actual inputs and show me where it fails.”
  • A human closes the loopThis is the part you can't automate away. The AI check doesn't replace your judgment; it points it, surfacing the numbers to spot-check, the assumptions to weigh, the gaps worth a second look. Then a person confirms the journey was actually taken. Skip this and the loop becomes just another destination: an AI vouching for an AI, and you trusting it more because it “passed.” The loop earns trust only when a human is standing at the end of it.

AI makes you faster. Showing the work is what makes you sure. The teams that pair the two are the ones this era belongs to.

Part of a series. Start with Where your business keeps its memory; more notes follow.

Download the note as a PDF

Book a call

Thirty minutes. Bring the problem you're trying to solve, and we'll tell you what it would take to get your data working on it.