Coding standards, frameworks, refactoring, and code review (18.2K skills)
Apply supported repetitive code edits with WebAssembly (WASM), a portable runtime, when a code pattern matches. Transforms include modernizing variable declarations, adding types or error handling, and converting Promise chains; unmatched patterns go to a coder fallback.
Guides test-first implementation by defining expected inputs, outputs, and edge cases before production code is written. It separates test writing from implementation, covers unit and integration tests as well as manual checks, and includes running tests to verify each task.
Investigate software bugs by reproducing the issue, forming and testing root-cause hypotheses, and narrowing the problem with logs or bisection. It helps guide a targeted fix and a follow-up check for regressions.
Turn research findings into a practical implementation plan. The skill sets success criteria, breaks work into file-specific steps, places test specifications first, and records risks and verification methods, with the level of detail matched to the change’s impact.
Carry out an approved implementation plan one step at a time, verifying each change and pausing at phase checkpoints. It investigates failures, tracks progress in the plan, and requires code and security reviews before completion.
Document significant technical decisions as Architecture Decision Records (ADRs). Capture the context, alternatives, chosen approach, and expected consequences, then organize the records with sequential numbers for future reference.
Use this skill to understand a requested codebase investigation before opening files. It guides the agent through clarifying the goal, tracing relevant files and data flows, and writing findings to a dated research document before asking how to proceed.
Use this skill when a project idea or request is still unclear. It asks focused questions, surfaces assumptions, compares possible directions and trade-offs, then turns the chosen direction into clear requirements for research or implementation.
Set up and manage isolated Git worktrees for feature work. The skill helps name branches, install dependencies, check worktree status, compare changes with a base branch, sync updates, and clean up finished or stale worktrees.
Guide code changes through strict test-driven development: write a failing test first, add only enough production code to pass it, then refactor while tests stay green. The skill also calls for checks and separate commits at each phase.
Use this skill to turn a task description into a structured software specification. It searches related code, resolves ambiguity with clarifying questions, breaks work into testable tasks, and refines acceptance criteria from review feedback.
Analyze a codebase to map its structure, index source, tests, configuration, and APIs, then identify conventions such as naming, error handling, and testing practices. Produce a conventions guide, search index, and enforceable project rules.
Break an implementation plan into discrete work units, each with a definition-of-done checklist, file scope, dependencies, and flags for human review or safe parallel execution. Checkpoints highlight changes such as database updates, security-sensitive paths, and external API integrations.
Use this skill to follow a pull request from creation toward merge. It monitors CI, handles review feedback, resolves addressed threads, and checks approvals, coverage, and conflicts to assess whether the PR is ready.
Review a plan before presenting it for approval. Three independent reviewers assess feasibility, completeness, and alignment with the request, each giving a pass or fail verdict with specific references to plan sections.
Prepare for development work by loading relevant rules, pitfalls, patterns, and decisions from a knowledge base. After the work, capture lessons and architectural choices so they can guide future tasks.
Coordinate implementation and review work across OpenAI Codex and Google Gemini. It can route tasks between models, arrange independent review, and define escalation paths that may include Claude and a human reviewer.
Review a feature or architecture proposal through six specialist perspectives: product, architecture, design, security, UX, and CTO. The process requires unanimous approval, consolidates objections, and allows up to three review rounds before escalating to a person.
Break a technical specification into small stories that one coder can complete in a batch. Map the existing modules and interfaces involved, order stories by dependency, estimate effort, and prepare a prioritized queue for implementation, including parallel work where appropriate.
Review a software project for maintenance needs by checking branches, documentation, TODO markers, test coverage, and dependencies. Produce a project health score and remediation recommendations to help teams track and prioritize technical debt.
Maintain a DOT knowledge graph of architectural patterns and design decisions. Capture new knowledge, check graph consistency, find relevant patterns in the codebase, sync the graph with current code, and export it for visualization.
Review code changes against four principles: avoid duplication, skip speculative features, use appropriate abstractions, and provide adequate test coverage. Get numeric quality scores and specific feedback tied to file names and line numbers.
Check GSD plans and phase artifacts for structural errors, missing files, broken references, and unmapped requirements. It returns a structured report showing passed checks, warnings, failures, and recommended fixes.
Manage Git work for GSD plans with one structured commit per task, separate commits for planning files, branch status checks, history and diff summaries, and annotated milestone tags. Keep code and planning changes organized with consistent references to phases and tasks.