prototype
/prototype
Buduje jednorazowy kod prototypu odpowiadający na pytanie projektowe: warianty UI na żywej trasie albo interfejs terminalowy lub pojedynczy plik HTML nad czystym modułem logiki.
- Autor
- timharris707 ↗
- Repozytorium
- skills ↗
- Licencja
- MIT
- Ostatnia zmiana repozytorium
- 19.10.2026
Ocena i bezpieczeństwo
- Pliki w paczce
- 4
- Skrypty
- 0
- Komentarze HTML
- 0
- Adresy URL w SKILL.md
- 1
Brak sygnałów. Repozytorium zmienione 19.10.2026, bez odwołań do wycofanych modeli i API.
MIT, otwarta: można używać i zmieniać, z zachowaniem informacji o autorze.
Co robi i kiedy
Buduje jednorazowy kod prototypu odpowiadający na pytanie projektowe: warianty UI na żywej trasie albo interfejs terminalowy lub pojedynczy plik HTML nad czystym modułem logiki.
Wyzwalacze z opisu
Oryginalny opis (EN)
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.
Jak działa
- Pick the branch
- Bindings (both branches)
- Done when (checkable)
- Attribution
Podgląd SKILL.md
--- 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.
Pliki w paczce (4)
- SKILL.md 4 KB
- agents/openai.yaml 1 KB
- references/LOGIC.md 2 KB
- references/UI.md 2 KB
Wersje
| Repozytorium | Wynik | Licencja |
|---|---|---|
| Ta strona · timharris707/skills | 90 | MIT |
| leanstacks/lstk | 100 | MIT |
| A7-studio/jobmigo | 100 | MIT |
| akillness/jeo-skills | 100 | MIT |
| runwield/runwield | 100 | MIT |
| yuan88964/RelayStudio | 100 | MIT |
| mathews-tom/armory | 100 | MIT |
| deaconb28-lang/prototype | 100 | MIT |
| drvoss/everything-copilot-cli | 100 | MIT |
Migawka bazy z 13.11.2026 · wersja paczki fe5b522db54f (skrót SHA-256 całej paczki)
Pobrania w ostatnich 30 dniach: 0 · ranking
Zgłoś problem z tym skillem: szkodliwa treść, błędny opis albo prośba autora o usunięcie.
Podobne skille
- 90throwaway-prototype
Buduje jednorazowy prototyp uruchamialny, na przykład aplikację terminalową albo warianty interfejsu, żeby odpowiedzieć na pytanie projektowe. - 85workflow-prototype
Buduje jednorazowy prototyp, aby odpowiedzieć na pytanie projektowe: czy model stanu jest sensowny albo jak powinien wyglądać interfejs. - 100plan-prototype
Buduje jednorazowy kod prototypu, który człowiek uruchamia, by odpowiedzieć na jedno pytanie projektowe, zanim cokolwiek zostanie zatwierdzone. - 90prototype-spike
Buduje lub planuje jednorazowy prototyp, który odpowiada na pytanie o projekt, API, UX, wydajność lub integrację, a potem zapisuje wnioski. - 90jor-prototype
Buduje jednorazowy prototyp, by odpowiedzieć na pytanie projektowe, np. czy model stanu wydaje się sensowny lub jak wyglądają warianty. - 90build-prototype
Buduje najmniejszy uruchamialny prototyp, który odpowiada na konkretne pytanie projektowe, i sprawdza jego zachowanie.