Can GitHub Copilot’s Coding Agent Build a Full Kanban Board App From a Single Instructions File?

A compelling way to test any coding agent is to hand it one clear instructions file and ask it to build a complete app, then see how far it gets on its own. A Kanban board, with its columns, draggable cards, and saved state, is a great benchmark because it is real but well-defined. Can GitHub Copilot’s agent build one from a single file? The short answer is largely yes, with important caveats, and the experience reveals a lot about how these agents work.

Why a Kanban board is a good test

A Kanban board hits a useful sweet spot for testing an agent. It has clear, familiar requirements, several interacting features, and a visible result you can judge immediately, which makes it demanding without being ambiguous. This is exactly the kind of clear, verifiable task where agents tend to do well. It is complex enough to be a real test and defined enough to be a fair one. A todo app would be too trivial, and a novel system too fuzzy.

The single-file approach

The idea is to put all your requirements into one instructions file and let the agent work from it. This file describes what the app should do, the features it needs, the conventions to follow, and how to run it, serving as the complete brief. It is essentially a detailed agents.md style file scoped to this one project. Concentrating everything in one place tests whether the agent can execute a full spec without hand-holding. The file is the whole input, and the app is the whole output.

Writing the instructions well

The quality of the file largely determines the result. A vague brief produces a confident but wrong app, while a clear one that names the exact features, the layout, the behavior of cards and columns, and the persistence requirement gives the agent a real target. Specificity is what turns a single-file build from a gamble into a reliable process. The better the instructions, the less correction you need afterward. Time spent sharpening the file is repaid in the output.

What the agent does

Given a good file, Copilot’s agent works through it methodically. It scaffolds the project, creates the files, implements the columns and cards, wires up the interactions, and adds the saving behavior, all while you can watch. Seeing a working board emerge from a single brief is genuinely impressive and a little surreal. The agent is executing your spec step by step, turning description into a running app. This is autonomy doing real, visible work.

Where it succeeds

For the well-defined parts, the agent tends to do well. Standard features like rendering columns, creating cards, and basic interactions are common patterns it has seen many times, so it implements them competently. The clearer and more conventional the requirement, the more reliably the agent nails it. This is the heart of why agents excel at familiar, verifiable work. Most of a standard Kanban board falls squarely in this zone.

Where it struggles

The rough edges appear at the tricky or underspecified parts. Subtle drag-and-drop behavior, edge cases in the saving logic, or anything your file left ambiguous can come out wrong or incomplete. The agent fills gaps with plausible guesses, and those guesses are sometimes off. This is the familiar limit that agents stumble on ambiguity and hard-to-verify details. The parts you specified loosely are the parts most likely to disappoint.

The role of iteration

A single-file build rarely ends with the very first output, and that is normal. You run the result, find what is off, and either refine the instructions file or ask the agent to fix specific issues, iterating toward a finished app. Even an autonomous build is a conversation that includes a review pass. Expecting one or two rounds of refinement is realistic, not a sign of failure. The first build gets you most of the way, and iteration closes the gap.

What it proves and does not prove

Succeeding at this shows that agents can execute a clear, moderately complex spec largely on their own, which is a real and useful capability. It does not prove they can build anything from a vague idea, since the whole thing depends on a good instructions file. The lesson is about the power of clear specification as much as the agent, echoing why measured evaluation beats hype when judging tools. The agent is impressive, and the specification is what unlocks it. Clarity in, capability out.

Trust but verify the result

An app that appears to work still needs checking before you rely on it. Reviewing the code, testing the edge cases, and confirming the behavior matches your intent is essential, because a fluent result can hide subtle bugs. This is the same accountability that applies to any agent output, no matter how autonomous the build. A working demo is a starting point, not a guarantee of correctness. Verify what the agent built, especially the parts you did not watch closely.

Setting Copilot up for the build

To give the agent the best shot, configure Copilot for autonomous work before you start. Using its agent mode, documented on the Copilot documentation, lets it plan and edit across files rather than suggesting one line at a time. Providing a clear instructions file and letting the agent run its own build-and-check loop follows the same effective-agent practices that make any autonomous task succeed. A little setup, the right mode and a good brief, is what turns a single-file build from a gamble into a repeatable process. Prepare the agent well, and most of the Kanban board effectively builds itself.

The takeaway

GitHub Copilot’s agent can build a full Kanban board app from a single instructions file, succeeding on the clear, conventional parts and struggling where the file was vague or the behavior subtle. The key is a specific, well-written brief, since the quality of the file largely determines the quality of the app. Expect a round or two of iteration, verify the result carefully, and you get a striking demonstration of what a clear spec plus an autonomous agent can build.

Common questions