Prototype Skill: Throwaway Code for Design Questions

Prototype is an agent skill that has your AI coding agent build throwaway code that answers one question — does this state model actually hold up, or what should this screen look like — and then get out of the way. Its opening rule sets the whole tone: the question decides the shape.

What it does

It's a formal take on software prototyping, scoped for AI agents. Most wasted engineering time isn't slow coding — it's building the real thing before anyone checked the idea. This skill makes the agent build the cheapest possible thing that answers the question first.

It starts by working out which of two questions you're asking, because they need completely different artifacts:

"Does this logic or state model feel right?" The agent builds a single shareable HTML file with free-play buttons and tabbed guided walkthroughs that push the state machine through the awkward cases that are hard to reason about on paper. It's deliberately something a non-developer can open and drive.

"What should this look like?" The agent generates several radically different UI variations on one route, switchable through a URL parameter and a floating bar at the bottom of the page — so you compare real options side by side instead of arguing about one.

The skill is explicit that picking the wrong branch wastes the entire prototype. If the question is ambiguous and you're not around to ask, it defaults to whichever branch matches the surrounding code — a backend module means logic, a page or component means UI — and states that assumption at the top of what it builds.

When to reach for it

• You're about to build a feature and aren't sure the state transitions are right
• A stakeholder wants to "see it" before you commit to an approach
• There are three plausible layouts and a meeting is about to be spent debating them
• A tricky edge case is easier to feel in a clickable demo than to describe in a ticket
• You want a decision recorded, not just made

It's the wrong tool for code you intend to keep. Prototype output is designed to be thrown away, and it's marked that way on purpose.

The rules it enforces

Six rules apply to both branches, and they're what make this more useful than simply asking an agent to "mock something up":

1. Throwaway from day one, and labelled as such. It lives next to the code it's prototyping for, named so nobody mistakes it for production.
2. Trivial to run. One command for a UI prototype, or a single HTML file you double-click for a logic demo.
3. No persistence by default. State stays in memory, because persistence is usually what's being tested, not something to depend on.
4. Skip the polish. No tests, no abstractions, no error handling beyond what keeps it runnable.
5. Surface the state. Every action or variant switch shows the full relevant state, so you can see exactly what changed.
6. Capture the answer. The validated decision goes into the real code; the prototype itself is kept on a throwaway branch with a pointer from the relevant issue, and the verdict is written down.

That last rule is the one teams skip and regret. A prototype that settled a question three months ago is only useful if someone can find what it concluded.

What's actually inside

One skill: a main SKILL.md that routes between two branches, plus separate guides for each — LOGIC.md for state-model demos and UI.md for layout variations. No connectors, no agents, no API keys. It relies on your agent's normal ability to read your project and write files.

Setting it up

The GitHub route. The skill lives in skills/engineering/prototype in a public repository. Because it's a folder with more than one file, you need to copy the whole folder — not just SKILL.md — into your agent's skills directory (for Claude Code, .claude/skills/ in your project or your user-level directory), then start a fresh session and confirm it's available. Copying only the main file is the classic mistake: the skill loads, then fails to find its branch guides.

The Taku route. Open it in Taku and the whole skill, including both guides, is mirrored into your workspace in one step.

Worth saying plainly: this is a developer skill. It writes code into a real project, so you still need a project and an AI coding agent. What you skip with Taku is the installation, not the engineering.

Who made it

Written by Matt Pocock as part of the public skills repository, and published to the Taku marketplace by Siyu. The repository groups skills by discipline, so if this one lands well there are neighbouring engineering skills built with the same care.

If you've never installed a skill before

You don't need to understand GitHub, Codex, or Claude Code's skill directories to get this running. Those routes work, but each asks you to learn a folder convention and a scope decision before the skill does anything — and this particular skill has a multi-file structure that's easy to install incompletely.

Taku is a desktop workspace built for that gap: find something someone already built, mirror it into your own workspace, and run it without reproducing their environment. Browse the free app library for more, or see coding agents for where tools like this fit. Once a prototype settles a question, the Git Workflow & Versioning skill keeps the real implementation's history clean.

Download Taku to run this skill without the install step. Taku is in Beta, and the Mac app is available now; there's also an experimental, unsigned Windows build for Windows 10 and 11.

FAQ

What is the Prototype skill?

An agent skill that has an AI coding agent build throwaway code to answer a design question — either a single-file HTML demo for testing logic and state, or several switchable UI variations for comparing layouts.

What's the difference between the logic and UI branches?

Logic produces one shareable HTML file with buttons and guided walkthroughs that exercise a state machine. UI produces multiple radically different layouts on one route, switchable with a URL parameter.

Does the prototype code end up in my main branch?

No. The skill keeps only the validated decision in the real code and preserves the prototype on a throwaway branch, with a pointer from the related issue.

Is it free?

The skill is free and open source. You need your own AI coding agent to run it. For what Taku costs, see pricing.

Can non-developers use the output?

The logic demos are designed so a non-developer can open and drive them. Building them still happens inside a code project.

Key points

• Builds disposable code to answer one design question, then gets out of the way.
• Two branches: an HTML state-model demo, or multiple switchable UI variations.
• Six rules keep prototypes labelled, runnable, unpolished, and recorded.
• The skill is a multi-file folder — install the whole folder, not just SKILL.md.
• Taku removes the install step; you still need a project and a coding agent.