Using AI /
You need to move away from the idea that you should one-shot these things
One prompt. One attempt. A complete working result.
That is a good demo. It is a terrible standard for real work.
The whole idea of one-shotting a piece of software, a strategy or an operating system is nonsense.
If you are trying to one-shot serious work, it will fail. The first output will contain assumptions nobody checked, edge cases nobody saw and decisions the model had no authority to make.
A second pass is not the failure. Shipping the first without checking is.
The first pass is a hypothesis
A capable model can produce an impressive amount in one pass. It can read a brief, write the code, draft the copy and assemble something that looks finished.
Looks finished is doing a lot of work there.
The code still has to run inside the actual repository. The interface still has to be used. The copy still has to say something true. The system still has to survive the odd inputs, missing data and conflicting rules that were absent from the prompt.
You only learn those things by putting the output back into contact with reality.
Run it. Read it. Click it. Break it. Check the source. Look at the logs. Compare the result with the job you meant to solve.
The first pass gives you something to inspect. It does not remove the inspection.
Better models make the loop faster
This is the part the one-shot story gets backwards.
The advantage of a strong model is not that you can fire one instruction into the void and walk away. It is that the distance between an idea, a working version and the next correction has collapsed.
A coding agent can inspect the repository, make a change, run the tests, see the failure and repair it. A research agent can gather sources, draft an argument, expose a weak claim and replace it. An image model can produce a composition, show you where the product geometry drifted and take another pass.
That loop used to be slow and expensive. Models compress it.
Skipping it throws away the advantage.
One-shot success usually hides the work
Sometimes the first result is good.
Usually one of three things happened:
- the job was small
- the standard was low
- a lot of work had already gone into the context, tools, examples and constraints
That third case matters. A mature system can make an agent look like it solved the task in one shot because the repository is legible, the tests are useful and the definition of done is clear.
The visible prompt was short. The system behind it was not.
That is not one-shot magic. It is the result of preparation.
Do the work
Do not measure success by how few times you had to interact with the model.
Measure whether the result works.
Give the agent the real sources. Let it inspect the existing system. Define what done means. Run the checks. Review the decisions that carry risk. Put the result in front of reality and keep going until the important failures are gone.
This does not mean hovering over every token or endlessly polishing work that is already good enough. It means closing the loop.
If a task is cheap and disposable, one pass may be enough.
If you are building something people will use, rely on or pay for, the first pass is not the finish line.
The rule
Stop trying to one-shot the work.
Use the model to make the loop faster. Then do the loop.