PluginBench
Skill
Pass
Audit score 90

layers-interaction-flow

jamiemill/layers-skills

Map interaction structure and flow—places, affordances, edge cases—without committing to visual form.

What is layers-interaction-flow?

Techniques for designing interaction flows by defining places, affordances, and state transitions. Use this skill when settling how users navigate a product, what actions are available at each step, and how edge cases and failures are handled—before visual design.

  • Breadboard interactions using text notation that forces logic to be settled early
  • Walk flows as the user to uncover unmade decisions and edge cases
  • Map affordances to named destinations and validate all paths (happy path, failures, empty states)
  • Apply disciplines: every affordance has a destination, edges are required steps, no broken or isolated objects
  • Choose techniques by situation: breadboarding (default), task analysis (redesign), story mapping (complex product), service blueprinting (multi-channel), or flow diagrams (orientation)
  • Validate that the conceptual model beneath is stable before committing to surface design

How to install layers-interaction-flow

npx skills add https://github.com/jamiemill/layers-skills --skill layers-interaction-flow
Prerequisites
  • Familiarity with the `/layers-intro` skill (this is a library of techniques, not a script)
  • A defined job story or user goal for the flow being mapped
Claude Code
Cursor
Windsurf
Cline

How to use layers-interaction-flow

  1. 1.Settle which job story the flow serves, where the user starts, and what success looks like
  2. 2.If redesigning, describe the current flow first to reveal existing decisions
  3. 3.Name the distinct places the user navigates through
  4. 4.Map affordances (actions) to their named destinations in each place
  5. 5.Identify content needed in each place
  6. 6.Walk the flow including edge cases: validation failures, server errors, empty states, loading states, cancel paths, and post-action states
  7. 7.Apply the disciplines: every affordance has a destination, edges are required, no broken or isolated objects, vocabulary matches the conceptual model
  8. 8.Capture the breadboard (places, affordances, destinations, content, conditional states) and any open decisions or risks

Use cases

Good for
  • Designing a new user flow for a feature before any visual mockups
  • Redesigning an existing flow by decomposing current tasks to find friction and workarounds
  • Planning incremental work across multiple user types and activities
  • Mapping flows that span channels or involve backstage operations (staff, systems, third parties)
  • Identifying which critical user journey to prioritize based on traffic, revenue, or metrics
Who it's for
  • Product designers and design leads
  • Product managers planning interaction logic
  • Teams using Shape Up or similar outcome-driven processes
  • Anyone settling interaction decisions before visual design

layers-interaction-flow FAQ

What's the difference between breadboarding and a flow diagram?

A breadboard is the primary artifact—text notation that captures interaction logic, conditions, and decisions. A flow diagram (graph LR) aids orientation but loses conditional detail; use it only after the breadboard is settled.

When should I use task analysis instead of breadboarding?

Use task analysis when redesigning an existing flow. Decompose the current task to find where friction, errors, and workarounds concentrate—this reveals decisions already made.

How do I know if my flow is too complex?

More than 5–6 places for a single job story signals that something can be collapsed. Look for what can be simplified or whether you're trying to serve multiple job stories at once.

What does 'no broken objects' mean?

For each object in your conceptual model, its attributes and actions should be available together in the flow—not scattered across places with no way to navigate between them.

Should I breadboard before or after the conceptual model is settled?

Breadboard only after the conceptual model is stable. If the model beneath isn't settled, flows built on it often need redoing.

Full instructions (SKILL.md)

Source of truth, from jamiemill/layers-skills.


name: layers-interaction-flow description: Techniques for mapping interaction structure and flow — places, affordances, edge cases, and failure paths — without committing to visual form

/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.

TechniqueUse 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 userNarrate: "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 analysisRedesigning an existing flow — decompose the current task to find where friction, errors, and workarounds concentrate.
Service blueprintingFlow spans channels or involves backstage operations (staff, systems, third parties).
Critical User JourneysDeciding 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.