flows

Plugin flows from marketplace dead-claude-skills in deadmade/dead-claude-skills. Commands read from the repo's manifest — 11 days ago.

Skills (14)

• doc-audit

  Check that the docs tell the truth about the code: every claim in READMEs, docs/, CLAUDE.md and manifest descriptions held against the code (contradicted, unbacked, undocumented), commands, paths, links and versions checked, changed prose edited, then one ranked report and fixes for the findings you

• feature-flow

  Build a feature through the whole skill chain: ground in the code and in how other projects solve it, brainstorm with options, grill the spec with domain docs and ADRs, write the plan, evaluate it adversarially, then execute, verify and finish. Two approval gates, no lock. Use for /feature-flow <wha

• fix-flow

  Fix a bug from symptom to verified branch: reproduce it, map where it lives and what a fix could break, search upstream for the same issue, find the root cause with systematic debugging, approve it, write the failing regression test first, fix, then /verify and /learn. Resumable. Use for /fix-flow <

• harden

  Find what makes the code fragile: security holes (with per-domain checklists for AI/MCP, supply chain, cloud, IPC and more), footgun APIs and dangerous defaults, bloat and dead code, and shallow modules worth deepening, from five passes run in parallel, merged into one ranked report, then fixes for

• implement

  Build from a plan, spec or ticket that already exists, without the design phases of /feature-flow: turn a spec into tickets or a plan if needed, approve the plan, execute it test-first through superpowers, then /verify and /learn. One approval gate, resumable. Use for /implement <path to plan, spec

• integrate

  Take a verified branch to a PR: show and make the commits, write the PR title and body for your approval, hand you the push and gh lines to run yourself, then watch the CI checks and stop with cause and options on a red one. Never pushes, never runs a gh command that writes, never fixes CI by pushin

• learn

  Keep what a piece of work taught, so the next session starts smarter: collect the surprises, decisions and root causes from a flow or the current session, sort each to its home (CLAUDE.md, GLOSSARY.md, an ADR, docs/solutions/, a skill, or memory), and write the ones you pick. The last step of every

• research-flow

  Build a feature on scientific evidence: ground it in the code and in papers, brainstorm options that cite an evidence table, state a falsifiable hypothesis with a metric, grill, plan, evaluate, execute, then measure the result against the hypothesis before finishing. Runs feature-flow's phases with

• self-review

  Review your own branch before opening a PR: a confidence-scored bug pass, a spec pass, a standards pass, a security pass, a CLAUDE.md audit, and specialist agents for error handling, tests, types and comments, all in parallel, then one ranked report and fixes for the findings you pick. Never posts a

• test-audit

  Is the test suite appropriate? Run it, then find what it would miss: mutation testing (surviving mutants are weak tests), property-based testing where the code is a parser, codec or invariant, requirements with no test, and test smells. One ranked report, then the gaps you pick get filled test-first

• understand

  Learn a codebase, a subsystem or a concept by doing: map it (pstack how, graphify when a graph exists), learn why it is that way (pstack why), then a guided lesson through mattpocock teach where you write the key lines and Claude explains, and keep the terms you settled in GLOSSARY.md. Use for /unde

• upgrade

  Bump a dependency safely: read its changelog and migration guide, find every use in the code and what the breaking changes hit, approve a plan, bump, fix and test, then /verify. Resumable. Use for /upgrade <package>[@version]; no argument resumes.

• verify

  Prove a branch is ready for a PR: run the tests and checks once and read their output, /self-review the diff, /doc-audit the docs it touched, optionally /test-audit it, read it in tui-review, have you confirm or reopen the decisions the build made on its own, then give a verdict and offer how to int

• writing

  How to write and revise prose a person will read, by the method of Williams and Bizup's Style: Lessons in Clarity and Grace: a problem and a point up front, an order the reader needs, sentences about characters doing things, and nothing needless. Use when writing or revising specs, plans, reports, R

Subagents (6)

• code-simplifier

  Used by /self-review: Use this agent when code has been written or modified and needs to be simplified for clarity, consistency, and maintainability while preserving all functionality.

• comment-analyzer

  Used by /self-review: Use this agent when you need to analyze code comments for accuracy, completeness, and long-term maintainability.

• pr-test-analyzer

  Used by /self-review: Use this agent when you need to review a pull request for test coverage quality and completeness.

• silent-failure-hunter

  Used by /self-review: Use this agent when reviewing code changes in a pull request to identify silent failures, inadequate error handling, and inappropriate fallback behavior.

• spec-compliance-checker

  Checks one documented requirement against the code that should implement it, and returns a verdict with the lines that evidence it. Writes its analysis to disk and returns a compact record. Use for a single requirement; use the spec-compliance workflow for a whole document.

• type-design-analyzer

  Used by /self-review: Use this agent when you need expert analysis of type design in your codebase.

Hooks (2)

• PostToolUse

  node

• PostToolUse

  node

Similar plugins