Idea Latency: The Cost of the Gap Between Thinking and Doing

Nobody knows how many good ideas die of old age. There is no registry of things people meant to build, no counter for the customer email that would have landed if it went out on Tuesday instead of three weeks later. The cost of waiting is invisible, so it gets booked as zero.

We don’t know the size of that cost. What we can do is measure the delay itself, the way an engineer measures a slow request. Call it idea latency: the elapsed time between having an idea and putting it in front of its first real test. Once you time it, two things show up quickly. Almost none of it is work. And the one part that used to be work, the building, is the part AI tools have just shrunk to an afternoon.

One idea, fifty days, seven hours

Lena is a backend engineer at a mid-size software company. One Monday she has a small, specific idea: a tool that turns a team’s merged pull requests into a plain-language weekly changelog for customers. (Lena is an illustrative composite built from a common pattern, not a real person, and the dates are invented to show the shape.)

Nothing in Lena’s story looks like procrastination. She was busy with her real job. She told a colleague, which felt like progress. She picked a date. Every individual delay was reasonable.

And the build, the part that used to take weekends, took one afternoon with a coding agent. The prototype was never the slow part. The calendar was.

The model: idea latency is a request with a queue

Here is the model the rest of this piece uses, in one sentence: idea latency is the elapsed time from an idea to its first real test, and like any request it splits into service time, when someone is working on it, and queue time, when it is waiting for someone to start.

The end condition of each stage is the useful part. “Decide” does not end when the idea feels good. It ends when you have committed to a test. “Test” does not end when the thing is built. It ends when someone who is not you has touched it. Fuzzy stages hide queue time, because a stage with no finish line can stay “in progress” forever.

Finding 1: most idea latency is queue time

Engineers know this shape from distributed traces. A request takes two seconds, the handler ran for forty milliseconds, and the rest was the request sitting in queues behind other requests. Making the handler faster does almost nothing for the total. You have to find the queue.

Ideas behave the same way. Lena’s build stage was the only one with a real chunk of work in it, and even there most of the eight days were waiting for a free Saturday. Ask anyone how long their side project “took” and they will quote service time. The latency is everything else.

Finding 2: an intention loses force while it waits

If waiting were free, an idea parked for three weeks would come back exactly as strong. The research on intentions says it does not come back at all, often.

Paschal Sheeran’s 2002 review in the European Review of Social Psychology pooled earlier meta-analyses of how well intentions predict behavior, then split people into four groups. The gap between intending and doing came mainly from one cell: people who formed the intention and never acted on it. Thomas Webb and Sheeran then looked only at experiments, where researchers deliberately raised people’s intentions, in a 2006 meta-analysis in Psychological Bulletin. Across 47 tests, a medium-to-large change in intention (d = 0.66) produced a small-to-medium change in behavior (d = 0.36).

None of these studies timed side projects. They measured health habits and everyday goals. But the mechanism carries over: an intention is a fragile state, and the longer an idea sits as intention, the more chances life has to crowd it out. The market moves too. A customer who asked for a feature in March has found a workaround by May.

Finding 3: AI tools collapsed the build stage, and only the build stage

The build stage is the one place where the tools have changed everything. Prompt-to-app builders now produce a working, clickable web app from a description. Vercel’s v0 generates React and Next.js interfaces and deploys them to Vercel. StackBlitz’s Bolt.new builds and runs full-stack apps inside the browser with nothing to install. Lovable builds full-stack apps from a chat and connects to Supabase for the database and sign-in. Replit Agent builds an app and hosts it in the same place.

When the idea has to touch real code, coding agents do the same job one level down. Claude Code works in the terminal, reads a repository, edits files and runs the tests. Cursor is an editor with an agent mode that makes changes across many files at once.

That is real, and it is also the trap. A team can adopt every one of these tools and find its idea backlog exactly as long a quarter later, because the build stage was rarely the bottleneck. Shrinking it reveals what was underneath: an idea that waits three weeks to be decided on, four days to be started, and two weeks to be shown to anyone.

Finding 4: start friction yields to a plan made in advance

If Finding 2 says intentions leak, the next question is what plugs the leak. Peter Gollwitzer and Paschal Sheeran’s 2006 meta-analysis in Advances in Experimental Social Psychology gives the best-studied answer. Across 94 independent tests, people who formed implementation intentions, plans of the form “if situation X arises, then I will do Y,” reached their goals more often, with a medium-to-large effect (d = 0.65).

The mechanism suits idea latency well. The start stage is mostly the cost of deciding, again, each time a free moment appears, whether this is the moment. An if-then plan makes that decision once, in advance, and hands it to a cue. The same trick works on the other stages. “If the prototype loads, then send it to five people before closing the laptop” turns the test stage from a wait into a reflex.

From idea to first test in one afternoon

The order matters more than the tools. The test sentence comes first, because a prototype built before you know what would count as a yes is a prototype you can admire indefinitely. For Lena it would be: “At least three of five changelog writers say they would paste this into a real release note.”

The market check is twenty to forty minutes, not a week. ChatGPT, Gemini and Perplexity all offer deep research modes that browse many pages and return a cited report, usually in well under an hour. Their citations are sometimes wrong, so open the three that matter. You are looking for one answer: has someone already built this well enough that you should use theirs?

The prototype step is where the AI builders earn their place. Use a prompt-to-app tool when the question is “does anyone want this,” and a coding agent when the question is “does this work on our real data.” The demand page is optional for an internal idea and essential for anything you might charge for. A one-page site and a three-question form are enough. Then send it to five people by name, today. A launch post invites silence. A direct ask for ten minutes usually gets an answer.

What this gets wrong

The model treats every wait as a cost, and some waits are a filter. Plenty of ideas look brilliant at 11pm and ordinary the next morning, and a short queue in the decide stage is how those get dropped cheaply. The fix is to put a limit on the queue, a date by which the idea gets tested or deleted, rather than to remove it.

Speed also tempts you to run the test that is quickest instead of the test that answers the question. Five colleagues saying “nice” in a chat thread is a fast signal and close to a useless one. If the honest test for an idea takes six weeks, a pricing experiment or a pilot with a real team, then six weeks is its floor, and shaving the build stage only matters if it brings that test closer.

And the evidence is borrowed. The intention research is solid on its own terms, but none of it followed people’s product ideas from notebook to launch. The claim that ideas decay the way intentions do is reasoning from mechanism, and it should be held more loosely than the effect sizes it rests on.

Your next idea’s latency

The build stage used to be the honest excuse. Building took weeks, so waiting for the right weekend made sense. That excuse expired with the current generation of app builders and coding agents. What is left is the queue in front of each stage, and queues respond to scheduling, not to effort.

So take the next idea that matters and give it a deadline for its first test, measured in days. Write the test sentence before anything else. Make one if-then plan for the start. Build with whatever gets you to a clickable version fastest, send it to five named people, and time the whole thing. The number you get is your idea latency. Next time, try to make it smaller.