Skip to content
Skills Library
Design & UX · Building & coding

prototype

/prototype

Build a throwaway prototype to answer a design question. Use when the user wants to sanity-check whether a state model or logic feels right, or explore what a UI should look like.

Repository
supermatt ↗
Licence
MIT
Last repository change
23.10.2026

Assessment and security

90/ 100Class: good
Format25 / 25
Frontmatter with name and description, valid name, description up to 1,024 characters, name matching the folder.
Discoverability25 / 25
Description explains when to use the skill, has a reasonable length and uses third person.
Content25 / 35
At least 150 words and at most 500 lines, headings, step lists, examples or code.
Hygiene15 / 15
No placeholders such as TODO, no Windows paths, with a licence.
Riskno signals detected in the scan
Files in this package
4
Scripts
0
HTML comments
0
URLs in SKILL.md
0
Deprecation

No signals detected. Repository changed on 23.10.2026, without references to retired models or APIs.

Licence

MIT, open: use and modify while retaining author attribution.

What it does and when to use it

Build a throwaway prototype to answer a design question. Use when the user wants to sanity-check whether a state model or logic feels right, or explore what a UI should look like.

Original author description

Build a throwaway prototype to answer a design question. Use when the user wants to sanity-check whether a state model or logic feels right, or explore what a UI should look like.

How it works

  1. Pick a branch
  2. Rules that apply to both
Original SKILL.md headings · 23 lines, 558 words
SKILL.md preview
---
name: prototype
description: Build a throwaway prototype to answer a design question. Use when the user wants to sanity-check whether a state model or logic feels right, or explore what a UI should look like.
license: MIT
---

# Prototype

A prototype is **throwaway code that answers a question**. The question decides the shape.

## Pick a branch

Identify which question is being answered from the user's prompt or surrounding code. If it remains ambiguous and the user is available, ask through the host's live multiple-choice capability, following its schema, or use chat when no such capability is usable:

- **"Does this logic / state model feel right?"** → [LOGIC.md](LOGIC.md). Build a single shareable HTML file (free-play buttons plus tabbed guided walkthroughs) that pushes the state machine through cases that are hard to reason about on paper, and that a non-developer can drive.
- **"What should this look like?"** → [UI.md](UI.md). Generate several radically different UI variations on a single route, switchable via a URL search param and a floating bottom bar.

The two branches produce very different artifacts, so getting this wrong wastes the whole prototype. If the question is genuinely ambiguous and the user isn't reachable, default to whichever branch better matches the surrounding code (a backend module → logic; a page or component → UI) and state the assumption at the top of the prototype.

## Rules that apply to both

1. **Throwaway from day one, and clearly marked as such.** Locate the prototype code close to where it will actually be used (next to the module or page it's prototyping for) so context is obvious, but name it so a casual reader can see it's a prototype, not production. For throwaway UI routes, obey whatever routing convention the project already uses; don't invent a new top-level structure.
2. **Trivial to run.** A UI prototype starts from one command in the project's task runner: `pnpm <name>`, `python <path>`, `bun <path>`, etc. A logic demo is a single HTML file the user double-clicks. Either way, no thinking required to start it.
3. **No persistence by default.** State lives in memory. Persistence is the thing the prototype is _checking_, not something it should depend on. If the question explicitly involves a database, hit a scratch DB or a local file with a clear "PROTOTYPE, wipe me" name. For a logic demo opened directly from disk, first probe `localStorage` with a guarded write/remove under that name: file-URL support varies by browser and can throw. When unavailable, show the limitation and provide explicit JSON export/import to preserve state. An in-memory fallback cannot establish persistence.
4. **Skip the polish.** No tests, no error handling beyond what makes the prototype _runnable_, no abstractions. The point is to learn something fast.
5. **Surface the state.** After every action (logic) or on every variant switch (UI), print or render the full relevant state so the user can see what changed.
6. **Capture it when done.** Fold any validated decision into the real code, then capture the prototype itself as a **primary source**: commit it to a throwaway `prototype/<name>` branch, out of main, push it when the repository has a remote so the pointer resolves, and leave a context pointer to that branch on the issue that asked the question (an implementation issue or a decision ticket). With no issue yet, put the pointer in the handoff or the conversation, so `to-spec` carries it into the spec. Capture the answer too (the verdict and the question it settled) in the issue or a commit. The main branch keeps only the validated decision.
Files in this package (4)
  • LOGIC.md 6 KB
  • SKILL.md 4 KB
  • UI.md 8 KB
  • agents/openai.yaml 1 KB

Versions

RepositoryScoreLicence
This page · svyatov/supermatt90MIT
leanstacks/lstk100MIT
A7-studio/jobmigo100MIT
akillness/jeo-skills100MIT
runwield/runwield100MIT
yuan88964/RelayStudio100MIT
mathews-tom/armory100MIT
deaconb28-lang/prototype100MIT
drvoss/everything-copilot-cli100MIT

Database snapshot: 13.11.2026 · package version 325cfa9b665a (SHA-256 digest of the entire package)

Downloads in the last 30 days: 0 · ranking

Report a problem with this skill: harmful content, incorrect descriptions or an author’s removal request.

Similar skills

  • 85workflow-prototype
    Build a throwaway prototype to answer a design question. Use when the user wants to sanity-check whether a state model or logic feels right, or explore what a UI should look like.
  • 90jor-prototype
    Build a throwaway prototype to answer a design question. Use to sanity-check whether a state model or logic feels right, or to explore what a UI should look like with variants screenshotted at the project's breakpoints.
  • 90throwaway-prototype
    Use when a design question needs a throwaway runnable answer: a terminal app that exercises a state model, or switchable UI variants on one route. Not for production code.
  • 100plan-prototype
    Build throwaway code that a person runs to answer one design question before anything is committed. A clickable HTML file for a state model or logic, or variants a person switches by hand on a real page for a UI. Builds two or three competing variants when the repo has no…
  • 95ce-prototype
    Build a throwaway prototype to answer how something should work, feel, or read. Use when committing the wrong answer would be expensive to unravel and a cheap sketch cannot settle it. Not a rough visual probe during brainstorming, not for deciding what to build, not polishing a…
  • 90prototype-spike
    Build or plan an explicitly throwaway prototype to answer a design, API, UX, performance, or integration question, then capture findings and cleanup. Use when the user asks for a spike, prototype, proof of concept, or experiment before committing to production design.

Feedback and reports

Your message goes to Bartosz Sokoliński. An email address is needed only for a reply. See the privacy policy.