DevFlow Skills Collection

Plugin devflow from marketplace mhylle in mhylle/claude-skills-collection. Commands read from the repo's manifest — 10 days ago.

Skills (35)

• adr

  Document architectural decisions in standardized ADR format. This skill should be used when making significant technical decisions, choosing between approaches, establishing patterns, or when other skills (create-plan, implement-plan, brainstorm) identify decisions that need documentation. Triggers

• adversarial-reviewer

  Adversarial code review by three independent subagent personas (Saboteur, New Hire, Security Auditor) running in parallel, isolated contexts that know nothing of the author's intent or Claude's earlier conclusions. Reviews a diff by default (staged/unstaged, a ref or a file); --codebase reviews a wh

• agent-creator

  Create composable AI agent systems in NestJS projects following the "tools all the way down" architecture. Use this skill when users want to: (1) Create new AI agents with orchestrator/planner/executor/evaluator components, (2) Build agentic systems that can call other agents as tools, (3) Implement

• brainstorm

  Refine a rough idea into a well-structured concept through Socratic questioning, targeted research and one or two fitting analysis frameworks (Six Thinking Hats, SCAMPER, Premortem), then write it to docs/brainstorms/ as the input for planning. Use when the user wants to brainstorm, explore or think

• code-quality-audit

  Run code quality audits covering test coverage, cyclomatic complexity, module sizes, dependency structure (cycles, fan-in/out), and mutation testing. Produces a prioritized report and acts as a quality gate. Use whenever the user wants to audit code quality, check coverage, find complex or oversized

• code-review

  Six-dimension code review of a phase's changes: service delegation, framework standards, ADR compliance, plan sync, coding standards and general quality. Returns a binary PASS or NEEDS_CHANGES verdict with every finding classed BLOCKING, RECOMMENDATION or NOTE. Used by implement-phase as its Step 4

• codebase-audit

  Long-running, resumable adversarial audit of a whole codebase. Splits the repo into partitions, runs /adversarial-reviewer --codebase on each, then synthesizes a cross-partition risk register and a written remediation report. Use for onboarding audits of an inherited codebase, pre-acquisition due di

• codebase-research

  Orchestrates comprehensive codebase research by decomposing user queries into parallel sub-agent tasks and synthesizing findings. This skill should be used when users ask questions about how code works, where functionality exists, how components interact, or need comprehensive documentation of exist

• context-saver

  Write the current session's in-flight work state to a human-readable handoff doc on disk (docs/context/CONTEXT-{topic}.md) so a future chat session — or another person — can pick up exactly where this one stops. Distinct from Claude Code's built-in memory system, which captures long-lived facts and

• continuous-learning

  Turn a hard-won, multi-step procedure from the current session into its own small skill at ~/.claude/skills/learned-<slug>/SKILL.md, so future sessions load it when the same trigger shows up again (an exact error, a tool limitation, a recurring debugging situation, a multi-step project task). On dem

• create-plan

  Create detailed implementation plans through interactive research and iteration. This skill should be used when creating new implementation plans, designing feature specifications, planning technical work, or when the user asks to plan an implementation. Triggers on requests like "create a plan", "p

• design-language

  Design and build someone's own reusable visual design language as durable files: design tokens (css/tokens.css plus a W3C design-tokens.json), a DESIGN_LANGUAGE.md contract and a living multi-page styleguide that future sessions and other projects use to build UI in one consistent style. Use when th

• e2e-testing

  Comprehensive E2E testing skill using Playwright MCP for systematic web application testing. This skill should be used when users need to test web-based systems end-to-end, set up test regimes, run exploratory tests, or analyze test history. Triggers on requests like "test my webapp", "set up E2E te

• eval-harness

  Build and run evaluation suites for AI features in the user's own application: prompts, LLM calls, RAG pipelines, agents. Covers capability and regression evals, graders (exact match, regex, code execution, LLM judge with structured output, human) and metrics (pass@k, pass^k, latency, cost). Three m

• grumpy-reviewer

  One grumpy, nitpicky structural reviewer, run as an isolated subagent that treats the code as a junior's submission and judges only maintainability: separation of concerns, service-oriented design, helper extraction, small files, and the rule of 7 (as a grouping nears 7 members, it pushes for sub-gr

• implement-phase

  Execute a single phase from an implementation plan with all quality gates. This skill is the unit of work for implement-plan, handling implementation, verification, code review, ADR compliance, and plan synchronization for ONE phase. Triggers when implement-plan delegates a phase, or manually with "

• implement-plan

  Orchestrate the execution of complete implementation plans, delegating each phase to implement-phase skill. This skill manages the full plan lifecycle including phase sequencing, user confirmation between phases, and overall progress tracking. Triggers on "implement the plan", "execute the implement

• iterate-plan

  Update existing implementation plans through user feedback with thorough research and validation. Also migrates old checkbox-based plans to the new Task tools system. This skill should be used when iterating on implementation plans, updating plans based on new requirements, refining technical approa

• prompt-generator

  Generate implementation prompts for phase-based project execution using an orchestration pattern. Use when users request prompts for implementing project phases, need orchestration prompts for multi-step implementations, ask for "/prompt", "generate prompt", "create implementation prompt", or want t

• security-review

  Comprehensive security audit for code changes. Use this skill when implementing authentication, authorization, user input handling, API endpoints, secrets/credentials, payment features, or file uploads. Provides security checklists, vulnerability patterns, and remediation guidance. Integrates with i

• ship-issue

  One-command issue-to-merge pipeline orchestrator. Drives a GitHub issue through nine stages (preflight, plan, implement, review, ci, cloud_review, deploy, e2e, logs) with two human gates, persisting all run state to files so a crashed or interrupted run resumes losslessly. Triggers on "/ship-issue"

• skill-visualizer

  Generate interactive HTML visualizations of the skills collection, codebase structure, or dependency graphs. Uses D3.js for interactive visualization with collapsible nodes, color-coded categories, and hover details. Triggers on "visualize skills", "generate skill map", "codebase visualization", or

• strategic-compact

  Suggest context compaction at optimal logical boundaries — between phases, after a research burst, after a debugging session ends — rather than waiting for the automatic compaction threshold to hit mid-task. Use when the user asks whether to compact, mentions context is getting long, wants to checkp

• tt-create-build-loop

  Writes a project's unattended build-loop prompt, `prompts/autonomous-build-loop.md`, which a dynamic `/loop` re-reads every iteration to plan, implement and verify TaskTracker phases under a zero-error phase gate, with a human-only queue and a per-phase cost ledger. Detects what it can (repo, visibi

• tt-create-plan

  Tasktracker-native implementation planning. Turns a /brainstorm file from docs/brainstorms/ (or a clear requirement) into a phased plan persisted as tasktracker phase tasks — NOT as a docs/plans/*.md file. Creates requirements with formal acceptance criteria, registers architecture components, gener

• tt-implement-phase

  TaskTracker-native procedure for ONE phase whose scope and sub-tasks live as TaskTracker phase and task rows (not a docs/plans/*.md file). Runs inline: the session that invokes it leads the phase and dispatches the work by role (a Sonnet implementer writes code and tests, a Haiku mechanic checks eve

• tt-implement-plan

  Tasktracker-native plan orchestrator. Drives a plan whose phases are stored as tasktracker phase tasks (not a docs/plans/*.md file): resumes at the first incomplete implementation phase, runs each phase by following /tt-implement-phase in this session (dispatching its role agents and acting on their

• tt-workflow-audit

  Tasktracker-native, project-wide parallel audit. Partitions a repo, backlog or architecture, fans out one read-only agent per partition (through the Claude Code Workflow tool when it is in the tool list, otherwise parallel Agent subagents), aggregates their findings into a deduplicated, ranked risk

• tt-workflow-build

  Tasktracker-native trigger for a PARALLEL build. Thin by design: (1) ensure a tasktracker project exists (use the existing one, or create one), then (2) build it in dependency waves, fanning each wave's independent slices out to worktree agents — through the Claude Code Workflow tool when it is in t

• tt-workflow-run

  Tasktracker-native autonomous build-loop orchestrator. Drives a first-class workflow_run end-to-end: resumes the project's open run or starts one through the start gates (lifecycle completeness, zero defects in), then loops over getNextReadyTask — activate the slice's phase, take a drift baseline, r

• user-story

  Generate hierarchical user stories (epics, features, tasks) with formal Given/When/Then acceptance criteria. Works from brainstorm output or standalone. Produces structured requirements that feed directly into create-plan. Triggers on "create user stories", "write stories", "define requirements", "u

• verification-loop

  Comprehensive 6-check verification framework for validating implementation quality across build, types, lint, tests, security, and diff review. This skill ensures code meets all quality gates before phase completion. Triggers on "verify implementation", "run verification", "/verification-loop", or a

• video-explainer

  Turn a video (YouTube or any yt-dlp URL, or a local file) into a self-contained HTML explainer page whose diagrams are built in pure CSS (flows, timelines, charts, comparisons, cycles, layers), adding screenshots only where the video's own visuals are the point. Uses the watch plugin to download the

• visual-explainer

  Turn any topic into a self-contained HTML explainer people understand and remember. A one-minute "short version" for busy readers (the answer as a headline, three takeaways, one animated diagram), a "How it works" page in plain language with animated CSS diagrams and a quick check after each section

• workflow-guide

  Routes a piece of work to the right pipeline in this collection. First decides TaskTracker vs file-based (the tt-* skills when a TaskTracker MCP is available and the project is tracked there; /create-plan and /implement-plan otherwise; /brainstorm serves both), then picks the lane by work shape: seq

Subagents (15)

• browser-verification-agent

  Use this agent to perform single UI verification tests via Playwright MCP. This agent executes one test at a time, captures screenshot evidence, and returns a structured response optimized for context preservation. Spawned by implement-phase during Step 3 (Automated Integration Testing).\n\nExamples

• codebase-analyzer

  Explains how existing code works: traces a flow from its entry point to its side effects with file:line references, and documents data transformations, configuration, error handling and integration points. Use when an idea, plan or change touches existing functionality and you need the facts first.

• codebase-locator

  Finds where code related to a feature or topic lives and returns a categorised map with paths from the repository root: implementation, tests, configuration, types, docs and entry points. Use before reading code, when you don't yet know which files matter. It locates and does not explain how the cod

• codebase-pattern-finder

  Finds concrete examples of how something is already done in this codebase, such as similar features, module and service structure, error handling, validation and tests, and returns real code snippets with file:line references and how consistently each pattern is used. Use before building something n

• docs-analyzer

  Use this agent when you need to extract high-value insights from documentation, design documents, ADRs, or research notes. This agent performs deep analysis to extract decisions, constraints, specifications, and actionable insights - filtering out noise and exploratory content. Use this agent when:

• docs-locator

  Use this agent when you need to find documentation, research notes, design documents, or historical context within a project''s documentation directories. This agent locates and categorizes documents in docs/, notes/, design/, plans/, and similar directories. Use this agent when: (1) You need to fin

• implementer

  Writes code and tests for one well-specified unit of work (a sub-task, a fix round, a test suite) from a brief that names the goal, the acceptance criteria and the files in scope, then returns a terse STATUS / FILES / TESTS / ERRORS block. Use it for the implementation and fix rounds a phase lead su

• issue-planner

  Use this agent to turn a triaged issue into an approved implementation plan with formal acceptance criteria. The plan is the single source of truth for every downstream ship-issue stage - tdd-implementer derives its tests from the acceptance criteria, merge-gate-reviewer judges the PR diff against t

• mechanic

  Runs checks and reports the facts without changing anything: build, type-check, lint, tests, coverage, diff scope, log scans, or a verification skill such as verification-loop. Returns pass/fail per check with counts and the first errors, and writes long output to log files. Use it for the mechanica

• merge-gate-reviewer

  Use this agent to review a full PR diff against the approved plan''s acceptance criteria and repository conventions, returning a single verdict - APPROVE or FIX with an itemized, complete blocker list. The blocker list is the entire work order for the fix cycle, which dispatches a fresh implementati

• reviewer

  Independent code reviewer for code it did not write: reviews a change set against its acceptance criteria, the project's conventions and ADRs by running devflow:code-review (and devflow:security-review when the change touches a security-sensitive surface), and returns a PASS or NEEDS_CHANGES verdict

• staging-e2e-verifier

  Use this agent to execute the approved plan''s E2E scenarios against a staging URL via Playwright MCP. It runs each scenario''s prescriptive steps exactly as written, captures one screenshot per scenario as evidence, and returns per-scenario and overall verdicts of PASS, FAIL, FLAKY, or BLOCKED. Spa

• staging-log-verifier

  Use this agent to fetch staging service logs for a deploy window, scan them for errors, warnings, and stack traces, and return a verdict of CLEAN or ERRORS_FOUND with excerpts of the offending lines written to a log file on disk, or BLOCKED when the logs are unreachable. Spawned by the ship-issue or

• tdd-implementer

  Use this agent to implement one approved plan task with strict test-driven development. It writes tests first from the plan''s acceptance criteria, observes each new test fail (RED), implements until the full suite passes (GREEN), and delivers the diff plus RED-then-GREEN test-run evidence. Fix requ

• web-search-researcher

  Researches one question on the web and returns sourced findings: official docs, release notes, issue trackers and forums, comparisons, current practice and known pitfalls. Use when the answer depends on information newer than training data or needs citations, such as library or API behaviour, techno

Hooks (11)

• PreToolUse

  node -e "console.error('[Hook] BLOCKED: Dev server must run in tmux for log access');console.error('[Hook] Use: tmux new-session -d -s dev \"npm run dev\"');console.error('[Hook] Then: tmux attach -t

• PreToolUse

  node -e "if(!process.env.TMUX){console.error('[Hook] Consider running in tmux for session persistence');console.error('[Hook] tmux new -s dev | tmux attach -t dev')}"

• PreToolUse

  node -e "console.error('[Hook] Review changes before push...');console.error('[Hook] Continuing with push')"

• PreToolUse

  node -e "const fs=require('fs');let d='';process.stdin.on('data',c=>d+=c);process.stdin.on('end',()=>{const i=JSON.parse(d);const p=i.tool_input?.file_path||'';if(/\.(md|txt)$/.test(p)&&!/(README|CLAU

• PostToolUse

  node -e "let d='';process.stdin.on('data',c=>d+=c);process.stdin.on('end',()=>{const i=JSON.parse(d);const cmd=i.tool_input?.command||'';if(/gh pr create/.test(cmd)){const out=i.tool_output?.output||'

• PostToolUse

  node -e "const{execSync}=require('child_process');const fs=require('fs');let d='';process.stdin.on('data',c=>d+=c);process.stdin.on('end',()=>{const i=JSON.parse(d);const p=i.tool_input?.file_path;if(

• PostToolUse

  node -e "const{execSync}=require('child_process');const fs=require('fs');const path=require('path');let d='';process.stdin.on('data',c=>d+=c);process.stdin.on('end',()=>{const i=JSON.parse(d);const p=

• PostToolUse

  node -e "const fs=require('fs');let d='';process.stdin.on('data',c=>d+=c);process.stdin.on('end',()=>{const i=JSON.parse(d);const p=i.tool_input?.file_path;if(p&&fs.existsSync(p)){const c=fs.readFileS

• Stop

  node -e "const{execSync}=require('child_process');const fs=require('fs');try{execSync('git rev-parse --git-dir',{stdio:'pipe'})}catch{process.exit(0)}try{const files=execSync('git diff --name-only HEA

• SessionStart

  node -e "const fs=require('fs');const path=require('path');const contextDir=path.join(process.cwd(),'docs','context');if(fs.existsSync(contextDir)){const files=fs.readdirSync(contextDir).filter(f=>f.s

• PreCompact

  node -e "console.error('[Hook] Consider saving context before compaction');console.error('[Hook] Use /context-saver to preserve important state')"

Similar plugins