Can an AI Coding Agent Build a Complete Kanban App From a Single Prompt With Zero-Shot Prompting?

Zero-shot prompting is the most demanding way to test a coding agent: you give it a single prompt, with no examples and no chance to iterate, and ask it to build a complete app in one go. It is the purest measure of raw autonomy, and a Kanban board makes a good target because it is real but well-defined. Can an agent like Codex pull this off zero-shot? The answer is a qualified yes, and both the successes and the failures are instructive.

What zero-shot prompting means

Zero-shot means the agent gets one prompt and no worked examples to learn from, and here it also means no back-and-forth iteration. You describe the whole app once and let the agent build the entire thing from that single instruction, judging only the final result. This is much harder than the usual conversational building, where you refine as you go, and its value is testing how far raw autonomy reaches, which is stressed in guides to building effective agents. One prompt in, a whole app out. It is autonomy with no safety net.

How the agent approaches it

Given a single prompt for a Kanban board, an agent like Codex works through the whole thing autonomously. It plans the structure, creates the files, implements the columns and cards, wires up interactions, and adds any persistence, all from that one instruction. Watching a complete app emerge from a single prompt is striking, and it shows how much an agent can execute without hand-holding. The agent is running a full build loop on one brief. It is autonomy on display.

Where zero-shot succeeds

For the conventional parts of the app, zero-shot works surprisingly well. Standard features like rendering columns, adding cards, and basic interactions are common patterns the agent has seen many times, so it implements them competently from a single prompt. The clearer and more standard the requirement, the more reliably a one-shot build nails it. Most of a typical Kanban board falls into this well-trodden territory. Familiar work is where zero-shot shines.

Where zero-shot falls short

The cracks appear in the details the single prompt could not fully specify. Subtle behavior, edge cases, and anything ambiguous in your one instruction tend to come out wrong or incomplete, because the agent had no chance to ask or to correct. With no iteration, every gap in the prompt becomes a gap in the result. This is the familiar limit that agents stumble on ambiguity, made sharper by the zero-shot constraint. One prompt cannot cover everything, so one build misses things.

Reasoning effort helps

Giving the agent more thinking room improves a zero-shot build. When the agent reasons more carefully before writing, as with a higher reasoning effort, it plans the app better and handles more of the tricky parts, since deeper step-by-step reasoning produces better outcomes on hard tasks. This does not make zero-shot flawless, but it noticeably raises the quality of a one-shot result. More careful thinking up front partly compensates for the lack of iteration. Effort is one lever that makes zero-shot more capable.

A great prompt matters even more

With no iteration to fall back on, the prompt carries all the weight. A vague single prompt produces a confident but flawed app, while a detailed one that names the features, layout, and behavior gives the agent enough to build the whole thing well. Zero-shot success depends almost entirely on how completely you specified the app in that one instruction. The better the prompt, the closer the one-shot result comes to done. When there is only one shot, aim it carefully.

Why iteration usually wins

Impressive as zero-shot is, it is usually not the best way to build. Allowing a round or two of refinement, running the result and fixing what is off, produces a better app with far less effort than perfecting a single prompt. Zero-shot is a demonstration of raw capability, not the most practical workflow. In real work, a short conversation beats a single heroic prompt almost every time. Iteration is normally the smarter path.

What it proves about agents

Succeeding at a zero-shot build shows that agents can execute a clear, moderately complex spec on their own, which is a real capability. It also shows the limits, since the parts that come out wrong are exactly the ambiguous and subtle ones. The exercise teaches as much about the power of clear specification as about the agent itself. Raw autonomy is impressive, and it is not a substitute for iteration or review. Capability and limits show up together.

Verify the zero-shot result

A one-shot app that appears to work still needs checking. Reviewing the code, testing the edge cases, and confirming it matches your intent is essential, because a fluent result can hide subtle bugs, especially the ones a single prompt could not fully specify. This is the same accountability that applies to any output, and it matters more when nobody iterated on the build. A working demo is a starting point, not a guarantee. Verify what the one prompt produced, especially the parts you did not spell out. Zero-shot is a demonstration, and review of the result is not optional.

The takeaway

An AI agent like Codex can build a complete Kanban app from a single zero-shot prompt, succeeding on the conventional features and stumbling on the subtle or underspecified parts. Success depends heavily on a detailed prompt and benefits from higher reasoning effort, but in practice a round or two of iteration produces a better app with less effort. Zero-shot is a striking demonstration of raw autonomy, best treated as a test of capability rather than your everyday way of building, and its output still needs careful verification.

Common questions