Agent skill

HTML Prototype

by plannotator in plannotator/effective-html

Direct-invocation specialist for polished, responsive, self-contained HTML mockups and interactive prototypes grounded in the user's conversation, product context, and design language.

MITAuto-check passedFrontend & Design

Install HTML Prototype

skills CLI
$ npx skills add plannotator/effective-html --skill html-prototype -a claude-code

Project install by default; add -g for ~/.claude/skills/.

GitHub CLI
$ gh skill install plannotator/effective-html html-prototype --agent claude-code

Project scope by default; add --scope user for a personal install. Needs GitHub CLI 2.90.0 or later (public preview).

Manual copy
$ git clone --depth 1 https://github.com/plannotator/effective-html.git skills-src && mkdir -p .claude/skills && cp -r skills-src/skills/html-prototype .claude/skills/html-prototype && rm -rf skills-src

Use ~/.claude/skills/ instead of .claude/skills for a personal install. The folder must contain SKILL.md.

Claude Code skills documentation · loads skills from .claude/skills/

Facts

Skill name
html-prototype
GitHub stars
3.6k
Token cost
~1.5k tokens
SKILL.md length
785 words
Files
2
Skills in repo
4
Repo updated
First seen
Licence
MIT

At a glance

Direct-invocation specialist for polished, responsive, self-contained HTML mockups and interactive prototypes grounded in the user's conversation, product context, and design language.

  • Works in 4 steps: The user's explicit visual and… → The project's established design… → The product, audience, content, and… → …
  • The user explicitly invokes html-prototype
  • SKILL.md covers Choose the fidelity mode, Derive the direction from…, Scope one credible experience and Model relevant states, plus 4 more sections
  • Instructions only: no scripts, shell commands, URLs or credentials in SKILL.md

What it does

HTML Prototype is an agent skill from plannotator/effective-html. Direct-invocation specialist for polished, responsive, self-contained HTML mockups and interactive prototypes grounded in the user's conversation, product context, and design language. Use when the user explicitly invokes html-prototype or the broad html skill routes a mockup or prototype request here. Do not activate independently from a general request. Treat a mockup as a noninteractive fidelity mode within this skill, not as a separate skill.

Its SKILL.md is about 1.5k tokens, which your agent loads only when the skill is triggered. The skill folder holds 2 other files (for example `agents/openai.yaml`).

It sits in Frontend & Design, covering Prototyping. The repository describes itself as: Agent skills for useful HTML artifacts, wireframes, interactive prototypes, plans, and diagrams. The licence is MIT.

When your agent uses it

  • The user explicitly invokes html-prototype
  • The broad html skill routes a mockup
  • Prototype request here

Example prompts

  • “/html-prototype”

Workflow steps

4 steps, taken from the first numbered list in SKILL.md.

  1. The user's explicit visual and functional instructions.
  2. The project's established design language and interaction conventions.
  3. The product, audience, content, and scenario.
  4. Your own design judgment.

What it can do on your machine

Read from SKILL.md and the folder at commit 2ac1dfe. It shows what the files ask for, not the result of running them.

  • Tool permissions

    Pre-approves nothing: there is no allowed-tools line, so your agent's usual permission prompts apply.

    From allowed-tools in the SKILL.md frontmatter.

  • Runs code

    No scripts in the folder and no shell commands in SKILL.md.

    From the folder's file list and the shell code blocks in SKILL.md.

  • Network

    Links to these hosts (documentation or services it may open):

    • docs.plannotator.ai

    From URLs in SKILL.md, links to its own repository left out.

  • Credentials

    Names no API keys, tokens, secrets or passwords.

    From names ending in _API_KEY, _TOKEN, _SECRET, _KEY or _PASSWORD in SKILL.md.

Context cost

HTML Prototype loads about 1.5k tokens when it runs. Until then it costs about 116 tokens; SKILL.md has 785 words of instructions outside code blocks.

Always · name and description, kept in context so the agent knows when to use it
~116
When it runs · the whole SKILL.md, loaded when a task matches
~1.5k

Estimates: characters ÷ 4, the usual rule of thumb; real counts depend on the model's tokenizer. Scripts and assets cost tokens only if the agent reads them.

Safety

Auto-check passed

The automated check found no risky patterns in SKILL.md.

Automated static check — not a guarantee. Review scripts before installing. It scans the text of SKILL.md for risky patterns (piping downloads into a shell, reading credential files, hidden Unicode, destructive commands); files beside SKILL.md are not scanned.

SKILL.md

The full file from plannotator/effective-html at commit 2ac1dfe, republished under its MIT licence (© plannotator). 785 words, ~1,514 tokens.

Download SKILL.mdSave it as .claude/skills/html-prototype/SKILL.md (or your agent's skills folder). This skill also uses 1 other file; get the full folder from GitHub.
name
html-prototype
description
Direct-invocation specialist for polished, responsive, self-contained HTML mockups and interactive prototypes grounded in the user's conversation, product context, and design language. Use when the user explicitly invokes html-prototype or the broad html skill routes a mockup or prototype request here. Do not activate independently from a general request. Treat a mockup as a noninteractive fidelity mode within this skill, not as a separate skill.

HTML Prototype

Build a credible model of a product decision. Match the artifact to the user's context instead of applying a recurring house style. The goal is not to make every possible screen. The goal is to make the important visual or behavioral question testable.

Choose the fidelity mode

Use one of two modes:

  • Mockup: Create a polished, responsive, mostly static artifact when the open question is visual hierarchy, layout, typography, color, or product fit.
  • Prototype: Create a working flow when the open question is navigation, input, state change, feedback, recovery, or transition.

Do not create a separate html-mockup skill. Do not add behavior merely to make a mockup seem more complete. If a user asks for both modes, preserve the same content and structure so changes in fidelity remain easy to compare.

Derive the direction from context

Inspect the conversation, supplied references, and project before designing. Look for design-system documentation, tokens, existing components, product screenshots, and nearby artifacts.

Authority runs in this order:

  1. The user's explicit visual and functional instructions.
  2. The project's established design language and interaction conventions.
  3. The product, audience, content, and scenario.
  4. Your own design judgment.

Before coding, settle:

  • the user and critical job;
  • the bounded scenario under review;
  • mockup or prototype mode;
  • the source of the visual direction;
  • the relevant state model;
  • the point where the real product would take over.

When no design system exists, create a specific direction from the subject and use case. Do not default to a gradient, a dark dashboard, interchangeable cards, or decorative metrics. A prototype for a field tool, an editorial workflow, and a financial approval should not feel like the same product.

When design-artifact is available and the visual direction remains open, read and compose it with this skill. Use it to choose the register, palette, type, and composition; keep this skill authoritative for fidelity, state, and interaction completeness.

Scope one credible experience

Choose the smallest flow that can answer the review question. Use realistic, internally consistent names, dates, statuses, quantities, and copy.

  • Make navigation work for the modeled scope.
  • Implement forms with labels, validation, submission feedback, and sensible defaults.
  • Use dialogs only when interruption or confirmation is part of the scenario.
  • Use transitions to clarify continuity or state change, not as decoration.
  • Remove dead buttons. If an action belongs to the real system, explain the boundary instead of pretending it completed.

Model relevant states

List the states before building. Include the states that the chosen scenario can actually reach:

  • loading;
  • empty;
  • error;
  • success;
  • disabled;
  • mobile;
  • domain-specific states from the brief.

An asynchronous-looking prototype action should normally show loading, success, and failure or recovery. A collection should normally consider empty state. A gated action should show why it is disabled. Do not force irrelevant states into the main flow just to satisfy a checklist. Make omitted states explicit in the handoff.

Show full SKILL.md (308 more words)Show less

Make interaction complete

  • Use native elements when they provide the right semantics.
  • Support the entire modeled flow with a keyboard.
  • Keep focus visible and place it deliberately after meaningful transitions.
  • Give dialogs an accessible name, contain focus, close on Escape, and restore focus to the trigger.
  • Associate form errors with their controls and announce important status changes.
  • Do not hide essential behavior behind hover.
  • Respect prefers-reduced-motion while preserving state feedback.
  • Make touch targets usable and prevent accidental page-level horizontal overflow.

In mockup mode, preserve semantic structure and visible focus styles even if the controls are not wired. Make the static review boundary clear.

Build contract

  • Deliver one self-contained .html file with essential CSS and JavaScript inline.
  • Require no build tooling, authentication, live API, or external service.
  • Use a responsive composition rather than shrinking a desktop canvas.
  • Keep design tokens small and specific to the chosen direction.
  • Use accessible contrast and more than color alone to communicate state.
  • Prefer depth and correctness in one flow over breadth across a fake product.

Verify and hand off

Test the artifact at wide desktop and narrow mobile widths. Exercise every modeled state and control. Test Tab, Shift+Tab, Enter, Space, arrow keys where appropriate, and Escape for dialogs. Check the console, page overflow, long content, disabled behavior, focus restoration, and reduced-motion mode.

Inspect computed foreground and background colors on every distinct surface, especially text that may inherit the body color inside a dark or tinted region. If browser tooling is unavailable, say which visual and interaction checks remain unverified instead of treating source inspection as a substitute.

Return the absolute file path, the fidelity mode, the scenario modeled, the states implemented, and the production behavior deliberately left out.

Further reading

Read Plannotator's HTML wireframes and prototypes for coding agents for guidance on moving from an approved structure to a mockup or working prototype.

© plannotator, MIT. Rendered from Markdown: HTML in the file is shown as text, images as links, and headings moved down two levels. Raw file

Files

SKILL.md and 1 other file in skills/html-prototype of plannotator/effective-html.

  • SKILL.md
  • agents/openai.yaml

Open the folder on GitHubat commit 2ac1dfe

Compare with similar skills

HTML Prototype next to the 5 skills that share the most tags, products or categories with it. Stars are the repository's; “used in” counts other GitHub owners with a copy.

HTML Prototype compared with similar skills
SkillStarsUsed inTokensAuto-checkLicenceRepo updated
HTML Prototype this skillplannotator/effective-html3.6k—~1.5kAutomated safety check: PassMIT
Fast Agent Designevalstate/fast-agent3.9k—~220Automated safety check: PassApache-2.0
Baby Menu Designkunchenguid/baby-menu233—~1.1kAutomated safety check: PassMIT
Writing Specbartstc/vite-ts-react-template122—~3.4kAutomated safety check: PassMIT
Beava Designbeava-dev/beava138—~443Automated safety check: PassApache-2.0
Vibeusage DesignvictorGPT/vibeusage131—~566Automated safety check: PassMIT

Similar skills

  • Fast Agent Design

    evalstate/fast-agent

    A skill your agent uses to generate well-branded interfaces and assets for fast-agent, either for production or throwaway prototypes/mocks/etc.

    3.9k GitHub stars~220 tokensUpdated 3 days ago
    Frontend & DesignAuto-check passed
  • Baby Menu Design

    kunchenguid/baby-menu

    A skill your agent uses to generate well-branded interfaces and assets for Baby Menu, either for production or throwaway prototypes/mocks/etc.

    233 GitHub stars~1.1k tokensUpdated 12 days ago
    Frontend & DesignAuto-check passed
  • Writing Spec

    bartstc/vite-ts-react-template

    Collaboratively write a feature spec with the developer. An agent skill from bartstc/vite-ts-react-template.

    122 GitHub stars~3.4k tokensUpdated yesterday
    Frontend & DesignAuto-check passed
  • Beava Design

    beava-dev/beava

    A skill your agent uses to generate well-branded interfaces and assets for beava (beava.dev, an open-source single-binary feature server for stream processing), either for production or throwaway…

    138 GitHub stars~443 tokensUpdated 4 mo ago
    Frontend & DesignAuto-check passed
  • Vibeusage Design

    victorGPT/vibeusage

    A skill your agent uses to generate well-branded interfaces and assets for VibeUsage, either for production or throwaway prototypes/mocks/etc.

    131 GitHub stars~566 tokensUpdated 2 mo ago
    Frontend & DesignAuto-check passed
  • Prototype Strategy

    Owl-Listener/designer-skills

    Choose prototype fidelity and method to match the design question and the decision at stake.

    2.9k GitHub starsUsed in 1 repo~465 tokens
    Frontend & DesignAuto-check passed

More from plannotator/effective-html

  • HTML

    plannotator/effective-html

    Create or redesign self-contained single-file HTML artifacts with a visual direction shaped by the user's brief, project, and subject.

    3.6k GitHub stars~1.6k tokensUpdated 23 days ago
    Auto-check passed
  • HTML Diagram

    plannotator/effective-html

    Direct-invocation specialist for self-contained HTML diagrams whose layout, notation, and interaction clarify relationships, sequence, topology, state, hierarchy, or quantitative structure.

    3.6k GitHub stars~678 tokensUpdated 23 days ago
    Auto-check passed
  • HTML Plan

    plannotator/effective-html

    Direct-invocation specialist for clear, self-contained HTML plans that preserve source material while improving hierarchy, sequence, ownership, dependencies, and reviewability.

    3.6k GitHub stars~614 tokensUpdated 23 days ago
    Auto-check passed

Questions about HTML Prototype

What does HTML Prototype do?

Direct-invocation specialist for polished, responsive, self-contained HTML mockups and interactive prototypes grounded in the user's conversation, product context, and design language. HTML Prototype is an agent skill from plannotator/effective-html. Direct-invocation specialist for polished, responsive, self-contained HTML mockups and interactive prototypes grounded in the user's conversation, product context, and design language.

When should I use HTML Prototype?

HTML Prototype fits situations like: the user explicitly invokes html-prototype; the broad html skill routes a mockup; prototype request here.

How do I install HTML Prototype in Claude Code?

Run `npx skills add plannotator/effective-html --skill html-prototype -a claude-code`. Or copy the skill folder (skills/html-prototype in plannotator/effective-html) into .claude/skills/html-prototype in your project. Claude Code loads it when a task matches its description.

How do I install HTML Prototype in Codex?

Run `npx skills add plannotator/effective-html --skill html-prototype -a codex`. Or copy the skill folder (skills/html-prototype in plannotator/effective-html) into .agents/skills/html-prototype in your project. Codex loads it when a task matches its description.

Can I use HTML Prototype in Cursor, Gemini CLI or GitHub Copilot?

Cursor, Gemini CLI, GitHub Copilot and OpenCode also load SKILL.md folders. With the skills CLI, run `npx skills add plannotator/effective-html --skill html-prototype -a cursor` (or -a gemini-cli, github-copilot or opencode for the others). To copy it by hand, put the folder in .cursor/skills/html-prototype, .gemini/skills/html-prototype, .github/skills/html-prototype and .opencode/skills/html-prototype in your project.

What does HTML Prototype need to run?

SKILL.md names no scripts, command-line tools or credentials: HTML Prototype is instructions for the agent only.

Does HTML Prototype access the network?

SKILL.md names 1 domain. As links in the text: docs.plannotator.ai. This is read from the text; nothing was executed.

Is HTML Prototype safe to install?

Our automated static check of SKILL.md found no risky patterns, such as piping downloads into a shell, reading credential files or hidden Unicode. It is not a guarantee. Review the folder before installing.

What licence does HTML Prototype use?

HTML Prototype is published under the MIT licence (the repository's licence). It allows redistribution, so the full SKILL.md is shown on this page.

How many tokens does HTML Prototype use?

About 1.5k tokens (SKILL.md is roughly 6.1k characters). Agents keep only the skill's name and description in context until a task matches; then they load SKILL.md in full.

What are the alternatives to HTML Prototype?

Skills that share tags, products or a category with HTML Prototype: Fast Agent Design (evalstate/fast-agent, 3.9k stars), Baby Menu Design (kunchenguid/baby-menu, 233 stars), Writing Spec (bartstc/vite-ts-react-template, 122 stars) and Beava Design (beava-dev/beava, 138 stars). The comparison table on this page puts their stars, adoption, token cost, safety result and licence side by side.

Who maintains HTML Prototype?

plannotator (a GitHub organization) maintains it in plannotator/effective-html, which has 3,555 GitHub stars. The repository holds 4 skills in this directory. The repository was last updated on September 14, 2026.

Source: plannotator/effective-html on GitHub. Facts on this page come from the repository at the commit we read; the author's words are quoted as theirs.