
Layers Intro
Load at the start of any product-design session so the agent shares the seven-layer framework before other `/layers-*` skills run.
Overview
layers-intro is a journey-wide agent skill that orients solo builders to the seven-layer Layers of Product Design framework—usable whenever you start a design session before committing to UI or interaction decisions.
Install
npx skills add https://github.com/jamiemill/layers-skills --skill layers-introWhat is this skill?
- Seven layers across Reality, Problem space, and Solution space with logical dependency and upward UX-debt propagation
- Explicit non-linear workflow: enter any layer but validate foundations below
- Gateway orientation all other `/layers-*` skills depend on—load first per SKILL.md
- Spans observed behaviour, domain, needs, strategy, conceptual model, interaction structure, and surface
- Grounded in Jesse James Garrett’s Elements of UX mental model
- 7 design layers across 3 zones (Reality, Problem space, Solution space)
Adoption & trust: 576 installs on skills.sh; 155 GitHub stars; 3/3 security scanners passed (skills.sh audits); trending (+100% hot-view momentum).
What problem does it solve?
You are about to run design skills or generate UX, but the agent does not share a consistent model of problem vs solution layers, so advice conflicts and weak foundations propagate as UX debt.
Who is it for?
Indie builders kicking off any Layers-of-Product-Design workflow or mixed design review where multiple `/layers-*` skills may run in one session.
Skip if: Sessions where you only need a one-off visual tweak and will not use the layers skill family—or when a full product spec is already frozen and you refuse any framework reframing.
When should I use this skill?
At the start of any design session before other `/layers-*` skills, per SKILL.md.
What do I get? / Deliverables
The agent loads shared framework context (zones, layer names, dependency rules) so subsequent `/layers-*` skills can target the right layer without reinventing the methodology.
- Shared framework context for the agent session
- Aligned vocabulary for subsequent layer-specific skills
Recommended Skills
Journey fit
Useful at every journey phase - explore requirements and options before committing to a direction.
Where it fits
Map domain concepts and user needs before choosing what to prototype.
Check whether proposed MVP features sit on sound strategy and conceptual-model layers.
Before screen designs, confirm interaction structure and flow logic are coherent.
Trace UX bugs upward to weak lower layers instead of only patching surface copy.
Align landing-page hierarchy with surface layer without contradicting the conceptual model.
How it compares
Use as structured design ontology before ad-hoc “make this UI nicer” prompts, not as a Figma plugin or component library.
Common Questions / FAQ
Who is layers-intro for?
Solo and indie product builders, and small teams, who use agent skills for UX and product design and want a single shared framework before deeper `/layers-*` skills execute.
When should I use layers-intro?
At the start of any design session with the layers repo—during Idea research, Validate scoping, Build interaction planning, Ship review of UX debt, or Launch messaging hierarchy checks—whenever you need aligned layer vocabulary first.
Is layers-intro safe to install?
It is documentation-only orientation with no shell, network, or secret access; review the Security Audits panel on this Prism page before trusting any skill in your agent environment.
SKILL.md
READMESKILL.md - Layers Intro
# /layers-intro Load this skill at the start of any design session. It provides the framework context that all other `/layers-*` skills depend on. --- ## The framework **Layers of Product Design** organises design work into seven layers across three zones. Layers have *logical dependency*: lower layers are foundations for upper ones. Weak lower layers create UX debt that propagates upward. **Reality** — complex, contradictory, evolving. Source of all learning. **Problem space** — knowledge gathered from reality: 1. **Observed behaviour** — what users actually do 2. **The domain** — concepts, terminology, and mental models that exist independently of any product 3. **User needs** — what we think users are trying to achieve, and why **Solution space** — deliberate decisions about what to build: 4. **Product & service strategy** — which needs to serve, and what business outcomes to target 5. **Conceptual model** — objects, relationships, states, vocabulary — independent of any interface 6. **Interaction structure and flow** — places, affordances, connections, and flow logic 7. **Surface** — words, visuals, feedback, hierarchy — what users actually encounter The layers are not a linear process. Enter anywhere — but always check whether the foundations below are sound. *Inspired by Jesse James Garrett's* The Elements of User Experience *(2000).* --- ## Design is decision-making Design = making decisions about the form of a solution (Christopher Alexander). Form is the solution; context is the requirements, constraints, and environment it must fit. Good design is good fit. **Four kinds of progress:** 1. **Making decisions** — resolving something undecided 2. **Uncovering unmade decisions** — discovering what hasn't been decided yet (often more valuable than 1) 3. **Evaluating decisions** — identifying decisions already made that are risky, inconsistent, or wrong 4. **Prioritising decisions** — lower layers are more foundational and carry more risk if wrong The job of every skill is to help the designer make better decisions — not to make decisions for them. --- ## How to use these skills Each `/layers-*` skill is a **library of techniques for one layer — not a script to run start to finish.** Don't march through every step and emit a stack of artefacts. Instead: 1. **Find the live decisions.** What at this layer is genuinely undecided, risky, or worth surfacing? (`/layers-orient` finds these across all layers if you're not sure.) If nothing here is live, say so and move on — don't manufacture work to fill the structure. 2. **Offer a technique that fits the decision.** Each skill lists techniques with the situations they suit. Suggest one or two and let the designer choose. A technique is a way to make a specific decision, not a box to fill. 3. **Work the decision; capture only the residue.** Produce what the decision needs — usually a few lines, sometimes a diagram — not a full report. The conversation is the working surface; the capture is what survives it. Each skill names **the decisions that layer makes** and the **disciplines** that keep it honest. Those are the spine. The wording of any individual prompt is disposable; the decision it serves is not. --- ## Principles — apply across all sessions 1. **Decisions, not outputs.** Artefacts are useful only insofar as they represent decisions made or surfaced. Name the decision, not just the diagram. 2. **Uncover before you resolve.** Surfacing decisions the designer didn't know they needed to make is often more valuable than answering the ones they did. 3. **Work at one layer at a time.** Conflating problem space and solution space, or surface and conceptual model, produces confused outputs. 4. **Check foundations before building upward.** Before working on an upper layer, audit the layer below. Flag inst