html-wireframe
plannotator/effective-html
Low-fidelity HTML wireframes to test structure, hierarchy, and task flow before design.
What is html-wireframe?
Creates self-contained HTML wireframes that help teams decide what belongs on screen and how tasks should work. Use when you need to explore information architecture, navigation models, or responsive behavior without visual polish or production interactions.
- Generates intentionally unfinished HTML artifacts with grayscale styling and system typography
- Explores multiple structural directions (navigation, grouping, content density, flow) in a single comparable file
- Tests information hierarchy, content placement, task flows, and responsive reflow across desktop and mobile
- Includes basic click-through behavior for navigation and disclosure without elaborate state management
- Preserves project vocabulary, constraints, and real content instead of placeholder text
How to install html-wireframe
npx skills add https://github.com/plannotator/effective-html --skill html-wireframeHow to use html-wireframe
- 1.Identify the user, task, screen, and key structural questions to answer
- 2.Provide explicit instructions or let the skill infer from project context
- 3.Review the generated HTML file at both desktop and mobile widths
- 4.Compare multiple directions (if provided) using the built-in selector
- 5.Check reading order, focus visibility, and all click paths before proceeding to mockup or prototype
Use cases
- Deciding whether a feature should use tabs, accordion, or step-by-step flow before committing to a design
- Testing how a form or checkout process should be organized across mobile and desktop
- Exploring whether a dashboard should show overview cards or detailed lists
- Validating that navigation and primary actions are in the right place for the user's job
- Comparing two or three meaningfully different layout approaches side-by-side
- Product managers and designers exploring structure before visual design
- Teams reviewing information architecture and task flows
- Developers building features and needing to validate layout decisions
- Anyone testing responsive behavior and reading order early in the design process
html-wireframe FAQ
Use html-wireframe to explore structure, hierarchy, and task flow with minimal styling. Use html-prototype when you need polished mockups, production-like interactions, or visual design decisions.
No. Use real labels and representative content, because wording affects layout. Low fidelity means restrained styling, not anonymous boxes.
No. Keep behavior immediate and plain. Add only click-through actions that test navigation, disclosure, or short task flows relevant to the review.
The skill keeps multiple directions in one HTML file with a keyboard-operable selector so you can switch between them without opening separate files.
Defer brand colors, gradients, shadows, illustrations, decorative imagery, and polished component styling to the mockup or prototype stage.
Full instructions (SKILL.md)
Source of truth, from plannotator/effective-html.
name: html-wireframe description: Direct-invocation specialist for low-fidelity, self-contained HTML wireframes that test information hierarchy, content, navigation, task flow, and responsive structure before visual design. Use when the user explicitly invokes html-wireframe or the broad html skill routes a wireframe request here. Do not activate independently from a general request. Do not use for polished mockups or production-like interaction; use html-prototype for those.
HTML Wireframe
Turn a product question into a low-fidelity HTML artifact that is easy to inspect, change, and discuss. The wireframe should help reviewers decide what belongs on the screen and how the task should work. It should not look like a finished product.
Establish the review question
Read the conversation, supplied brief, and nearby project material before choosing a layout. Reuse the project's vocabulary, content model, and known product constraints.
Authority runs in this order:
- The user's explicit instructions and accepted decisions.
- The product's existing structure and terminology.
- The user, task, and content being modeled.
- Your own layout judgment.
Before coding, identify:
- the user and the job they need to complete;
- the screen or bounded flow under review;
- the information and actions the artifact must contain;
- the assumptions that can be made safely;
- the structural questions the wireframe should help answer.
Use real labels and representative content. Low fidelity is not permission to use anonymous boxes or lorem ipsum where wording affects the layout.
Explore structure before style
When design-artifact is available, read it for
subject-specific composition and hierarchy guidance without importing editorial
polish. This skill's low-fidelity contract remains authoritative.
When the layout is still unsettled, create two or three meaningfully different directions. Vary product decisions such as:
- navigation model;
- grouping and order;
- primary-action placement;
- content density;
- overview versus step-by-step flow;
- desktop-to-mobile reflow.
Do not call color changes or minor card rearrangements separate directions. Give each direction a short descriptive name and one sentence about its tradeoff.
Keep the directions in one HTML file when practical. Use a small, keyboard-operable selector so reviewers can compare them without opening several files. Preserve the same core content and task across directions. If the user has already chosen a structure, build that direction only.
Keep the artifact intentionally unfinished
- Use a restrained grayscale palette, system type, plain borders, and simple blocks.
- Avoid brand colors, gradients, shadows, illustrations, decorative imagery, and polished component styling.
- Use limited radius and spacing. Enough order should be present to judge hierarchy, but not enough polish to invite a brand review.
- Show images or rich media as labeled placeholders unless the asset changes a structural decision.
- Add annotations only when they expose an assumption, open question, or behavior that cannot be shown directly.
The wireframe may still be well composed. Intentional unfinishedness is different from careless spacing, illegible type, or broken responsive behavior.
Add only useful behavior
Use basic click-through behavior when it helps test navigation, disclosure, or a short task flow. Keep it immediate and plain.
- Make links, tabs, and next or back actions work when they are part of the review.
- Use native controls and visible keyboard focus.
- Do not build elaborate animation, persistence, simulated APIs, or production state management.
- Remove controls that have no review purpose, or label them clearly as out of scope.
Build contract
- Deliver one self-contained
.htmlfile with essential CSS and JavaScript inline. - Require no build tooling or external service.
- Use semantic landmarks, headings, lists, forms, and buttons.
- Make the layout useful at wide desktop and narrow mobile widths.
- Keep the page free of accidental horizontal overflow.
- Respect the source material. Do not invent extra product scope to fill space.
Verify and hand off
Open the result at desktop and mobile widths. Check reading order, wrapping, overflow, focus visibility, and every implemented click path. Confirm that the directions remain structurally distinct at both sizes.
Return the absolute file path, the names and tradeoffs of the directions, and the visual decisions deliberately deferred to a later mockup or prototype.
Further reading
Read Plannotator's HTML wireframes and prototypes for coding agents for guidance on what to decide at the wireframe stage.
Related skills
More from plannotator/effective-html and the wider catalog.

design-artifact
Design principles and creative direction for polished HTML artifacts—pages, reports, landing pages, and tools that don't look AI-generated.

html
Create self-contained single-file HTML artifacts shaped by your brief, project, and subject.

html-diagram
Build self-contained HTML diagrams that clarify relationships, sequence, topology, state, hierarchy, or structure.

html-plan
Transform plans into clear, inspectable HTML documents that preserve source material and improve structure.

honcho-integration
Integrate Honcho memory and social cognition into existing Python or TypeScript codebases. Use when adding Honcho SDK, setting up peers, configuring sessions, implementing the dialectic chat endpoint for AI agents, or wiring Honcho into bot frameworks (nanobot, openclaw, picoclaw, etc).

design-game
Audit and polish your game's visuals, UI, and player experience without changing gameplay.