Skip to content
Skills Library
Programming · Building & coding

prototype

/prototype

Build throwaway prototype code that answers a design question: UI variants on a live route, or a terminal UI or single shareable HTML file over a pure logic module. Use when a question is \"how should this look / behave / feel in action\" and discussion or static artifacts cannot settle it.

Repository
skills ↗
Licence
MIT
Last repository change
19.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
1
Deprecation

No signals detected. Repository changed on 19.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 throwaway prototype code that answers a design question: UI variants on a live route, or a terminal UI or single shareable HTML file over a pure logic module. Use when a question is \"how should this look / behave / feel in action\" and discussion or static artifacts cannot settle it.

Triggers from the description

how should this look / behave / feel in action\
Original author description

Build throwaway prototype code that answers a design question: UI variants on a live route, or a terminal UI or single shareable HTML file over a pure logic module. Use when a question is \"how should this look / behave / feel in action\" and discussion or static artifacts cannot settle it.

How it works

  1. Pick the branch
  2. Bindings (both branches)
  3. Done when (checkable)
  4. Attribution
Original SKILL.md headings · 31 lines, 569 words
SKILL.md preview
---
name: prototype
description: "Build throwaway prototype code that answers a design question: UI variants on a live route, or a terminal UI or single shareable HTML file over a pure logic module. Use when a question is \"how should this look / behave / feel in action\" and discussion or static artifacts cannot settle it."
---

# Prototype

A prototype is throwaway code that answers a question. It is the most expensive way to get an answer, so the cheap ways come first: a question with a simple frame resolves in discussion, and a question answerable from existing screenshots or artifacts resolves from those. Reach for a prototype the moment the question is "I need to see/feel this in action." It runs two ways: as the engine of a `prototype` ticket inside a decision map (see the decision-map skill), and standalone for UI-heavy or state-model-heavy work outside any map.

## Pick the branch

- "How should it **look / behave on screen**?" → [references/UI.md](references/UI.md): three structurally different variants mounted on the live route.
- "Does this **logic / state model feel right**?" → [references/LOGIC.md](references/LOGIC.md): a pure candidate module behind a disposable shell: a lightweight terminal UI, or a single shareable HTML file when the demo must travel.

## Bindings (both branches)

- **All prototype code lives on a throwaway `prototype/<name>` branch** cut from the default branch: variants, switcher, terminal or HTML shell, everything. It never merges; the branch is the reference artifact, kept until the winner has shipped.
- **The verdict is the deliverable**: record on the driving ticket which variant won / what the logic answer was, and **why**; that comment is the primary-source pointer the implementing spec links back to, with the branch name for the code.
- **The winner is re-implemented through a normal change** (tests plus whatever verification discipline the repo's binding doc names), using the prototype branch as reference. Promoting prototype code as-is skips the discipline the real change exists for; start fresh and copy judiciously.
- **Prototype branches are exempt from the repo's test-first or coverage rules**: that is the point of a throwaway branch, and the exemption is named in the binding doc's precedence section so agents never deadlock between this skill and a resident test law. The exemption ends the moment re-implementation starts.
- Iterate where the decider is. In-session: react to each variant/run, give concrete feedback, let the next variant encode it. In a lane with no decider in-session, the driving ticket is the iteration channel: post what each round showed and the question it raises, and let the decider's reply drive the next round. Either way, the richness of the recorded design decisions is the point, not the first render.

## Done when (checkable)

- The driving ticket carries the verdict comment (winner + why + `prototype/<name>` branch name).
- The prototype branch holds the final iteration, pushed.
- The working branch you return to is clean of prototype code (`git status` shows none of it outside the prototype branch).
- A follow-on implementation path exists: either the implementing work item is named on the ticket, or the verdict states why none is filed yet.

## Attribution

This skill is adapted from Matt Pocock's [`prototype`](https://github.com/mattpocock/skills/tree/main/skills/engineering/prototype) (MIT), and follows it closely. The core model is his: throwaway code that answers a question, the two branches (UI variants switchable by URL param on a live route, and a pure logic module driven through the paper-hard cases, including the single shareable HTML file), the `prototype/<name>` branch kept out of main as the primary source, and the verdict captured on the driving issue.

What this repo adds: the decision-map coupling, the re-implementation-through-a-normal-change rule, the test-exemption named in the binding doc, the lane-mode iteration channel, and the checkable Done-when list.
Files in this package (4)
  • SKILL.md 4 KB
  • agents/openai.yaml 1 KB
  • references/LOGIC.md 2 KB
  • references/UI.md 2 KB

Versions

RepositoryScoreLicence
This page · timharris707/skills90MIT
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 fe5b522db54f (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

  • 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.
  • 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.
  • 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…
  • 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.
  • 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.
  • 90build-prototype
    Build and exercise the smallest runnable artifact that answers a stated design question. Use for uncertain state, logic or interface behavior; distinguish prototype observations from production claims.

Feedback and reports

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