Friction Audit

Audit user-facing flows for unnecessary friction. Produces a friction report with scored findings and actionable fixes. Use this skill before launch readiness checks, after major UX changes, or when user drop-off is suspected.

5 stars

Best use case

Friction Audit is best used when you need a repeatable AI agent workflow instead of a one-off prompt.

Audit user-facing flows for unnecessary friction. Produces a friction report with scored findings and actionable fixes. Use this skill before launch readiness checks, after major UX changes, or when user drop-off is suspected.

Teams using Friction Audit should expect a more consistent output, faster repeated execution, less prompt rewriting.

When to use this skill

  • You want a reusable workflow that can be run more than once with consistent structure.

When not to use this skill

  • You only need a quick one-off answer and do not need a reusable workflow.
  • You cannot install or maintain the underlying files, dependencies, or repository context.

Installation

Claude Code / Cursor / Codex

$curl -o ~/.claude/skills/friction-audit/SKILL.md --create-dirs "https://raw.githubusercontent.com/BasharAmso/Bashi/main/.claude/skills/friction-audit/SKILL.md"

Manual Installation

  1. Download SKILL.md from GitHub
  2. Place it in .claude/skills/friction-audit/SKILL.md inside your project
  3. Restart your AI agent — it will auto-discover the skill

How Friction Audit Compares

Feature / AgentFriction AuditStandard Approach
Platform SupportNot specifiedLimited / Varies
Context Awareness High Baseline
Installation ComplexityUnknownN/A

Frequently Asked Questions

What does this skill do?

Audit user-facing flows for unnecessary friction. Produces a friction report with scored findings and actionable fixes. Use this skill before launch readiness checks, after major UX changes, or when user drop-off is suspected.

Where can I find the source code?

You can find the source code on GitHub using the link provided at the top of the page.

SKILL.md Source

# Friction Audit

> Audit user-facing flows for unnecessary friction. Produces a friction report with scored findings and actionable fixes.

## When to Use

- Explicitly via `/trigger FRICTION_AUDIT_REQUESTED`
- Automatically referenced by other skills (Frontend Dev, Code Review, UAT, Growth, Mobile Dev) when working on user-facing tasks
- Before launch readiness checks
- After major UX changes

## Inputs

| Input | Source | Required |
|-------|--------|----------|
| Target flows | User specifies, or auto-detect from recent tasks | Yes |
| Friction Audit Checklist | `.claude/skills/friction-audit/CHECKLIST.md` | Yes |
| Project source files | `src/`, `docs/`, UI components | Yes |

## Procedure

### Step 1: Identify User-Facing Flows

1. If the user specified flows: use those.
2. If not: scan recent completed tasks and files modified for UI components, pages, forms, and onboarding flows.
3. List all flows to audit (e.g., "signup flow", "checkout", "settings page").

### Step 2: Run Checklist Against Each Flow

For each identified flow, evaluate every item in the Friction Audit Checklist (`CHECKLIST.md`):

- **Core Questions** (5 items) — always evaluate
- **Interaction Friction** (6 items) — evaluate if flow has UI
- **Onboarding Friction** (4 items) — evaluate if flow involves new users
- **Cognitive Friction** (4 items) — always evaluate

Score each item: Pass / Fail / N/A

### Step 3: Calculate Friction Score

```
Friction Score = (items passed / items evaluated) * 100
```

| Score | Rating |
|-------|--------|
| 90-100% | Low friction — ready to ship |
| 70-89% | Moderate friction — fix before launch |
| Below 70% | High friction — needs redesign |

### Step 4: Generate Report

Write findings to the Execution Summary (not a separate file unless the user requests it):

```
## Friction Audit Report

- **Flows audited:** [count]
- **Overall score:** [X]% ([rating])
- **Items passed:** [N] of [M]

### Findings

| Flow | Score | Top Issues |
|------|-------|------------|
| [flow name] | [X]% | [top 2-3 friction points] |

### Recommended Fixes (Priority Order)

1. [Most impactful fix — what to change and why]
2. [Second fix]
3. [Third fix]
```

### Step 5: Log Friction Findings

If any flow scores below 70%, log to the Execution Summary:
```
Friction check: [N] flows audited, [M] flagged (scores below 70%)
```

## Definition of Done

- [ ] All user-facing flows identified and audited
- [ ] Each flow scored against the full checklist
- [ ] Findings reported with actionable fixes
- [ ] No flow scores below 70% without a documented fix plan

## Output Contract

| Field | Value |
|-------|-------|
| **Artifacts** | Friction Audit Report (in Execution Summary or standalone file if requested) |
| **State Update** | `.claude/project/STATE.md` — mark task complete, log friction scores |
| **Handoff Event** | `TASK_COMPLETED` (friction audit complete) |

Related Skills

Supply Chain Audit

5
from BasharAmso/Bashi

Audit the dependency supply chain for security risks beyond what `npm audit` or `pip audit` catches. Analyzes dependency health, maintainer trust signals, typosquatting risk, and transitive dependency exposure.

SEO Audit

5
from BasharAmso/Bashi

Audit web pages for search engine optimization: meta tags, heading hierarchy, structured data, image optimization, mobile-friendliness, and content quality. Complements SKL-0013 (Growth & Distribution) by validating what was built.

Token Audit

5
from BasharAmso/Bashi

Audit the current project for token waste patterns. Produces a Token Health Report with scored findings and actionable fixes. Use this skill when token usage feels high, sessions are hitting limits, or before optimizing costs.

Security Audit

5
from BasharAmso/Bashi

Audit code and dependencies for security vulnerabilities. Use this skill when a security review is requested, including OWASP checks, secrets scanning, and dependency audits.

Pitch Deck

5
from BasharAmso/Bashi

Create a structured pitch deck outline for investors, stakeholders, or partners. Covers problem, solution, market, traction, team, and ask. Natural output after PRD + Problem Stress Test validation.

Launch Checklist

5
from BasharAmso/Bashi

Pre-launch validation covering everything deployment (SKL-0021) doesn't: analytics, error tracking, social meta, legal pages, email setup, DNS, SSL, and go-live readiness. Produces a launch readiness report with pass/fail checklist. Use this skill before going live on any project.

Insecure Defaults Detection

5
from BasharAmso/Bashi

Detect insecure default configurations, hardcoded credentials, fail-open security patterns, and dangerous default values in application code and configuration files. Complements SKL-0015 (Security Audit) by focusing on configuration-level vulnerabilities that dependency scanners miss.

Differential Security Review

5
from BasharAmso/Bashi

Security-focused review of code changes using git diff analysis. Identifies security implications of recent modifications — new attack surfaces, removed protections, changed auth logic, and risky refactors. Complements SKL-0016 (Code Review) with a security lens on diffs.

Copywriting

5
from BasharAmso/Bashi

Write conversion-focused copy using proven frameworks (AIDA, PAS, BAB). Produces headlines, CTAs, landing page copy, email sequences, and micro-copy. Ensures copy matches brand voice and target audience.

Competitor Analysis

5
from BasharAmso/Bashi

Structured competitor research: features, pricing, positioning, gaps, and differentiation strategy. Feeds into PRD Writing (SKL-0004) and Problem Stress Test (SKL-0027) with better market context.

UX Design

5
from BasharAmso/Bashi

Design user experiences including wireframes, flows, and interaction patterns. Use this skill when UX design work is requested, including onboarding flows and interface layouts.

User Acceptance Testing

5
from BasharAmso/Bashi

Structured QA testing with four modes: diff-aware (auto-scoped to branch changes), full (systematic exploration), quick (30-second smoke test), and regression (compare against baseline). Produces health score, structured reports, and actionable bug lists. Use this skill when UAT is requested or a feature is ready for acceptance testing.