Skip to content

ans-4175/interaction-design-skills / skills/interaction-design

interaction-design

Verified

Guide, audit, or decide human-centered interaction design — digital products (apps, web, dashboards, forms), information design, and services or organisational processes (requests, approvals, onboarding) — using named laws and heuristics (Fitts, Hick, Miller, Jakob, Tesler, Doherty, Peak-End, Norman, Nielsen, Gestalt, service blueprint). Use when designing a screen, flow or process, reviewing one for usability problems, or choosing between design options.

---
name: interaction-design
description: Guide, audit, or decide human-centered interaction design — digital products (apps, web, dashboards, forms), information design, and services or organisational processes (requests, approvals, onboarding) — using named laws and heuristics (Fitts, Hick, Miller, Jakob, Tesler, Doherty, Peak-End, Norman, Nielsen, Gestalt, service blueprint). Use when designing a screen, flow or process, reviewing one for usability problems, or choosing between design options.
disable-model-invocation: true
---

# Interaction Design

Three modes: **GUIDE** (design something new), **AUDIT** (judge something that exists) and **DECIDE** (choose between options). Pick the mode from the request. If the request is ambiguous, say which mode you are using in one line and go on.

Ground every claim in a named principle **and** in the actual artifact (screen, flow, code, screenshot, form, SOP, process description). A law alone is not a finding: say where it applies and what changes.

## References (read only what the task needs)

| File | Read when |
|---|---|
| `references/laws.md` | Any mode. The core laws: what each says, when it applies, common misuse |
| `references/heuristics.md` | AUDIT. Nielsen's 10, Norman's principles, severity scale |
| `references/patterns.md` | The work touches errors, feedback, loading, forms, navigation, search, onboarding, gestures |
| `references/states.md` | A component or flow has async work, branching, or many states |
| `references/information-design.md` | Layout, grouping, hierarchy, density, tables, charts, dashboards |
| `references/service-process.md` | Services and human processes: several people/units, approvals, documents, offline channels (service blueprint, handoffs, SLAs) |

## Choosing which principles matter

Start from the user's situation, not from the list of laws:

| Situation | Look first at |
|---|---|
| Too many options or a crowded screen | Hick, Miller (chunking), progressive disclosure, density |
| Hard to hit, mis-taps, mobile reach | Fitts |
| "Users don't find X" | Jakob (convention), scent/wayfinding, serial position, von Restorff |
| User does work the system could do | Tesler, Postel, recognition over recall |
| Feels slow | Doherty, loading ladder, optimistic UI |
| Errors, data loss, frustration | Error hierarchy, Norman constraints, undo over confirm |
| Unclear what happened after an action | Feedback, visibility of system status, gulf of evaluation |
| Multi-step / long tasks | Goal-gradient, Zeigarnik (with autosave), Peak-End |
| Grouping, alignment, "looks messy" | Gestalt, visual hierarchy, aesthetic-usability |
| A process run by people/units (requests, approvals, intake) | `service-process.md`: blueprint, handoffs, state ownership + Tesler, visibility of status |

Apply only 2–5 principles to any one problem. Listing every law is noise.

## GUIDE — design a screen, component, or flow

1. **Frame**: who the user is, the primary task, the context (device, frequency, stakes), and what "done" looks like. Ask only for what blocks the design; otherwise state your assumptions.
2. **Structure**: the content and actions on the screen, grouped and ordered by importance and task sequence (Miller, serial position, Gestalt).
3. **Interaction**: for each key action give the trigger, the rules, the feedback and the result. Use the conventional pattern unless there is a stated reason not to (Jakob).
4. **States**: empty, loading, partial, error, success, no-permission, offline where relevant (`states.md`). Each state needs a way out.
5. **Edges**: errors and recovery, long or missing content, first use vs. repeat use, keyboard and screen-reader access.
6. **Output**: a short spec. Cover structure, interactions, a state table, copy for key moments and open questions. Tag each design choice with the principle behind it, e.g. `(Hick)` or `(Tesler)`. Include an ASCII wireframe of each key screen and the flow between them (see *Wireframes*).

## AUDIT — review a screen, flow, or implementation

1. **Scope**: which screens, flows or tasks are in scope. Walk the primary task as a first-time user, then as a frequent user.
   - **Trace across roles.** When a task spans people (trainer shows a QR → participant scans; requester submits → approver acts), walk both sides. The root cause often sits on the other role's screen, such as the wrong artifact being shown or shared.
2. **Inspect** the real thing: the running app (drive it with a browser tool) and the code. Do not audit from memory. Live evidence finds what code misses (layout below the fold, stale messages, real copy); code finds states you can't trigger. Use both when you can.
3. **Check** against `heuristics.md`, then the relevant laws and patterns. Pay extra attention to the unhappy paths: errors, empty states, slow network, expired session.
4. **Report** findings ranked by severity:

```
[S3] <short title> — <where: screen/component/file:line>
Principle: <law/heuristic>
Problem: <what the user experiences, concretely>
Fix: <specific change>
```

Severity: S4 blocks the task or loses data · S3 major friction or a frequent error · S2 minor · S1 cosmetic. Put the strengths that must be kept at the end, in one or two lines. Do not pad the report: five real findings beat twenty generic ones.

For every **S3/S4** finding, and any fix that changes layout or flow, add a **before → after** ASCII wireframe (see *Wireframes*). When findings become tickets, the wireframe goes into the ticket too, so the builder doesn't have to reconstruct the layout from prose.

## Wireframes

Use plain ASCII inside a code block so it renders in chat, Markdown and issue trackers. Keep it at low fidelity: show structure, order, the primary action and the copy that matters; leave out styling.

- **Screen:** a box at the target width (≈36 chars for mobile, ≈72 for desktop). Mark the fold with `┄┄ fold ┄┄` when position matters, show the primary action as `[ Action ]` and secondary ones as `( action )`, and mark removed elements `~~like this~~` or with a `✕` note.
- **Flow:** `screen → screen` steps on one line, with the trigger on the arrow when it isn't obvious (`scan QR → login → [OTP] → name+confirm → ✓ done`). Count the steps before and after.
- One wireframe per decision. Don't draw screens that don't change.

## DECIDE — choose between options

1. **Restate** the options and the decision criteria: primary task, user type, frequency, stakes, platform, and constraints (time, engineering cost).
2. **Name the trade-off** each option makes, in terms of the laws. Examples: fewer choices against more hidden functionality (Hick vs. discoverability); convention against differentiation (Jakob); simplicity for the user against effort for the product (Tesler).
3. **Score** each option against the criteria in a compact table, giving reasons, not just numbers.
4. **Recommend one option.** State what would change your mind, and the cheapest way to validate the choice (first-click test, 5-user test, A/B, analytics).

## Rules

- Conventions and thresholds (44pt targets, 400ms, 4±1 chunks) are design targets, not physics. Say so when a decision depends on one.
- Accessibility is part of every mode. That means keyboard access, focus, contrast, never color alone, reduced motion, and labels.
- Prefer undo over "Are you sure?" Keep confirmation for actions that are both destructive and irreversible.
- When a recommendation conflicts with an existing design system or `DESIGN.md`, follow the system and flag the conflict.
- Match the user's language in the output. Keep the law names in English.
rea-analysis-optimizationmorluto/reaOptimize REA providers and shared analysis workflows for agent context, latency, CPU, and memory while preserving correctness and Evidence. Use for analysis bottlenecks and cache or query design; CI/test-suite optimization belongs to rea-ci-tests-audit.Stars: 472kUpdated Claude CodeCodexVerifiedInstall
rea-ci-tests-auditmorluto/reaAudit REA CI and test suites for correctness, fixture drift, false passes, and measured performance; use for suite or workflow investigations and efficiency changes, rather than ordinary feature testing or a single test failure.Stars: 472kUpdated Claude CodeCodexVerifiedInstall
rea-tool-designmorluto/reaAudit, investigate, design, or change REA investigation tools, CLI/MCP contracts, provider capabilities, and Evidence semantics.Stars: 472kUpdated Claude CodeCodexVerifiedInstall
ponytail-auditDietrichGebert/ponytailQuality audit of the whole repo: bugs, security, real load, missing tests, speed, and what to delete. Most important first.Stars: 194kUpdated Claude CodeCodexVerifiedInstall