prototype

Build throwaway code prototypes that answer design questions through human reaction.

2|Updated Jul 24, 2026
One-click install
npx skills add https://github.com/konstantinos-malavazos/claude-code-playbook --skill prototype-konstantinos-malavazos
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: prototype
Source: https://github.com/konstantinos-malavazos/claude-code-playbook/tree/main/templates/skills/prototype
Command: npx skills add https://github.com/konstantinos-malavazos/claude-code-playbook --skill prototype-konstantinos-malavazos

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve? Some design decisions cannot be settled by reading code or docs — they need to be seen running. This Skill builds disposable prototypes (an interactive state harness or several UI variants) so a human can react and the decision gets resolved, without polluting the main codebase. ## Core Features & Use Cases - Two prototype shapes: an interactive harness that drives a state machine by hand for logic questions, or three to four radically different UI variants switchable on one screen for look-and-feel questions. - Throwaway discipline: prototypes live on a named throwaway branch beside what they prototype, run with one command, keep state in memory, and skip tests and polish. - Verdict landing: folds the validated decision into the real code or ticket, posts the verdict on the ticket via the tracker adapter, and points at the branch instead of pasting code. - Use Case: A team cannot agree whether a wizard's state model handles back-navigation correctly. Build a small harness that steps through the tricky transitions, show it to the team, and record the settled decision on the ticket. ## Quick Start Ask the agent to prototype the stuck design question as throwaway code on a scratch branch so you can react to it and settle the decision.

Frequently Asked Questions about prototype

High-intent search queries and answers about installing and using this skill.

FAQPage Schema
How do I prototype a design question with throwaway code?

Identify whether the question is about logic or appearance, then build the matching artifact: an interactive harness that drives the state machine by hand, or several radically different UI variants on one screen. Keep it on a throwaway branch, runnable with one command, and delete it after the human reacts.

When should I use a prototype instead of writing the real implementation?

Use a prototype only when a decision is stuck on something nobody can judge on paper and must be seen running. If the code or docs can already settle the question, skip the prototype. The test is whether you would be sad to delete it — if so, you built the wrong thing.

Should prototype code include tests, persistence, or error handling?

No. Prototypes skip tests, abstractions, and error handling beyond what makes them run, and keep all state in memory. Persistence is usually the thing being checked, not something the prototype may depend on, unless a clearly labeled scratch store is required.

Can an AI agent evaluate the prototype variants by itself?

No. The human reaction is the output of the prototype, and an agent that builds variants and picks one itself has left the question open. If the human is unavailable, the agent shows the running prototype, names what to look at, and leaves a progress note on the ticket.

Where does prototype code live when there is no repository yet?

It runs wherever it can, with no branch and nothing to sit beside. Do not create a repo just to hold a prototype, since scaffolding is a separate stage and only the answer, recorded on the ticket, needs to survive.