Skip to content
Skills Library
Programming · Building & coding

frontend-prototype-explorer

/frontend-prototype-explorer

Build disposable experiments for unresolved UI or state decisions. Use when code and documentation cannot settle the question; exclude approved implementation and small edits.

Licence
Apache-2.0
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
2
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

Apache-2.0, otwarta: można używać i zmieniać, z zachowaniem licencji i informacji o zmianach.

What it does and when to use it

Build disposable experiments for unresolved UI or state decisions. Use when code and documentation cannot settle the question; exclude approved implementation and small edits.

Original author description

Build disposable experiments for unresolved UI or state decisions. Use when code and documentation cannot settle the question; exclude approved implementation and small edits.

How it works

  1. Purpose
  2. When To Use
  3. When Not To Use
  4. Required Context
  5. Tool Contract
  6. Workflow
  7. Output Contract
  8. Validation Gates
  9. Trigger Evals
  10. Reference Map
Original SKILL.md headings · 102 lines, 640 words
SKILL.md preview
---
name: frontend-prototype-explorer
description: "Build disposable experiments for unresolved UI or state decisions. Use when code and documentation cannot settle the question; exclude approved implementation and small edits."
id: "agents.skills.frontend-prototype-explorer.skill"
title: "Frontend Prototype Explorer"
doc_type: "skill"
layer: "skill"
status: "active"
publishable: true
local_only: false
skill: "frontend-prototype-explorer"
tags: []
parent:
  - "[[AGENTS|Canonical Agent Policy]]"
related:
  - "[[common/domain-glossary-rules]]"
  - "[[templates/decision-log]]"
depends_on: []
---

# Frontend Prototype Explorer

Maturity: experimental. Validate a consequential UI or state decision through
a disposable experiment before production implementation.

## Purpose

Answer one unresolved question with the cheapest runnable artifact. Preserve
the decision and evidence, not an accidental production implementation.

## When To Use

- Compare interactive UI alternatives when descriptions cannot settle usability.
- Exercise a state model through cancellation, delayed responses, or recovery.
- Investigate a consequential choice that source and documentation cannot settle.

## When Not To Use

- Implementing an already approved layout or feature.
- A small style edit, routine bugfix, or question answered by existing source.
- Planning-only requests that do not authorize building an experiment.
- Backend, production data, benchmarking, or new infrastructure outside scope.

## Required Context

1. Apply the active runtime entrypoint (`AGENTS.md` for project targets or
   the native runtime prelude for plugin targets) and the confirmed question
   and constraints.
2. Inspect only the existing stack, commands, and affected ownership needed.
3. Read `common/domain-glossary-rules.md` when domain terms matter.
4. Read `common/verification-loop-rules.md` for executable observations and
   `common/rendered-visual-verification-policy.md` if UI interaction is needed.

## Tool Contract

Use available project-file and command capabilities. A callable browser is
required for claims about rendered interaction, not for a headless state probe.
Use existing dependencies. Tool or package installation, external mutations,
and production access retain their existing authorization boundaries.

## Workflow

1. State one question, what observation would change the decision, and the
   bounded experiment scope. Resolve facts from code before asking questions.
2. Choose an isolated scratch directory or disposable worktree outside production
   source and build inputs. Never overwrite an existing experiment. State the
   allowed files, stop condition, and attempt/time budget before implementation.
3. Build the minimum probe with synthetic in-memory data and one launch command.
   For usability, compare meaningfully different interactions on the same data;
   for logic, expose transitions and resulting state. Avoid production services,
   durable user storage, test infrastructure, and speculative abstractions.
4. Run the relevant cases and record observations. If a tool is unavailable,
   record blocked evidence. For subjective usability, present the alternatives
   and collect user judgment; agent preference alone is not user validation.
5. Stop when the question is answered, the budget is exhausted, or evidence is
   blocked. Report inconclusive results without defaulting to a preferred option.
6. Record Question, Observations, Decision, Limitations, and Evidence reference
   in the existing local decision log when durable work warrants it. Include
   rejected alternatives only when actually considered.
7. Hand the decision to the design/architecture or execution planner. Production
   implementation is a separate approved slice with its own acceptance checks.
   Do not silently promote prototype code, merge its branch, publish it, or
   delete artifacts owned by the user. Keep an evidence pointer for resumption.

## Output Contract

Final response: return only facts that affect the user's understanding, confidence, or next action. Omit empty fields and workflow narration.

Report the answered question, launch command or artifact, observations,
decision or pending user judgment, limitations, and next implementation step.
State experimental maturity. Do not report production readiness from a probe.

## Validation Gates

- One question and explicit budget bound the experiment.
- Production source, dependencies, and real data remain outside the experiment.
- Claims are tied to executed observations or clearly marked user judgments.
- Blocked or inconclusive evidence is not success.
- A decision survives the session, with the scope of what was actually tested.

## Trigger Evals

Should trigger:

- "Compare two interactive filter placements using disposable data before we choose."
- "Prototype cancel and retry transitions to decide whether this state model works."
- "Try a throwaway preview interaction; stop after answering the navigation question."

Should not trigger:

- "Implement the approved preview layout."
- "Change the prototype button color in this one file."
- "Explain this existing state reducer without making changes."

## Reference Map

- `common/domain-glossary-rules.md`
- `common/verification-loop-rules.md`
- `common/rendered-visual-verification-policy.md`
- `templates/decision-log.md`
Files in this package (2)
  • SKILL.md 5 KB
  • agents/openai.yaml 1 KB

Versions

The database has no other skills named frontend-prototype-explorer.

Database snapshot: 13.11.2026 · package version fc552059318b (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

  • 81prototype
    Runs a bounded experiment when existing evidence cannot settle a material design, feasibility, or runtime question cheaply. Use for prototypes, spikes, and proof-of-concept work.
  • 100prototype
    Builds throwaway variants to answer one decision question (UI layout, interaction, state machine, data model) before production work, kept out of production paths. Use when the right approach is genuinely uncertain and cheap experiments can decide it. Pair with frontend-design for UI.
  • 90prototype
    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.
  • 90prototype-lab
    Build throwaway prototypes to answer a specific product, UI, state-machine, data-model, or workflow question before committing production code. Use when the user asks to prototype, explore variants, sanity-check logic, try designs, make a playable mock, or learn quickly with…
  • 90prototype
    Build a throwaway prototype to answer a focused logic, state-model, or UI question before committing to production design. Use when the user asks to prototype, sanity-check a model, mock up UI, explore design options, or try a few designs.
  • 90prototype
    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.

Feedback and reports

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