
Layers Interaction Flow
- 1.6k installs
- 282 repo stars
- Updated May 30, 2026
- jamiemill/layers-skills
layers-interaction-flow is a Claude Code skill that maps user flows, affordances, navigation paths, edge cases, and failure states for developers who need interaction structure defined before visual design or implementat
About
layers-interaction-flow is a jamiemill/layers-skills technique library that sits between the conceptual model layer (what exists) and the surface layer (how it looks). After loading layers-intro, developers use it to define places users navigate, available affordances, presented content, and transitions between states—including edge cases and failure paths. Breadboard-style outputs keep structure explicit without committing to pixels or components. Reach for layers-interaction-flow when wireframes or code are premature but you need agreement on navigation, empty states, errors, and multi-step flows.
- Defines distinct places, affordances, content needs and state transitions for any user job story
- Requires naming every destination for each affordance as a hard discipline
- Explicitly breadboards failure paths, validation flows, empty states and edge cases
- Sits between conceptual model and surface/visual layer to prevent rework
- Library of techniques rather than a single script — assumes layers-intro is loaded
Layers Interaction Flow by the numbers
- 1,580 all-time installs (skills.sh)
- +129 installs in the week ending Aug 5, 2026 (Skillselion tracking)
- Ranked #234 of 1,880 Design & UI/UX skills by installs in the Skillselion catalog
- Security screen: LOW risk (skills.sh audit)
- Data as of Aug 5, 2026 (Skillselion catalog sync)
npx skills add https://github.com/jamiemill/layers-skills --skill layers-interaction-flowAdd your badge
Show developers this skill is listed on Skillselion. Paste this into your README.
| Installs | 1.6k |
|---|---|
| repo stars | ★ 282 |
| Security audit | 3 / 3 scanners passed |
| Last updated | May 30, 2026 |
| Repository | jamiemill/layers-skills ↗ |
How do you map user flows before visual design?
Map user flows, affordances, navigation paths, edge cases and failure states before committing to visual design or code.
Who is it for?
Developers or designers prototyping SaaS or mobile flows who need shared interaction structure before Figma mocks or frontend commits.
Skip if: Teams ready to implement final UI components or who only need pixel-level visual design critique.
When should I use this skill?
The user asks to map flows, breadboard interactions, or document navigation edge cases before design or build.
What you get
Interaction breadboard, navigation path map, affordance list, and documented edge or failure states.
- Interaction breadboard
- Navigation flow map
- Edge and failure-state checklist
Files
/layers-interaction-flow
Assumes `/layers-intro` has been loaded. This skill is a library of techniques, not a script — see "How to use these skills" there.
The interaction structure and flow layer defines how a person interacts with the product: the places they navigate, the affordances available, the content presented, and the flow between states. It sits above the conceptual model (which defines what exists) and below the surface (which defines how it looks).
A breadboard is always for a particular user in a particular situation doing a particular job. Know which job story before you start.
---
The decisions this layer makes
- The distinct places this flow moves through
- What the user can do in each place, and where each action leads
- What content each place needs to show
- What happens on failure paths, empty states, and edge cases
- Whether the flow is as simple as it can be while still serving the job
If the conceptual model beneath isn't stable, flows built on it often need redoing — check that first.
---
Disciplines — what keeps a flow honest
- Every affordance has a named destination. "Submit → where?" If you can't name it, it's an unmade decision.
- Edges are required steps, not afterthoughts. Breadboard the failure paths (validation, server error, disconnection, timeout, concurrent edit), the empty and loading states, the post-action state, and the cancel path. Each gap is an unmade design decision — name it.
- No broken objects. For each conceptual-model object in this flow, its attributes and actions should be available together — not scattered across screens with no cross-linking.
- No isolated objects. Each model relationship should be visible and navigable in the flow, or there should be a deliberate decision that it needn't be.
- Vocabulary matches the model's ubiquitous language.
- Naming places is a design decision — descriptive and user-meaningful ("Referral dashboard", not "Page 3").
- Keep it minimal. More than 5–6 places for a single job story is a signal to look for what can be collapsed.
---
Breadboard notation
Place name
- affordance → destination place
- affordance → destination place
[ content shown in this place ]---
Techniques
Breadboarding is the default; the rest serve particular situations.
| Technique | Use it when |
|---|---|
| Breadboarding (Ryan Singer / Shape Up) | Default. Text notation that forces interaction logic to be settled before visual design makes changes expensive. |
| Walk the flow as the user | Narrate: "I'm a user who [situation]. I arrive at [place], I see [content], I want to [motivation], so I [affordance]…" Walk the happy path, then every edge. The fastest way to find unmade decisions. |
| User story mapping (Jeff Patton) | Complex product, many user types, incremental planning. Activities → tasks → stories across a timeline. |
| Task analysis | Redesigning an existing flow — decompose the current task to find where friction, errors, and workarounds concentrate. |
| Service blueprinting | Flow spans channels or involves backstage operations (staff, systems, third parties). |
| Critical User Journeys | Deciding which flow to work on — the minimal path to core value (high-traffic, high-revenue, metric-critical). |
Flow diagram (graph LR) | Orientation only — flow through time reads left to right. The text breadboard stays the primary artefact; the diagram loses conditional detail. |
---
Working with the designer
Settle which job story the flow serves, where the user starts, and what success looks like. If redesigning, describe the current flow first — it reveals decisions already made, many of them unintentionally. Then name the places, map affordances and destinations, and walk the flow including its edges, applying the disciplines above. Conditions — when an affordance is or isn't available — are often where the real decisions hide.
Offer the technique that fits: breadboarding for most flows, task analysis for a redesign, story mapping when there's a lot to plan. Do the next useful thing, not all of them.
Capture only the residue: the breadboard (places, affordances, destinations, content, key conditional states), a flow diagram if it aids orientation, the open decisions (gaps and unresolved edge cases), and risks that depend on unsettled lower-layer decisions.
A breadboard defines interaction logic without committing to visual form. Before moving to surface, make sure the conceptual model beneath is stable.
Related skills
FAQ
How is layers-interaction-flow different from visual design?
layers-interaction-flow defines navigation places, affordances, content, and state flow—including failures—without choosing colors, typography, or components. Visual surface decisions come in a later Layers stage.
What should exist before layers-interaction-flow?
layers-interaction-flow assumes layers-intro is loaded and benefits from a conceptual model of what exists in the product. layers-interaction-flow then structures how people move through those concepts.
Is Layers Interaction Flow safe to install?
skills.sh reports 3 of 3 security scanners passed. Review the Security Audits panel on this page before installing in production.