Getting your AI tools to actually pass data

I lost most of an afternoon once to a vibe-coded workflow that looked like it was working. Five AI tools chained into a pipeline, each one good at its job, and data quietly landing in the wrong places between them. No crash, no error, just a final output that was confidently, specifically wrong, built on top of inputs that had drifted one slot to the left three steps back.

The reflex when your AI tools stop passing data cleanly is to reach for a bigger prompt. Put one capable agent in charge, hand it all five inputs and all five steps, and let it thread the whole thing in its head. That works in a demo. It's also the exact move that got me the wrong answer, because a single prompt holding all the state is guessing at what goes where, and it will guess wrong the moment the flow gets longer than the demo.

This is the wall almost every vibe coder hits once they go past a single tool. Vibe coding is very good at generating each piece. Getting the pieces to hand off to each other is a different skill, and it's the one nobody shows you.

the same inputs, two architectures

Here's the moment it clicked for me. I had the same set of inputs run through two different architectures on the same job, and they produced completely different output. Same data in, two builds, one right and one quietly wrong.

The first build was the mega-prompt: one agent, all the inputs pasted into its context, told to run the whole sequence. It parsed. It read the blob of inputs and inferred which value belonged to which step, and it mis-slotted them, because inference is a guess and nothing forced the guess to be correct.

The second build was dispatch. Each input moved between steps through an explicit contract: this step takes these named fields, returns these named fields, and the next step reads exactly those. Nothing was inferred. Every handoff was declared. Same inputs, and this time they landed where they belonged, because the routing was a structure instead of a hope.

That's the whole lesson, and it has a name I keep coming back to: the handoff has to be explicit. Context that moves between steps by being declared and passed survives the trip. Context that lives in one agent's head, threaded implicitly, gets dropped the moment the sequence is long enough to strain it. Durable handoffs beat held state. It's the same reason I keep a written memory between build sessions instead of trusting one long conversation to remember everything. The explicit handoff is what survives the boundary.

dispatch, not parse

So the way I vibe code a multi-tool workflow now is dispatch first. A few moves make the difference.

Route by contract, not by prompt. Every step declares what it takes and what it returns, and the orchestration layer moves named fields between steps. No step gets a blob and guesses; each gets exactly the fields it needs. This is what AI orchestration actually is underneath the buzzword: dispatch, not one clever prompt holding everything.

Separate the roles. One agent builds, another reviews, another checks the work against the spec. A builder, a researcher, an adversarial reviewer. Each role is a step with its own contract, not one mega-agent wearing every hat and losing track of which one it has on. Role separation beats a single model trying to hold every job and all the state at once.

Pass state you can see. The data between steps should be inspectable: named, structured, loggable. When a handoff goes wrong you want to point at the exact field that drifted, not re-read a paragraph of prose trying to reconstruct what the agent thought it had.

the way this breaks

The dangerous part is that the mega-prompt architecture doesn't fail loudly. It works on three steps. It works in the demo. It degrades quietly as you add steps, and the degradation looks like the model getting dumber. Really it's the architecture running out of room to hold state it was never given a structure for. If your AI tools are silently dropping data between steps, adding more instructions to the prompt is treating the symptom. The fix is upstream, in how the steps hand off at all.

I wrote about the pain side of this in when AI tools don't talk to each other; this is the build side of the same problem. If you want the broader frame for designing the whole flow, how to design reliable AI workflows is the companion piece.

If you're chaining vibe-coded tools into something that has to hold in production and you want a second set of eyes on the handoffs before the data starts drifting, /work-with-us. Most of what an automation build actually is comes down to this: turning implicit prompts into explicit contracts so the workflow stops guessing.

None of this is complicated. It's just the unglamorous part. The prompt is the easy half. The contract between the steps is where the workflow actually lives, and it's the half worth building on purpose.