I really like what my custom Claude plugin produces. Give it a brief and it returns the kind of deck I would put in front of a chief executive or a board: a clear storyline, action titles, every figure sourced, the pages clean. The downside is the clock. A run takes hours, and I kept finding that I needed something less polished and much quicker, for a weekly status update, say. So I measured where the time goes, using the plugin's own run records. This is Part 1 of 2.
Eleven seconds to check a deck, nearly two hours to build one
One number stopped me. Once a deck is finished, a single pass to render it, run every automated check on it and image the pages takes about 11 seconds. Yet the fastest version of the plugin needs roughly 107 minutes of run time from a cold start, and the client-ready version about 204 minutes, not counting research. The software is fast. Something else is using up nearly two hours.
The question I set myself was simple. Could a version finish in thirty minutes?
The plugin is polished, accurate and slow for the same reason: I designed it for perfection, and perfection is paid in turns and tokens. Turns are the round trips between the AI and its files; tokens are the words it writes, its own thinking included. A thirty-minute version would be doing a different job from the full run.
Every review in the plugin found something on its first pass
First, what the hours buy. The plugin works the way a good consulting team does, in stages. It researches the question and writes a storyline. A fresh-eyes "partner", a reviewer that never saw the drafting, critiques that storyline before a single slide exists. Then the plugin builds the deck and runs quality assurance, with a devil's advocate on the research and a stress test on the finished claims. Every figure carries its source and a confidence rating. Where a number is missing, the plugin leaves a visible bracket instead of guessing.
Much of that rigor comes from cycles: a reviewer sends the work back, the stage that wrote it revises it, and the reviewer reads it again. The loops find real problems. On each of the last four quality runs, the first partner review sent the storyline back for revision, and the first full QA found between two and seven major issues. The research devil's advocate weakened three of the five claims it tested.
Every loop adds work. The client-ready run on the current version took 19 agent launches. The storyline was written three times and reviewed three times, and the build and QA each ran twice. It graded 96 on the plugin's own 100-point rubric, which measures how rigorous the process is rather than a market-tested accuracy rate.
I built for "right" before "fast" because that is what my readers worry about. In a McKinsey survey published in March 2026, 74% of about 500 organizations called inaccuracy a highly relevant AI risk. In a University of Melbourne study of more than 48,000 people in 47 countries, about two-thirds of employees who answered its questions on AI at work said they rely on AI output without checking its accuracy. And in 2025 a 237-page report written for an Australian government department was found to cite research that does not exist; the consulting firm that wrote it agreed to refund part of its fee.
Each step is quick, and there are more than a thousand of them.
Even the fastest version takes roughly 107 minutes
A weekly status update needs a quick turnaround, so the fastest version is the one to time. The quick first draft already skips the partner review, the de-AI pass, the stress test and the fix cycles. From a cold start it still comes to roughly 107 minutes of run time. About 30 of those go to research. The rest is four stages: the storyline (about 20 minutes), the build (about 30), visual polish (about 14) and QA (about 13). The time is spread across all four, so there is no obvious one to cut.
That figure also leaves out the intake and the hand-offs between stages, so the clock you actually feel, from sending the request to receiving the file, runs longer. For a weekly status update, that felt clock is the one that decides whether the deck is ready in time. Getting to thirty minutes means cutting more than two-thirds of the time.
The obvious fix is to drop another stage. Take out visual polish as well and the cold run comes to about 93 minutes, and the deck loses the only pass that looks at the rendered pages. Research on its own takes about as long as the whole goal. The time is inside the stages.
A minute is made of tokens and turns
I took 65 measured agent runs from the plugin's own telemetry: 839 agent-minutes, about 4,000 turns and 4.4 million output tokens in all. Then I looked for what predicted each run's length. Two things were enough. By the fit, each turn costs about 3.6 seconds and each 1,000 output tokens about 8 seconds. Those two rates explain 95% of the variation in run time across the 65 runs. Fitted only on runs of an earlier version, the same law put today's four draft stages at 77.5 minutes; they took 77.1.
If you assume AI is slow because the software is slow, this is where the data disagrees. Across a writing stage, running tools takes 1–7% of the time. Thinking is 39% of the storyline stage and 43% of the build, and it sits inside the token count, because thinking is one of the things the AI writes. Nearly everything else is round trips and words.
Much of the spend buys accuracy, and most of that is reading. In the storyline stage, 66 of its 99 tool calls were reads or searches, and 51 of those went into the plugin's own reference files on structure, evidence and style. Every fresh reviewer starts by re-reading what it is about to judge, and every send-back makes the writer re-read and rewrite.
The rest buys polish, as the plugin makes it today. The build effectively writes every slide twice: a 74-kilobyte outline re-expressed as a 206-kilobyte deck specification. On one complex slide, 34 of its 37 elements are placed by hand, coordinate by coordinate. Add up a single client-ready deck and the scale is plain: 1,072 turns, 1,184 tool calls and about 1.19 million output tokens across 19 launches.
I made it inefficient on purpose
A lot of those turns are there because I put them there. I designed the plugin to read its reference files a section at a time rather than whole, to reduce hallucination, and I knew it would take many more turns. Before writing a word, the storyline and build stages each read about half a megabyte, one section at a time.
Picture a very fast librarian who walks into the stacks, reads one paragraph, walks back to the desk, writes one sentence, then walks back for the next paragraph. It looks inefficient. I would call it cautious. It will not carry ten books back to the desk and trust its memory of them. Each walk is quick. A thousand walks take an hour, which is roughly what the 1,072 turns of one client-ready deck come to.
The caution has a reason behind it. A peer-reviewed 2024 study found that the models it tested used information in the middle of a long input markedly worse than information at the start or the end, and a 2025 vendor study of 18 models found reliability fell as inputs grew longer. The bet has a serious counterweight: a 2024 study found that, given enough resources, letting a model read everything beat feeding it selected passages, on average. I have not run the same brief both ways, so this is a reasoned bet whose price shows up in the turn count.
Grounding a model in sources also reduces hallucination without ending it. Commercial legal research tools, as tested in 2024, still gave incorrect or misgrounded answers 17–33% of the time. That is why the plugin checks so much and leaves a bracket rather than a guess.
Thirty minutes means changing the shape of the work
If the minutes are the price of polish and accuracy, a faster version has to choose what it stops buying. None of the easy answers gets there on its own. Fewer stages gets to about 93 minutes from a cold start. Faster software has little to give, since the software's own work takes seconds a pass. A faster model is less of an answer than it sounds: in the one clean test I have, the quickest run came from the bigger model thinking less. More agents help where the work divides, and much of building a storyline is tightly sequential.
In the units that cost time, thirty minutes of stages has room for roughly 150 turns and 155,000 output tokens. Today's draft stages use 363 turns and 413,000 tokens, and a cold run has to fit research in as well. By the law, today's tokens alone would take about 56 minutes. So the stages have to read and write less than half of what they do now, or run side by side. In practice it will take both.
Part 2 will test four levers: reading from a prepared pack instead of walking to the stacks, writing each slide once, working side by side only where the work divides, and thinking hard only where judgment is needed.
Four questions to ask of any AI workflow
The same questions apply to any AI workflow you are building or buying. In Gartner's 2025 survey of 183 finance leaders, 59% said they use AI in their finance function, about where it stood a year earlier. With adoption levelling off, the live question for many is how these workflows are designed.
Which clock are you measuring? Ask for the time from your request to a usable file, the one you feel, rather than a vendor's run time. My own 107 minutes leaves out the intake and the hand-offs, and I built the thing.
Where do the minutes go? Count round trips and words written before you blame the software, or pay to upgrade it. In my plugin, the software's pass took seconds and the words took hours.
Which of your accuracy controls carry the weight, and what does each one cost in time? Every review loop in my plugin found something, and every one is paid for in re-reading. A review step you cannot price, you cannot trade.
Before you ask for faster, which confidence are you willing to give up, and who checks the output if the workflow no longer does? My answer for a weekly status update is not my answer for a board deck.
The hours are a price I chose
Back to where I started: about 11 seconds to render and check a finished deck, nearly two hours of run time to build the fastest version from a cold start, and more than a thousand round trips for a client-ready one. I did not stumble into that gap. I chose it, in pursuit of perfect polish and no hallucinations, and I paid for it in turns and tokens. For a C-level-ready deck, that perfection is what I want.
The measurements turned a vague complaint, that a run takes hours, into a bill I can read: so many round trips, so many words, and what each one buys. A weekly status update is a different job. In Part 2 I will look at what has to change inside the stages to get a version to thirty minutes, and which confidence it gives up to get there. Any AI workflow spends the same currency, and it is worth knowing what yours is buying.
Download the full insight for the three exhibits (the cold-start draft run stage by stage, where a run's minutes go and what each part buys, and the turn and token budget for a thirty-minute version) and the supporting research from McKinsey, the University of Melbourne, Gartner, and published studies on hallucination, long inputs and multi-agent systems.