Skip to main content
skill CX Codex

click-path-audit — Claude Code skill: trace conflicting state resets

click-path-audit — a skill for Claude Code and Codex that audits user-facing touchpoints. Traces sequential state mutations to uncover silent side effects and conflicting resets across UI handlers.

MIT 6,200 installs ★ 308,413 updated 2026-10-20

Install into Claude Code · Skills CLI (Vercel) All methods and platforms ↓
npx skills add affaan-m/ECC --skill click-path-audit -a claude-code
Open on GitHub

What click-path-audit does

The audit inspects button clicks, form submissions, and toggle handlers by mapping their complete execution path. It starts by cataloging state stores, such as Zustand or React context, noting every setter along with the fields it clears. This map exposes dangerous actions that reset state variables owned by other parts of the application.

Next, the skill evaluates each handler against six concrete failure patterns. It spots race conditions between unresolved promises, stale closures, conflicting useEffect hooks, and immediate resets caused by sequential setter calls. Large codebases can split this workload across dedicated parallel agents assigned to specific sections.

What it helps with

  • diagnose buttons that do nothing despite zero runtime errors
  • catch unintended shared store resets after code refactoring
  • identify async race conditions in user action handlers
  • verify that final UI state matches the action promised by a control

Example prompts for the agent

  • Run click-path-audit on the new email button inside ThreadList.tsx
  • Audit all touchpoints on the projects page to find broken state transitions
  • Use click-path-audit to inspect store actions modified in emailStore

How to install click-path-audit

1Skills CLI (Vercel)

npx skills add affaan-m/ECC --skill click-path-audit -a claude-code

2Manually: put the files in place

~/.claude/skills/click-path-audit/SKILL.md

Copy the whole skill folder; for one project use .claude/skills/click-path-audit/

Step by step, with commands for each platform: How to install skills in Claude Code: five ways

Questions about click-path-audit

How to install click-path-audit in Claude Code?

Run npx skills add affaan-m/ECC --skill click-path-audit -a claude-code in your terminal.

What does click-path-audit do?

It traces interactive touchpoint handlers call by call to find state side effects that cancel previous actions.

When should click-path-audit be triggered?

Run it when standard debugging reports no failures yet buttons feel broken, or right after major updates to shared state stores.

Source text

SKILL.md · MIT
---
name: click-path-audit
description: "Trace every user-facing button/touchpoint through its full state change sequence to find bugs where functions individually work but cancel each other out, produce wrong final state, or leave the UI in an inconsistent state. Use when: systematic debugging found no bugs but users report broken buttons, or after any major refactor touching shared state stores."
metadata:
  origin: community
---

# /click-path-audit — Behavioural Flow Audit

Find bugs that static code reading misses: state interaction side effects, race conditions between sequential calls, and handlers that silently undo each other.

## The Problem This Solves

Traditional debugging checks:
- Does the function exist? (missing wiring)
- Does it crash? (runtime errors)
- Does it return the right type? (data flow)

But it does NOT check:
- **Does the final UI state match what the button label promises?**
- **Does function B silently undo what function A just did?**
- **Does shared state (Zustand/Redux/context) have side effects that cancel the intended action?**

Real example: A "New Email" button called `setComposeMode(true)` then `selectThread(null)`. Both worked individually. But `selectThread` had a side effect resetting `composeMode: false`. The button did nothing. 54 bugs were found by systematic debugging — this one was missed.

---

## How It Works

For EVERY interactive touchpoint in the target area:

```
1. IDENTIFY the handler (onClick, onSubmit, onChange, etc.)
2. TRACE every function call in the handler, IN ORDER
3. For EACH function call:
   a. What state does it READ?
   b. What state does it WRITE?
   c. Does it have SIDE EFFECTS on shared state?
   d. Does it reset/clear any state as a side effect?
4. CHECK: Does any later call UNDO a state change from an earlier call?
5. CHECK: Is the FINAL state what the user expects from the button label?
6. CHECK: Are there race conditions (async calls that resolve in wrong order)?
```

---

## Execution Steps

### Step 1: Map State Stores

Before auditing any touchpoint, build a side-effect map of every state store action:

```
For each Zustand store / React context in scope:
  For each action/setter:
    - What fields does it set?
    - Does it RESET other fields as a side effect?
    - Document: actionName → {sets: [...], resets: [...]}
```

This is the critical reference. The "New Email" bug was invisible without knowing that `selectThread` resets `composeMode`.

**Output format:**
```
STORE: emailStore
  setComposeMode(bool) → sets: {composeMode}
  selectThread(thread|null) → sets: {selectedThread, selectedThreadId, messages, drafts, selectedDraft, summary} RESETS: {composeMode: false, composeData: null, redraftOpen: false}
  setDraftGenerating(bool) → sets: {draftGenerating}
  ...

DANGEROUS RESETS (actions that clear state they don't own):
  selectThread → resets composeMode (owned by setComposeMode)
  reset → resets everything
```

### Step 2: Audit Each Touchpoint

For each button/toggle/form submit in the target area:

```
TOUCHPOINT: [Button label] in [Component:line]
  HANDLER: onClick → {
    call 1: functionA() → sets {X: true}
    call 2: functionB() → sets {Y: null} RESETS {X: false}  ← CONFLICT
  }
  EXPECTED: User sees [description of what button label promises]
  ACTUAL: X is false because functionB reset it
  VERDICT: BUG — [description]
```

**Check each of these bug patterns:**

#### Pattern 1: Sequential Undo
```
handler() {
  setState_A(true)     // sets X = true
  setState_B(null)     // side effect: resets X = false
}
// Result: X is false. First call was pointless.
```

#### Pattern 2: Async Race
```
handler() {
  fetchA().then(() => setState({ loading: false }))
  fetchB().then(() => setState({ loading: true }))
}
// Result: final loading state depends on which resolves first
```

#### Pattern 3: Stale Closure
```
const [count, setCount] = useState(0)
const handler = useCallback(() => {
  setCount(count + 1)  // captures stale count
  setCount(count + 1)  // same stale count — increments by 1, not 2
}, [count])
```

#### Pattern 4: Missing State Transition
```
// Button says "Save" but handler only validates, never actually saves
// Button says "Delete" but handler sets a flag without calling the API
// Button says "Send" but the API endpoint is removed/broken
```

#### Pattern 5: Conditional Dead Path
```
handler() {
  if (someState) {        // someState is ALWAYS false at this point
    doTheActualThing()    // never reached
  }
}
```

#### Pattern 6: useEffect Interference
```
// Button sets stateX = true
// A useEffect watches stateX and resets it to false
// User sees nothing happen
```

### Step 3: Report

For each bug found:

```
CLICK-PATH-NNN: [severity: CRITICAL/HIGH/MEDIUM/LOW]
  Touchpoint: [Button label] in [file:line]
  Pattern: [Sequential Undo / Async Race / Stale Closure / Missing Transition / Dead Path / useEffect Interference]
  Handler: [function name or inline]
  Trace:
    1. [call] → sets {field: value}
    2. [call] → RESETS {field: value}  ← CONFLICT
  Expected: [what user expects]
  Actual: [what actually happens]
  Fix: [specific fix]
```

---

## Scope Control

This audit is expensive. Scope it appropriately:

- **Full app audit:** Use when launching or after major refactor. Launch parallel agents per page.
- **Single page audit:** Use after building a new page or after a user reports a broken button.
- **Store-focused audit:** Use after modifying a Zustand store — audit all consumers of the changed actions.

### Recommended agent split for full app:

```
Agent 1: Map ALL state stores (Step 1) — this is shared context for all other agents
Agent 2: Dashboard (Tasks, Notes, Journal, Ideas)
Agent 3: Chat (DanteChatColumn, JustChatPage)
Agent 4: Emails (ThreadList, DraftArea, EmailsPage)
Agent 5: Projects (ProjectsPage, ProjectOverviewTab, NewProjectWizard)
Agent 6: CRM (all sub-tabs)
Agent 7: Profile, Settings, Vault, Notifications
Agent 8: Management Suite (all pages)
```

Agent 1 MUST complete first. Its output is input for all other agents.

---

## When to Use

- After systematic debugging finds "no bugs" but users report broken UI
- After modifying any Zustand store action (check all callers)
- After any refactor that touches shared state
- Before release, on critical user flows
- When a button "does nothing" — this is THE tool for that

## When NOT to Use

- For API-level bugs (wrong response shape, missing endpoint) — use systematic-debugging
- For styling/layout issues — visual inspection
- For performance issues — profiling tools

---

## Integration with Other Skills

- Run AFTER `/superpowers:systematic-debugging` (which finds the other 54 bug types)
- Run BEFORE `/superpowers:verification-before-completion` (which verifies fixes work)
- Feeds into `/superpowers:test-driven-development` — every bug found here should get a test

---

## Example: The Bug That Inspired This Skill

**ThreadList.tsx "New Email" button:**
```
onClick={() => {
  useEmailStore.getState().setComposeMode(true)   // ✓ sets composeMode = true
  useEmailStore.getState().selectThread(null)      // ✗ RESETS composeMode = false
}}
```

Store definition:
```
selectThread: (thread) => set({
  selectedThread: thread,
  selectedThreadId: thread?.id ?? null,
  messages: [],
  drafts: [],
  selectedDraft: null,
  summary: null,
  composeMode: false,     // ← THIS silent reset killed the button
  composeData: null,
  redraftOpen: false,
})
```

**Systematic debugging missed it** because:
- The button has an onClick handler (not dead)
- Both functions exist (no missing wiring)
- Neither function crashes (no runtime error)
- The data types are correct (no type mismatch)

**Click-path audit catches it** because:
- Step 1 maps `selectThread` resets `composeMode`
- Step 2 traces the handler: call 1 sets true, call 2 resets false
- Verdict: Sequential Undo — final state contradicts button intent

© affaan-m · MIT · affaan-m/ECC

Similar skills

All skills for Frontend and UI →

From the same set150

The whole set →
data-scraper-agent The data-scraper-agent skill walks you through building an agent that scrapes public sources on a schedule, enriches results with Gemini Flash, and stores them in Notion, Sheets or Supabase. CX Codex +1 6,300installs compose-multiplatform-patterns compose-multiplatform-patterns is a skill that guides shared UI design for Compose Multiplatform and Jetpack Compose in KMP projects, covering state, navigation, theming, and platform-specific UI. CX Codex +1 6,300installs hipaa-compliance The skill runs in Claude Code and other platforms, handling HIPAA compliance tasks and PHI security workflows in software. CX Codex +1 6,200installs regex-vs-llm-structured-text The regex-vs-llm-structured-text Claude Code skill helps choose an extraction method for structured text. It starts with regex for repeated patterns and sends uncertain results to an LLM for review. CX Codex +1 6,200installs homelab-wireguard-vpn The homelab-wireguard-vpn Claude Code skill guides WireGuard setup for remote access to a home network. It covers server and client configuration, key generation, and the choice between split and full tunnel routing. CX Codex +1 6,200installs healthcare-emr-patterns healthcare-emr-patterns is a Claude Code skill that defines EMR and EHR development patterns focused on patient safety, encounter workflows, and medication checks. CX Codex +1 6,200installs skill-comply skill-comply is a Claude Code skill that tests whether agents follow skills, rules, and agent definitions. Run it after changing an instruction file or as part of recurring compliance checks. CX Codex +1 6,200installs terminal-ops terminal-ops — a repo execution skill: runs commands, reads git state, debugs CI failures and makes narrow fixes with proof of what was actually verified. CX Codex +1 6,200installs

Project sponsors

Companies that keep this analytics open