Layers Interaction Flow

jamiemill/layers-skills/skills/layers-interaction-flow

by jamiemilla201dc8c2011No license307 starsListed Oct 8, 2026Updated Oct 8, 2026Repository updated 4 months ago

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

Instructions onlyDesign & Creative
AI-generated overview

Maps product interaction structure and flow using breadboarding and related UX techniques, without committing to visual form.

What it does
This skill provides a library of techniques for defining how a person interacts with a product: the places they navigate, the affordances available, the content shown, and the flow between states. It produces a breadboard notation of places, affordances, destinations, content, and key conditional states, plus optional flow diagrams and a list of open decisions and risks. It also covers failure paths, empty and loading states, and edge cases as required design steps.
When to use it
Use it when designing or redesigning a product flow and needing to settle interaction logic before visual design. It fits situations such as mapping a job story, decomposing an existing flow for friction, or planning complex multi-user-type products. It assumes the conceptual model is stable and that the layers-intro skill has been loaded.
Requirements
No scripts or tools are required; it is an instructions-only skill. It assumes the companion skill layers-intro has been loaded and that a conceptual model is already stable.

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

Source and attribution

Source:jamiemill/layers-skillsinskills/layers-interaction-flowat commita201dc8

License: No license

Content belongs to its original authors. SourceWeft indexes it from a public repository.

Report or request removal