clutch
A Claude Code plugin for ADHD

Not a gift. Not a deficit. A different transmission.

It catches the stall the moment it happens and hands you one small move. It banks the idea that pulled you away and turns it into fuel for later sessions. Both halves are built on the ADHD research, not productivity folklore.

ADHD is a performance disorder, not a knowledge one. You already know the next step. Clutch works at the point of performance, in your editor, whether or not your attention showed up. It gets your existing intent to the wheels.

How it works

Five hooks, fired at fixed moments of a session.

Clutch is five hooks and a set of commands. The hooks fire while you can still act, because the effect degrades with distance from that moment (Barkley). What they say is recognition. Uninvited lines are capped at two a session; the one ask before a destructive git command and the session-start question sit outside that cap.

Two layers watch where a stall shows up: your git state, and what you are saying. When the read is unclear, nothing happens. Silence is the default state, and a wrong nudge costs more than a missed one. Each step below shows what the hook hands the model, and what you see.

  1. Start

    You open a project cold. It greets you with your thread, the last landed commit, and the one file to pick back up. On a fresh session with no gear set, one question.

    fired:
    SessionStart (startup, resume, clear, compact, fork) → anchor.sh
    writes:
    .clutch/session-state on a fresh session

    Why: the gap opens at the point of performance, so the thread comes back before you have to rebuild it, and the re-orientation tax is gone.

    session start · anchor.sh
    hook → model (the constitution, then) Worklog: web moved: landed 'auth tests run on CI' Thread: on main; last landed 'parser runs clean'; 2 modified; most recent: src/parser.py Last landed: 'parser runs clean' Captures held: 2. Smallest move to resume: finish or bank the change in src/parser.py. Intent for this session: build, ideate, ops, or review? /clutch:intent sets the frame. you see clutch Back on main. Last landed 'parser runs clean'; pick up src/parser.py. Build, ideate, ops, or review?
  2. Stall

    You say "I don't know where to start," or you circle the same two options for three turns without editing anything. One smallest next move. Never a list.

    fired:
    UserPromptSubmit, every prompt → heartbeat.sh
    writes:
    nothing

    Why: a nag lays a brick that raises tomorrow's wall (Mahan), so it fires on zero movement, never on slowness, and the heartbeat keeps that read alive through a long session.

    every prompt · heartbeat.sh
    hook → model clutch dispatch spine (…): spoken stall -> smallest-move; … explicit timebox -> sprint; … TERMINAL: anything else, or no established focus -> SILENCE. clutch-budget: 0/2 spent. you see you I don't know where to start. clutch Smallest move: write the one failing test for empty input. you /clutch:sprint clutch Twenty minutes, one shippable: the empty-input test.
  3. Catch

    A test goes red twice with nothing edited, and you reach for git reset --hard. One beat lands in the way. Your yes wins in one keypress.

    fired:
    PostToolUse and PostToolUseFailure(Bash) → red-moment.sh; PreToolUse(Bash) → hot-pause.sh
    writes:
    .clutch/session-state (the repeat-red record); the pause writes nothing

    Why: the red is a heat spike, not a verdict, and the smaller move is to bank what still works before you burn it.

    shell command · red-moment.sh, hot-pause.sh
    hook → model clutch red-moment: a runner just failed again on the same target with nothing edited since the last failure. … If unsure, stay silent, a miss is free. you see clutch Make just the empty-input case pass, or bank what works with one commit. you git reset --hard ask Hot action. One beat: if this follows a red result, the heat is a spike, not a verdict, and the smaller move is banking what still works first. Your call either way.
  4. Turn end

    Every turn leaves a breadcrumb. After 25 minutes and real movement, the bell names what landed. It never counts days and never mentions a streak.

    fired:
    Stop → stop.sh
    writes:
    .clutch/breadcrumb, and one moved: line in ~/.clutch/worklog.md when the turn landed a commit

    Why: recognition after real movement is fuel, and capping it at two lines a session keeps it from turning into a nag.

    turn end · stop.sh
    hook → model (nothing; the breadcrumb is saved for the next start) .clutch/breadcrumb: on main; last landed 'parser handles empty input'; 0 modified you see Landed: 'parser handles empty input'. Smallest next move: one commit. a live sprint shows this instead: Sprint: 6 min left on 'the empty-input test'
  5. Worklog

    Run two sessions at once, or come back after a compaction, and each one learns what the others did. A landed commit logs itself; the model adds an on: claim when it starts work a parallel session might take. Claims age out after 4 h and moves after 24 h.

    fired:
    Stop → stop.sh appends; SessionStart → anchor.sh reads
    writes:
    ~/.clutch/worklog.md, one short line per moved: note or on: claim

    Why: it is not live, so a session sees a peer's line at its next start, clear, compaction or fork, or in an ops sweep, and the block is context for the model, never a list for you.

    another repo, next start · anchor.sh
    hook → model Worklog: api moved: landed 'parser handles empty input' api on: rewriting the retry policy claims kept 4 h, moves 24 h, at most eight lines you see you /clutch:ops clutch Swept. Three loops open; the retry policy is held by another session, so it stays out.

The catch may reach first. The spark only answers.

When the read is clear, the catch side may step in on its own: one smallest move, an igniter, the triage question, or a one-line bank of a tangent through /clutch:fomo, which banks only and never reports back. Apart from that silent bank, divergence, the focuses and the upkeep commands wait until you fire them.

Four focuses

One question, the only one of the day.

A fresh session opens with it: build, ideate, ops, or review? Ignoring it is also an answer, and it never asks twice. /clutch:intent takes the answer and engages the matching gear.

Build

/clutch:intent

A maker session in the craft gear: explore, then commit. The catch commands are at hand: one smallest move, a sprint, an igniter, a triage, a retrace.

Ideate

/clutch:ideate

The whole session in divergent mode: it loads the pool, engages ballmer (fast divergence with periodic convergence checkpoints), and holds anti-convergence until you land it.

/clutch:spark · anchor: what if the parser streamed? hop: a stream is a log you can replay trace-back: streamed parser → replayable input log · banked

Ops

/clutch:ops

For the day that is meetings, people, and threads rather than a repo: one sweep of the tools you named, the situation in a few lines, then one loop closed at a time, each outward step on a yes. Work another session holds stays out of the sweep.

Review

/clutch:review

Closes one PR at a time with your written conventions applied. When your call on a finding implies a rule, one line offers it as a convention, written on a yes. Each post goes out on a yes.

/clutch:tempo hands you the gearbox directly: five gears, espresso, craft, ballmer, freefall, ferment, set or reported.

Where state lives

Your repo grows a memory.

An idea yanks you sideways mid-task. /clutch:fomo banks it in one line and you are back, nothing lost, while a background pass reads it. A sprint's deflected ideas bank through the same door. When you sit down to explore, the banked lines are the anchors, and a /clutch:retrace hands back the ones from its window.

  1. The pool.A local .clutch/ folder your repo owns: captures, cross-references, spark logs, idea files, the session clock and the breadcrumb. Clutch adds it to git's ignore list. Pool writes stay repo-scoped by design.
  2. The brain.Keep a ~/.clutch folder and it becomes the brain, the second pool level every reader sweeps, across all your repos. No pool item enters it ambiently: one door up, the absorb verdict in /clutch:fomo. The idea a work session almost lost feeds a family-project spark next week.
  3. The worklog.~/.clutch/worklog.md, one short line per moved: note or on: claim, shared by every session in every repo.

The assistant's own auto-memory directory is a different brain, and it gets maintenance too: /clutch:dream consolidates it and prunes the index, and /clutch:interview asks a short batch of questions about its thin spots.

Commands at a glance

Twenty commands, same heartbeat, opposite directions.

The catch side meets you when work stops moving. The spark side banks what pulls you and hands it back as ignition. The rest set the session's focus, run the day, and check on clutch.

CommandWhat it doesUse it when
Catch
/clutch:smallest-moveNames one move you can finish in one sitting, as an ignorable lineYou cannot see where to start
/clutch:sprintA fixed 20 minutes on one minimal shippable; deflected ideas bankYou want a timebox
/clutch:igniteRecasts work you already understand as a speed-runYou dread the boring plumbing
/clutch:triageAsks the one question that separates a wall from forgettingA task did not happen and you do not know why
/clutch:retraceRebuilds a blurred session from git and the poolYou lost track of what you built
Spark
/clutch:fomoBanks a link or a thought in one line; a background pass reads it and returns absorb, park, or releaseA tab you cannot close, or an idea mid-task
/clutch:sparkA chain reaction: one anchor, ping-pong hops, a trace-back at the endYou sit down to explore
/clutch:daydreamRuns a few associative hops in the background and banks themA connection whispers while you work
/clutch:dream-sparkCross-references everything the pool holdsYou want what connects that nobody is watching
Focus and day
/clutch:intentDeclares the session's focus and engages the gearThe session-start question, or a change of plan
/clutch:ideateDivergent mode for the whole sessionAn ideate session
/clutch:opsOperations mode: one sweep, one loop at a timeA day of meetings, people, and threads
/clutch:reviewReview mode: one PR at a time, your conventions appliedA review session
/clutch:tempoSets or reports the gear: espresso, craft, ballmer, freefall, fermentYou want the gearbox itself
/clutch:morningOpens the day: focus check, deep ping, one divergent beat, one quick win, the first moveThe start of your day
/clutch:eodCloses the day: a mini-retro without shame, tomorrow's focuses, one fun slotThe end of your day
/clutch:ritualsAsks for your day's facts once and writes ~/.clutch/rituals.mdBefore the first morning, or when your days change
Upkeep
/clutch:statusReports whether the hooks are alive in this repo and sessionRight after install, or when the bell seems silent
/clutch:dreamConsolidates the auto-memory brain and prunes its indexThat brain has grown long or stale
/clutch:interviewAsks one batch of questions about that brain's thin spotsYou want the gaps filled

Ignite is not spark. Ignite recasts dread as a challenge; spark runs divergence. The day anchors fire when you fire them, at whatever anchor time your ~/.clutch/rituals.md names.

The research

Seven sources, a citations file, a quarantine list.

The wording carries seven digested sources of ADHD research: Barkley, Brown, Dodson, Mahan, Hallowell. Each has a hand-assigned weight and an annotated place in the argument. Nothing reads the corpus at runtime. The judgment is baked into fixed wording and constants.

The quarantine list is the part most tools skip. Ego depletion, the idea that willpower is a fuel tank you refill with glucose and breaks, is in the canon and kept out of the product. It is a replication-crisis casualty, and a fuel model inside a performance frame contradicts both Barkley and this tool.

The numbers: twenty commands, five hooks, a seven-source canon. Built with AI assistance, by an engineer with ADHD, tested on himself in public.

Safe on a work repo

Install it on a work repo without a second thought.

Carries nothing personal. Reads your git state, its own .clutch/ folder, your ~/.clutch brain if you keep one, and the conversation in front of it. Some commands read more, and only when you fire them.
Writes the local .clutch/ folder, plus your brain on an absorb verdict, and adds the local folder to git's ignore list.
Sessions append one-line notes of what moved to ~/.clutch/worklog.md, so parallel sessions can see each other. It is the one thing sessions write to ~/.clutch without a command or a verdict. The log is global: its lines, commit subjects and repo names included, reach sessions in every repo, a work repo included. If you keep no ~/.clutch yet, the first note creates it, and that folder is the brain: from then on an absorb verdict in /clutch:fomo files ideas there, and sessions in every repo read them. Every other write comes from a command you fire.
A brain entry banked at home surfaces in whatever repo you run these skills in, a work repo included. Whether that is fine is your call.
Some commands reach out: /clutch:fomo fetches a banked link, a spark, daydream, dream-spark, or ideate pass may run a web search, and ops and morning check the integrations you named. But only when you invoke them; nothing touches the network on its own.
Read-mostly and fails open, so it composes underneath stricter guardrails: the strictest rule wins.
Install

Two commands. Zero configuration.

Claude Code
/plugin marketplace add yuvalraz/clutch
/plugin install clutch@clutch

No settings, no env vars. The opinions are the product. One optional file, written by /clutch:rituals, holds your day's facts. Source at github.com/yuvalraz/clutch.