Claude Skills by tomzx

Score and rank a backlog of GitHub issues by reach, impact, confidence, and effort (RICE).

Run a bidirectional propagation pass over the SDLC artifact chain after a change, updating the artifacts that depend on the change (downward) and re-checking the premises the change depends on (upward). Use when the user says /propagate-changes, "propagate changes", "propagate this change", "bring the artifacts back in sync", or wants consistency restored in both directions across issue, requirements, specification, plan, tasks, tests, code, and documentation after a change.

Remove local git worktrees (and their branches) whose associated pull request was merged, verifying merge state against GitHub instead of git ancestry. Use when the user says /prune-merged-worktrees, "prune worktrees", "clean up merged worktrees", "remove worktrees for merged PRs", or wants stale worktree cleanup after merges.

Commit an implementation plan to a branch, open a draft PR linked to the originating issue, and post a comment on the issue pointing to the PR.

Drive a multi-round Q&A loop with an external reporter to gather enough information to proceed to requirements.

Rapidly review and approve a GitHub pull request to unblock others. Approves unless there are significant risks or significant public interface changes.

Check all PRs where you are a requested reviewer for new commits and run quick-pr-review on each one that has changed since last reviewed. Optionally filter to specific organizations or repositories (owner/repo).

Record a terminal/CLI demonstration with asciinema, render it to an embeddable GIF (or SVG), and return the asset path. Reusable recording primitive used by verify-pr and validate-implementation.

Record a web UI demonstration with Playwright, capturing screenshots at one or more viewports and optionally a video clip, then return the asset paths. Reusable recording primitive used by verify-pr and validate-implementation.

Refactor the code just produced by create-implementation, introducing only the abstractions and seams it needs to stay small, cohesive, and testable, using the dependency-breaking and behavior-preservation techniques from Michael Feathers' Working Effectively with Legacy Code. Use after implementation and before review, when a change has grown bloated, duplicated, or hard to test. Triggers on /refactor-implementation, "refactor this implementation", "this code is bloated", "introduce a seam",...

Reproduce a bug reported in a GitHub issue by creating a worktree, analyzing the codebase, and attempting to trigger the bug.

Research a topic to map the state of the art, gathering and triaging sources before writing an article. Produces a research brief with organized sources, key findings, and identified gaps that feeds into create-article.

Research any topic by running a comprehensive web search, snapshotting each visited page's raw HTML and converting it to clean markdown, then synthesizing a structured research document. Use when the user says /research-topic, 'research a topic', 'investigate a subject', 'gather sources', 'background research', 'build a research dossier', 'find information on', or wants a topic researched with sources saved on disk. Persists snapshots of every source so findings are auditable and re-usable. F...

Scan a repository for the current user's open pull requests that have merge conflicts, then resolve each one IN PARALLEL by fanning out to a separate agent session per PR. Each session reuses an existing git worktree or creates a new one, fixes the conflicts, verifies, and pushes. Use when the user says /resolve-pr-conflicts, "fix merge conflicts", "resolve PR conflicts", "my PRs have conflicts", "unblock my PRs", or wants to bulk-resolve merge conflicts on their own pull requests in parallel.

Review an article for accuracy, clarity, structure, sourcing, audience fit, cross-article consistency, and style.

Review an assumption validation report for completeness, experiment quality, result rigor, and soundness of the proceed or backtrack decision.

Review an assumption record for specificity, basis quality, risk assessment, and validation plan adequacy.

Review a CLI design for command-surface completeness, cross-command consistency, usability, error handling, output behavior, and convention fit.

Review a codebase analysis for coverage of relevant components, accuracy of behavior claims, rigor of changeability assessments, and completeness of migration and impact analysis.

Review a decision record for clarity, completeness, reasoning quality, and consequence coverage.

Review documentation for completeness, accuracy, clarity, usability, and structure.

Review a domain model for entity coverage, relationship correctness, vocabulary consistency, invariant validity, boundary clarity, and alignment with the domain context.

Review an existing solutions survey for search coverage, evaluation rigor, accuracy, due diligence, and a sound build-versus-adopt recommendation.

Review a feasibility assessment for completeness, risk coverage, and soundness of the go/no-go decision.

Review goals, objectives, key results, and KPIs for measurability, ownership, and alignment.

Review a code implementation for correctness, quality, test coverage, security, performance, and spec alignment.

Review a GitHub issue for completeness, clarity, acceptance criteria quality, and time budget defensibility before development begins.

Review a learnings document for actionability, specificity, completeness, and balance.

Review a resource lifecycle document for completeness, consistency, spec alignment, and correctness of state transitions and invariants.

Review UI mockups and wireframes for coverage, usability, accessibility, consistency, state coverage, responsiveness, spec fidelity, and implementability.

Review a needs assessment for evidence rigor, stakeholder coverage, alternative-path completeness, and verdict soundness.

Review an observability plan for completeness, actionability, consistency, and alignment with the specification.

Review an implementation plan for completeness, feasibility, dependency coverage, and risk assessment.

Orchestrate a full PR review for a single PR, running assess-pr-risk in parallel with the analyze-test-coverage -> validate-pr -> verify-pr -> review-pr chain. Skips steps already completed for the current commit. Accepts a PR URL or a PR number with optional repository.

Conduct the code-craft review of a GitHub pull request (approach and simplicity, quality, architecture, security, tests, operational concerns). Static only: does not build or run the code (verify-pr's conformance role) or judge whether the target is the right product (validate-pr's validation role).

Review the project context files (.sdlc/context/) for completeness, consistency, clarity, and actionability. Use when the user says /review-project, after /create-project, or before relying on project context to drive feature work.

Review a question record for specificity, answerability, impact, and resolution quality, then record the answer and set the lifecycle status.

Review a README for template conformance, accuracy, completeness, clarity, and getting-started usability.

Orchestrate full PR reviews (assess-pr-risk in parallel with analyze-test-coverage, validate-pr, verify-pr, review-pr) across all PRs where you are a requested reviewer (including PRs where a team request was later dropped), or on a specific PR by URL. Fans out one independent review-pr-full session per PR so a slow step on one PR never blocks another. Never posts anything to GitHub directly; each sub-skill posts its own report.

Review a requirements document for clarity, completeness, testability, and feasibility.

Review a roadmap for alignment, sequencing, focus, horizon discipline, and currency before it drives prioritization.

Review SLOs, SLIs, SLAs, and error budgets for measurability, coverage, and policy soundness.

Audit a skill directory for duplicates, broken references, circular dependencies, orphaned skills, composability issues, CLI drift, and skill gaps. Use when the user says /review-skills or wants to audit their skill library.

Review a technical specification for ambiguities, inconsistencies, incoherences, missing information, and implementability concerns.

Review a task decomposition for granularity, completeness, dependency clarity, and estimability.

Review a Team API for completeness, ownership clarity, dependency accuracy, interaction-mode soundness, and contract quality.

Review a team charter for completeness, clarity, boundary soundness, decision-making, metric quality, and ratifiability.

Review a telemetry plan for completeness, actionability, measurability, and consistency with the specification.

Review a test suite or test plan for coverage, quality, correctness, and maintainability.

Display a progress dashboard for SDLC features from .sdlc/ directory data, without modifying any artifacts. Use when the user says /sdlc-status, wants a status report, wants to see feature progress, or asks "where am I" in the SDLC pipeline.