Process & method Claude Code skills

Bundled multi-agent diff review at chosen effort level (low to max, plus cloud 'ultra'), with --fix and --comment; /simplify runs the cleanup-only sibling that applies reuse/simplification fixes without bug hunting.

Trio that launches the actual app and observes behavior instead of trusting tests; run-skill-generator records the project's launch recipe as a per-project skill at .claude/skills/run-<name>/ so all agents reuse it.

Session hygiene skills: /debug turns on debug logging and diagnoses issues from the session log; /fewer-permission-prompts mines your transcripts to build a read-only allowlist in settings.json.

Creates custom hooks to block unwanted Claude behaviors, the official path to enforce automated rules the model itself cannot guarantee.

The reference agentic-development framework: ~14 process skills (brainstorm, plan, TDD, debug, review, verify) that turn Claude Code into a methodology-driven senior engineer; portable to Cursor, Codex, Copilot CLI, Gemini CLI, OpenCode.

Enforces RED-GREEN-REFACTOR before any implementation code, with an anti-patterns reference; the single most-cited skill in the collection.

Four-phase root-cause analysis to run on any bug or test failure before proposing a fix, killing guess-and-patch loops.

Socratic requirements/design refinement gate that runs before any creative or feature work starts.

Pair that converts a spec into a detailed implementation plan then executes it in batches with review checkpoints, optionally in a separate session.

Blocks 'done/fixed/passing' claims until verification commands have actually been run and their output confirmed: evidence before assertions.

One CLAUDE.md distilling Karpathy's Jan-2026 complaints about LLM coding into four behavioural rules (no silent assumptions, no over-engineering, no orthogonal changes, explicit verification); fastest-growing skill repo of 2026.

Automated pull-request review using multiple specialized agents with confidence-based scoring of findings.

PR review agents specializing in comments, tests, error handling, type design, code quality, and simplification.

Simple slash commands for the git workflow: committing, pushing, and creating pull requests.

Publish a living project status page (overview, workstreams, next steps) as a shareable claude.ai artifact that refreshes to the same URL and reports only deltas.

Adds educational insights about implementation choices and codebase patterns while working (revives the deprecated Explanatory output style).

Interactive learning mode that pauses and asks you to contribute meaningful code at decision points instead of writing everything itself.

Socratic design refinement before any creative work: explores user intent, requirements, and design alternatives before implementation starts.

Turns a spec or requirements for a multi-step task into a detailed written implementation plan before touching code.

Executes a written implementation plan in batches with review checkpoints, designed for running the plan in a separate session.

Requires running verification commands and confirming their output before claiming work is complete, fixed, or passing: evidence before assertions.

Pre-review checklist for preparing work before asking for a code review.

Structured way to respond to code-review feedback instead of blindly accepting or ignoring it.

When implementation is done and tests pass, guides the merge-vs-PR-vs-cleanup decision with structured options.

Research-before-coding workflow: search existing code, docs, and prior art before writing anything new.

Continuous verification process so changes are checked as they land rather than at the end.

Suggests manual context-compaction points during long sessions to preserve what matters.

Enforces writing failing tests before implementation code for any feature or bugfix.

Structured root-cause investigation of bugs and test failures before proposing any fix.

Turns rough ideas into fully-formed designs through structured questioning before any code is written.

Create isolated git worktrees with smart directory selection and safety checks for parallel work.

Guides branch completion with structured options for merge, PR creation, or cleanup once tests pass.

Lightweight meta-prompting and spec-driven development system for shipping features fast.

Planning copilot that explores the codebase, asks clarifying questions, and generates executable markdown plans.

Matt Pocock's spec-interview skill: the agent interrogates your request with pointed questions to expose vague requirements before writing any code.

Variant of grill-me that grounds its interrogation in fetched library documentation, so requirement questions reference real API constraints.

Enforces a red-green-refactor loop: write the failing test first, implement minimally, refactor, for every feature or fix.

From Superpowers: converts a spec into a written multi-step implementation plan with checkpoints before any code is touched.

From Superpowers: blocks any "done/fixed/passing" claim until verification commands have actually been run and their output confirmed.

Analyzes staged git changes and writes conventional-commit messages matching the actual diff.

Automatically creates user-facing changelogs from git commit history.

Active le protocole Argus (ex-Frankenstein) : un seul agent qui fusionne huit disciplines d'elite (code chirurgical, verification systematique avant toute affirmation, ecriture directe sans hedging, orchestration multi-agents qui bat un modele seul, gout UI pr

Mode supercomputer. Fusionne sept system prompts d'elite (Fable 5, Cursor, GPT-5, Perplexity, Lovable, Cline, Devin) en une seule personnalite operationnelle. Code chirurgical avec verification systematique, ecriture directe sans hedging ni filler, reponses so

A comprehensive verification system for Claude Code sessions.

Use when facing 2+ independent tasks that can be worked on without shared state or sequential dependencies

Use when you have a written implementation plan to execute in a separate session with review checkpoints

Use when implementation is complete, all tests pass, and you need to decide how to integrate the work - guides completion of development work by presenting structured options for merge, PR, or cleanup

Use when receiving code review feedback, before implementing suggestions, especially if feedback seems unclear or technically questionable - requires technical rigor and verification, not performative agreement or blind implementation

Use when completing tasks, implementing major features, or before merging to verify work meets requirements

Use when starting feature work that needs isolation from current workspace or before executing implementation plans - ensures an isolated workspace exists via native tools or git worktree fallback

Use when starting any conversation - establishes how to find and use skills, requiring skill invocation before ANY response including clarifying questions

Use when you have a spec or requirements for a multi-step task, before touching code