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
- BagelHole/BagelSkillstheir own version, first seen Nov 8, 2026
Other versions1 project uses a version of this.
Word for word · 0
None found.
Edited · 0
None found.
Wrote their own version · 1
- BagelHole/BagelSkills★ 2same name
How matches are found. Word for word: the exact same text. Edited: shares passages with this file (“99% same” means 99% of its five-word phrases also appear here; 10% or more counts). Their own version: similar meaning, or, weakest, the same name. We can’t tell which project had it first. Projects are counted among the 200 most-starred candidates, and mentions are links to the repository we found, up to 50 per site, so both counts are a floor.
In this repository49 other files it gives its agents.
- accessibility-auditorSkill
- api-doctorSkill
- browser-compatibilitySkill
- build-doctorSkill
- bundle-doctorSkill
- cache-doctorSkill
- change-cartographerSkill
- ci-cd-doctorSkill
- code-auditorSkill
- code-migratorSkill
- code-reviewerSkill
- config-doctorSkill
- container-doctorSkill
- context-keeperSkill
- contract-testerSkill
- cron-doctorSkill
- database-doctorSkill
- decision-memorySkill
- dependency-doctorSkill
- documentation-engineerSkill
- env-guardSkill
- error-boundary-doctorSkill
- feature-integritySkill
- git-hygieneSkill
- handoff-engineerSkill
- i18n-auditorSkill
- incident-debuggerSkill
- intent-architectSkill
- log-doctorSkill
- motion-designerSkill
- observability-engineerSkill
- performance-optimizerSkill
- product-architectSkill
- project-driftSkill
- qa-engineerSkill
- refactor-engineerSkill
- release-notesSkill
- runtime-doctorSkill
- safe-scopeSkill
- security-auditorSkill
- seo-doctorSkill
- ship-itSkill
- skill-managerSkill
- spec-doctorSkill
- state-managerSkill
- terminal-visualizerSkill
- test-engineerSkill
- type-safety-auditorSkill
- ui-redesignSkill
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
- Distinctive: line 27
Before a launch or demo, to catch usability issues.
- Distinctive: line 34
Before simulating journeys, understand what the app does:
- Distinctive: line 42
Read the actual code, routes, and components — not just the README.
- Distinctive: line 46
Create 4–6 realistic user journeys to simulate:
- Distinctive: line 57
Do not simulate journeys the app does not support.
≈ “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.
Files
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:
| Persona | Description | Journey |
| First-time user | Never seen the app before | Landing → Sign up → First action |
| Returning user | Knows the app, has data | Login → Find previous work → Continue |
| Mobile user | On a phone, small screen, touch | Navigate → Complete primary task |
| Keyboard user | No mouse, tabbing through UI | Tab through → Complete primary task |
| Error-recovery user | Made a mistake, needs to recover | Make error → Try to fix it |
| Speed-run user | Knows exactly what they want | Fastest 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:
- Step — what the user does (clicks, types, navigates).
- User expectation — what they expect to happen.
- Actual behavior — what the code actually does.
- Friction — where expectation and reality diverge.
- Impact — how this affects the user's experience.
- 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 itemProvide 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 RecommendationsGuardrails: 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.
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
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.

