pda

Summarize staged changes, create a git commit without Co-Authored-By, then push

Implement the next task incrementally — build, test, verify, commit

Remove redundant planning artifacts and untracked test/spec files that were generated during development but never committed

Simplify code for clarity and maintainability — reduce complexity without changing behavior

Summarize staged changes and create a git commit without Co-Authored-By

Break work into small verifiable tasks with acceptance criteria and dependency ordering

Conduct a five-axis code review — logic, readability, architecture, security, performance

Combine the project's existing CLAUDE.md with the pda-plugins behavioral guidelines to reduce common LLM coding mistakes

Run the pre-launch checklist and prepare for production deployment

Start spec-driven development — write a structured specification before writing code

Run TDD workflow — write failing tests, implement, verify. For bugs, use the Prove-It pattern.

Guides stable API and interface design. Use when designing APIs, module boundaries, or any public interface. Use when creating REST or GraphQL endpoints, defining type contracts between modules, or establishing boundaries between frontend and backend.

Tests in real browsers. Use when building or debugging anything that runs in a browser. Use when you need to inspect the DOM, capture console errors, analyze network requests, profile performance, or verify visual output with real runtime data via Chrome DevTools MCP.

Automates CI/CD pipeline setup. Use when setting up or modifying build and deployment pipelines. Use when you need to automate quality gates, configure test runners in CI, or establish deployment strategies.

Simplifies code for clarity. Use when refactoring code for clarity without changing behavior. Use when code works but is harder to read, maintain, or extend than it should be. Use when reviewing code that has accumulated unnecessary complexity.

Optimizes agent context setup. Use when starting a new session, when agent output quality degrades, when switching between tasks, or when you need to configure rules files and context for a project.

Guides systematic root-cause debugging. Use when tests fail, builds break, behavior doesn't match expectations, or you encounter any unexpected error. Use when you need a systematic approach to finding and fixing the root cause rather than guessing.

Manages deprecation and migration. Use when removing old systems, APIs, or features. Use when migrating users from one implementation to another. Use when deciding whether to maintain or sunset existing code.

Records decisions and documentation. Use when making architectural decisions, changing public APIs, shipping features, or when you need to record context that future engineers and agents will need to understand the codebase.

Use when asked to format, restructure, or organize a system design document. Triggers on "format system design", "restructure design doc", or when a system design file needs standardized structure.

Builds production-quality UIs. Use when building or modifying user-facing interfaces. Use when creating components, implementing layouts, managing state, or when the output needs to look and feel production-quality rather than AI-generated.

Structures git workflow practices. Use when making any code change. Use when committing, branching, resolving conflicts, or when you need to organize work across multiple parallel streams.

Refines ideas through structured divergent and convergent thinking. Use when starting with a raw idea that needs clarity, constraints, or validation before building. Use when brainstorming, stress-testing a plan, or exploring multiple directions for a concept.

Delivers changes incrementally. Use when implementing any feature or change that touches more than one file. Use when you're about to write a large amount of code at once, or when a task feels too big to land in one step.

Breaks work into ordered tasks. Use when you have a spec or clear requirements and need to break work into implementable tasks. Use when a task feels too large to start, when you need to estimate scope, or when parallel work is possible.

Evaluates code design quality including SOLID principles, modularity, coupling/cohesion, dependency management, and scalability. Use when performing an architecture review, design review, or as part of code-review.

Performs comprehensive code review across 5 dimensions (security, architecture, logic, performance, readability) using parallel agents. Aggregates findings into a unified report with prioritized verdicts. Use when asked to review code, review a PR, or perform a code review.

Analyzes code for bugs and correctness issues including off-by-one errors, null handling, boolean logic mistakes, race conditions, and edge cases. Use when performing a logic review, correctness review, bug review, or as part of code-review.

Analyzes code for performance issues including algorithmic complexity, N+1 queries, memory leaks, missing caching, blocking operations, and inefficient data structures. Use when performing a performance review, perf review, or as part of code-review.

Analyzes code for readability and simplicity issues including unclear naming, complex control flow, dead code, missing or misleading comments, over-engineering, and unnecessary length. Use when performing a readability review or as part of code-review.

Analyzes code for security vulnerabilities including OWASP Top 10, injection, auth flaws, secrets exposure, and crypto misuse. Use when performing a security review, security audit, or as part of code-review.

Prepares production launches. Use when preparing to deploy to production. Use when you need a pre-launch checklist, when setting up monitoring, when planning a staged rollout, or when you need a rollback strategy.

Grounds every implementation decision in official documentation. Use when you want authoritative, source-cited code free from outdated patterns. Use when building with any framework or library where correctness matters.

Creates specs before coding. Use when starting a new project, feature, or significant change and no specification exists yet. Use when requirements are unclear, ambiguous, or only exist as a vague idea.

Spawn N agents with the same prompt (slight framing variations) to independently analyze a problem, then aggregate results by consensus. Use for decision-making, ranking options, strategic analysis, or any problem where you want to filter hallucinations and surface high-variance ideas. Triggers on "consensus", "poll agents", "stochastic consensus", "spawn N agents to analyze", "multi-agent vote", or /stochastic-multi-agent-consensus. Also triggers on phrases like "what do 10 agents think", "get multiple opinions", or "poll on [topic]".

Drives development with tests. Use when implementing any logic, fixing any bug, or changing any behavior. Use when you need to prove that code works, when a bug report arrives, or when you're about to modify existing functionality.

Use when creating new skills, editing existing skills, or verifying skills work before deployment

2 hooks across 2 events

pyright-langserver