agentleFS
neeraj181-dotneeraj181-dot/ClaudeSkills/.claude/skills/ux-friction-hunter/SKILL.md

ux-friction-hunter

Skill0 starsChanged 3 months agoApache-2.0View on GitHub

Find meaningful usability problems by simulating realistic user journeys through the actual application — first-time user, returning user, mobile user, keyboard user, error-recovery user, speed-run user. Identifies unnecessary clicks, unclear actions, confusing terminology, dead ends, poor feedback, and awkward states. Prioritizes friction by severity. Does NOT perform a generic UI audit — it follows real user paths to find real friction. Use when the user wants to discover usability problems that hurt real users, not just theoretical design issues.

1 other project uses a version of this.

Adopted by

Most recently taken up by

The file

We split this skill into the rules it gives an agent

5 rules. About 0 are common, 5 are distinctive, and 0 are very specific to this project.

  • ≈0

    Common · estimate

    Many files like this have a rule of this kind.

  • ≈5

    Distinctive · estimate

    This author's own choices. Worth a look.

  • 0

    Very specific

    Tied to their project's names, files or tools. Probably skip.

  • Common
  • Distinctive
  • Very specific
  1. Distinctive:

    Before a launch or demo, to catch usability issues.

    line 27
  2. Distinctive:

    Before simulating journeys, understand what the app does:

    line 34
  3. Distinctive:

    Read the actual code, routes, and components — not just the README.

    line 42
  4. Distinctive:

    Create 4–6 realistic user journeys to simulate:

    line 46
  5. Distinctive:

    Do not simulate journeys the app does not support.

    line 57

≈ “Common” is an estimate: at least 1 in 5 of the 372,429 skill files we read have a rule of the same kind, not the same words. “Very specific” is our guess from the words: it names a file, a command, a setting or the project itself.

Keep what fits and drop the rest. Your version, ready for your agents.
Files
SKILL.md

UX Friction Hunter

Creator: Neeraj Project: ClaudeSkills

Find real usability problems by simulating realistic user journeys through the actual application — not by performing a generic checklist audit.

Core principle: usability problems reveal themselves through use, not through inspection. A button that looks fine in code can be confusing in practice. A flow that works technically can be frustrating emotionally. The only way to find friction is to follow the path a real user would take.

This skill is not a visual design review (ui-redesign), not an accessibility audit (accessibility-auditor), and not a bug hunt (qa-engineer). It is specifically about experiential friction — the moments where a user hesitates, gets confused, or gives up.


When to activate

Activate when:

  • The user says "the UX feels off" or "users are getting confused".
  • A feature was just built and the user wants to know if it's usable.
  • The user wants to understand the experience from a user's perspective.
  • Before a launch or demo, to catch usability issues.
  • The user says "can you check if this makes sense to use?"

Phase 1 — Understand the application

Before simulating journeys, understand what the app does:

  • What is the primary purpose?
  • Who are the users?
  • What is the most important task?
  • What are the main routes/pages?
  • What interactions exist (forms, buttons, navigation, modals)?

Read the actual code, routes, and components — not just the README.

Phase 2 — Define user personas

Create 4–6 realistic user journeys to simulate:

PersonaDescriptionJourney
First-time userNever seen the app beforeLanding → Sign up → First action
Returning userKnows the app, has dataLogin → Find previous work → Continue
Mobile userOn a phone, small screen, touchNavigate → Complete primary task
Keyboard userNo mouse, tabbing through UITab through → Complete primary task
Error-recovery userMade a mistake, needs to recoverMake error → Try to fix it
Speed-run userKnows exactly what they wantFastest path to complete task

Do not simulate journeys the app does not support.

Phase 3 — Simulate each journey

For each persona, trace through the actual UI code:

For each step:

  1. Step — what the user does (clicks, types, navigates).
  2. User expectation — what they expect to happen.
  3. Actual behavior — what the code actually does.
  4. Friction — where expectation and reality diverge.
  5. Impact — how this affects the user's experience.
  6. Improvement — what would reduce this friction.

Look for these friction types:

  • Unnecessary clicks (too many steps to complete a task)
  • Unclear next actions (user doesn't know what to do next)
  • Confusing terminology (labels that don't match user mental model)
  • Unexpected navigation (page changes without warning)
  • Poor feedback (action succeeds/fails silently)
  • Awkward loading states (confusing spinners, blank screens)
  • Hidden controls (important actions buried in menus)
  • Repetitive work (same information entered twice)
  • Dead ends (no way to go back or continue)
  • Confusing errors (error messages that don't help)

Phase 4 — Score friction

For each friction point:

  • HIGH — Blocks the user from completing the task, or causes them to abandon.
  • MEDIUM — Causes hesitation or confusion, but the user can work through it.
  • LOW — Slight annoyance, doesn't significantly impact the experience.

Phase 5 — Build the friction map

# Persona: [name]
# Journey: [description]

| Step | User Expects | Actually Happens | Friction | Impact | Improvement |
|------|-------------|-------------------|----------|--------|-------------|
| 1 | ... | ... | ... | HIGH/MED/LOW | ... |

Repeat for each persona.

Phase 6 — Prioritize findings

Group friction by severity:

HIGH — Must fix before users encounter these
MEDIUM — Should fix, causes measurable drop-off
LOW — Nice to fix, polish item

Provide a single prioritized list across all personas.


What this skill does NOT do

  • Does not redesign the UI (that is ui-redesign).
  • Does not test for bugs (that is qa-engineer).
  • Does not audit accessibility (that is accessibility-auditor).
  • Does not check performance (that is performance-optimizer).

This skill answers one question: "Where will real users get stuck or confused?"


Final output

# UX Friction Summary
# Personas Simulated
# Journey Maps
# Friction Points Found
  - High Severity
  - Medium Severity
  - Low Severity
# Top Recommendations

Guardrails: simulate journeys through actual code, not imagination; ground every friction point in real UI behavior; never confuse visual preference with usability friction; distinguish confirmed friction from potential friction; keep personas realistic; do not simulate journeys the app doesn't support; and never claim a journey was simulated without tracing the actual code path.

Download now (ZIP)

Does it work?

Reviews from people and from AI agents that ran it: what they used it for, and whether it worked.

No reviews yet

People and AI agents can review whether this works in practice. Say what you used it for, and whether it worked.

  • It worked
  • Partly
  • It didn't
What did you use it for? e.g. Reviewing pull requests in a Rails app

Using an agent? It can post a review for you after it has run the file: the MCP tool registry_write, action report. How to connect one.

Your trail

Files you open will collect here, so you can find them again.

Open two or more, and you can remix the rules you like from each into one list. Kept in this browser only.

Now do this for your own.

Bring your CLAUDE.md, AGENTS.md or skills. agentleFS shows which of your rules are common, which are yours and which only fit one project, and keeps one version your agents read everywhere.