##skills

Create modern, AI-era PRDs through guided interview.

Best when a feature idea is still fuzzy and the agent needs to shape the problem before writing requirements.

Run a 7-perspective review on a PRD before approval.

Useful for pressure-testing clarity, scope, edge cases, and stakeholder concerns before the document moves forward.

Approve a reviewed PRD and advance the pipeline.

Use after review is complete and the PRD is ready to become the source document for downstream planning and engineering.

Break a PRD into tracer-bullet implementation phases.

Helps teams turn product requirements into a staged execution plan with slices that can be built and validated incrementally.

Write a PRD through interview, exploration, and module design.

Good when the task needs more system understanding than a lightweight PRD interview alone can provide.

Get product, engineering, and implementation status in one pass.

Use at session start or when project state is fragmented across PM, DoE, specs, ADRs, and implementation artifacts.

Principal-engineer code review in two modes: pre-PR local Standards + Spec axes, post-PR GitHub review with two-phase approval.

Slash-invoked only (/code-review-multi-axis) — the model never fires it on its own. Pre-PR mode (argument is a git ref): reviews the diff since a fixed point along two parallel sub-agent axes — Standards (repo coding standards plus a Fowler code-smell baseline) and Spec (the originating issue/PRD) — reported side by side, nothing posted. Post-PR mode (argument is a PR number/URL): 11-dimension rubric grounded in Pragmatic Programmer, Domain-Driven Design, and A Philosophy of Software Design; pre-checks PR description quality (what / why / test plan), size (LOC + file count), and single-concern scope before deep review; walks every finding one at a time with approve / skip / edit / expand / defer / quit verbs; only the approved subset is posted as one grouped GitHub Review. Never auto-APPROVEs. Re-review safe — dedupes against prior runs via hidden markers. Fully configurable in config.yaml. Formerly code-review.

Playwright PRD audit + persona screenshot demo + bug-to-fix_plan emitter.

Discovers routes and auth strategy, scaffolds a Playwright e2e package, writes PRD-driven tests, captures full-page screenshots per persona/route, exports a diagnostic report, and appends one ralph task per bug to .ralph/fix_plan.md with file paths, root-cause hypotheses, and exit criteria.

Turn an approved PRD into TDD, engineering spec, and ADRs.

Runs a review panel across architecture, database design, testing, and performance before approval.

Test-driven development via the red-green loop — seams, anti-patterns, and vertical slices.

Fits feature work and bug fixes where the user wants test-first implementation with pre-agreed seams and tracer-bullet vertical slices. Refactoring is deliberately out of the loop — it belongs to the review stage handled by two-axis-review.

Review a diff since a fixed point along two axes — repo standards and spec fidelity — via parallel sub-agents.

Pins a fixed point (commit, branch, tag), takes the three-dot diff against the merge-base, then runs two parallel sub-agents: Standards (documented repo standards plus a fixed Fowler code-smell baseline) and Spec (missing or partial requirements, scope creep, wrong implementations). Reports both axes side by side without merging or reranking, so a pass on one axis can't mask a failure on the other. Ported from Matt Pocock's engineering/code-review.

Block destructive git commands in Claude Code.

Sets up hooks to stop push, reset, clean, and similar actions before they can damage the working tree or remote state.

[Deprecated] Superseded by /repo-context-scan and /domain-grill.

Kept as a redirect so existing references resolve. Use /repo-context-scan to build CONTEXT.md from the code itself, /domain-grill to stress-test engineering artifacts against it, and /grill-me for PRDs or non-technical plans.

Scan a codebase to build CONTEXT.md and seed ADRs for clearly-deliberate decisions.

Autonomous by default — reads code, infers domain language, and writes CONTEXT.md (or CONTEXT-MAP.md for multi-context repos) plus seeded ADRs. Asks only when ambiguity blocks resolution. Idempotent; safe to re-run as the codebase evolves. Run after cloning a repo or whenever code has drifted from docs. Companion to /domain-grill.

Engineering-only stress-test of a code artifact against CONTEXT.md.

Reads CONTEXT.md (and ADRs) to interview the user against an eng spec, TDD plan, refactor proposal, technical design, schema migration, or API contract. Surfaces conflicts, sharpens fuzzy terms, may add new ADRs for crystallized decisions. Refuses PRDs and non-technical artifacts and redirects to /grill-me. Read-only on CONTEXT.md — flags new terms and recommends re-running /repo-context-scan. Asks for a grill depth (quick / standard / deep) before starting, defaulting to deep; pre-selectable via `/domain-grill quick|standard|deep`. Depth changes how many branches the skill walks, not how sharp each question is.

Run an interactive QA session that files GitHub issues.

Designed for conversational bug reporting when the user wants the agent to absorb context and turn findings into issues.

Plan a refactor as tiny, safe commits.

Best for risky cleanup work that needs an interview, incremental sequencing, and issue tracking before changes begin.

Stress-test a plan or design through relentless interview.

Good when an idea sounds plausible but the team wants to expose weak assumptions before investing implementation time. Asks for a grill depth (quick / standard / deep) before the first question, defaulting to deep; pre-selectable via `/grill-me quick|standard|deep`. Depth changes how many branches the skill walks, not how sharp each question is.

Batch-mode grill: all questions in one collapsible markdown doc, answered in one reply.

Same rigor as /grill-me, but non-interactive. Asks for depth (quick / standard / deep, default deep), writes numbered collapsible questions to `.grills/<YYYY-MM-DD-HHMM>-<slug>-<depth>.md`, includes options, recommendations, alt recommendations, and three reply paths: `accept all my recommendations`, `accept all my alt recommendations`, or a filled per-question answer key. Applies `precision-mode` implicitly to authored prose (question text, *why it matters*, option labels, recommendation and alt reasons) with hard per-field word caps; markdown scaffolding, security/data-loss caveats, and the recommendation + alt structure are exempt.

Research, compare, and select the best packages before installing.

Stops the agent from blindly installing packages. Searches the web for alternatives, compares stars, downloads, bundle size, vulnerabilities, and maintenance — then presents a comparison table so the user picks the right dependency.

Sync README and other user-facing docs with merged PRs.

Surveys recent merged PRs, classifies user-facing changes, places each into the right doc section using a placement matrix, re-audits the project's drift hot spots (alias tables, CLI flag references, config examples) every run, and finishes with a grammar/casing/alignment copy-edit pass. Project-agnostic.

Scaffold a new GitHub repo mirroring a reference repo's settings, branch protection, access, and Pages site.

Captures the reference repo's general settings, security-and-analysis flags, classic branch protection, and (default-on) team + direct-collaborator access, then creates the new repo and PATCHes / PUTs everything to match. Optionally ports a neo-brutalist GitHub Pages docs site (rebranded), wires a custom domain via docs/CNAME, and background-polls for the Let's Encrypt cert before flipping https_enforced. Pass `--no-mirror-access` to skip the team + collaborator step. Other opt-ins: mirror repo-level rulesets (`--mirror-rulesets`), create the Cloudflare DNS record (`--cname-provider cloudflare`), and bootstrap a starter skill so the first commit isn't empty arrays.

Tailor a resume to a specific job with research, discovery, and scored matching.

Takes a JD and your resume library, researches the company/role, surfaces undocumented experience via branching interview, matches content with confidence scores, and emits MD + DOCX + PDF + interview-prep report. Multi-job batch mode for applying to 3–5 roles at once. Includes a portable single-file .skill bundle for Codex and co-work.

Configure a repo for amit-t/skills conventions through a guided 3-decision setup.

Prompt-driven workflow that explores a repo, then asks three sequential decisions — agent instruction surface (AGENTS.md / CLAUDE.md / both), domain context layout (single CONTEXT.md vs multi CONTEXT-MAP.md), and catalog/category mode (consumer-only / skill-catalog authoring / hybrid) — confirms the draft, and writes only the selected scaffolding. Ships templates for agent config, single/multi context layout, ADR format, and catalog categories. Modeled on Matt Pocock's setup-matt-pocock-skills.

Set up Husky + lint-staged + Prettier pre-commit hooks in a JS/TS repo.

Detects the package manager from the lockfile, installs husky/lint-staged/prettier as devDependencies, runs husky init, writes .husky/pre-commit (lint-staged then typecheck and test), .lintstagedrc, and .prettierrc when missing, verifies, and commits as a smoke test. Ported from Matt Pocock's misc/setup-pre-commit.

Scaffold a GitHub Pages site in a neo-brutalist house style.

Drop-in Jekyll templates with a cohesive neo-brutalist design system — IBM Plex Mono everywhere, 3px borders, solid offset shadows, eight saturated accents, four themes (light / dark / cyberpunk grid / solarized IDE), copy buttons on <pre>, theme switcher in localStorage. Includes scaffold.zsh for one-shot stamping and a GitHub Actions Pages workflow.

Run a structured design brief interview before any screens.

Captures context, user goals, style, constraints, and success metrics before visual work starts.

Go from design interview to developer handoff.

Covers user flows, wireframes, system decisions, hi-fi screens, review, and approval in one end-to-end UX workflow.

Review generated screens from 5 design perspectives.

Useful for checking UX, accessibility, engineering feasibility, brand alignment, and end-user clarity before handoff.

Compact the current conversation into a concise summary.

Creates a structured summary of completed work, key decisions, current state, and pending tasks so you can continue in a fresh session without losing context. Only use when the agent lacks a built-in /compact command.

Write a discoverable handoff document so another agent can continue the work via /resume-session-handoff.

Saves a focused handoff to `<project-root>/.claude/handoffs/YYYY-MM-DD-HHMM-<slug>.md` — goal, current state, decisions, ruled-out approaches, open questions, next moves, and suggested skills for the next session. YAML frontmatter (cwd, branch, uncommitted-file count, focus, status) feeds the companion `/resume-session-handoff` skill's preflight. Auto-adds `/.claude/handoffs/` to `.gitignore`, references existing artifacts (PRDs, plans, ADRs, issues, commits, diffs) by path or URL, and tailors the body to the optional argument describing the next session's focus. Named `session-handoff` (not `/handoff`) to avoid colliding with Devin's built-in `/handoff` command, which would otherwise shadow the skill.

Load the newest open handoff with an environment preflight, then ask what to do next — never auto-executes.

Companion to `/session-handoff`. Named `resume-session-handoff` because (1) most agents (Claude Code, Codex, others) ship a built-in `/resume` that restores the prior conversation and would shadow a skill named `resume`; (2) Devin reserves `/handoff` for its own session-transfer flow, so `/resume-handoff` collides by association. `/resume-session-handoff` is unambiguous. Resolves the project root the same way as `/session-handoff` (`git rev-parse --show-toplevel` → ancestor with `.claude/` → `pwd`), globs `<root>/.claude/handoffs/*.md` for the newest open handoff, parses its frontmatter, and surfaces drift against the current environment (project root, cwd, branch, uncommitted-file count, staleness over 14 days). On user confirm, flips `status: resumed`, sets `resumed_at`, moves the file to `.claude/handoffs/resumed/<resume-ts>--<orig-name>`, internalises the body, and **stops to ask the user what to do next** — presenting the Next-moves items, Suggested skills, and free-form options instead of auto-running the first move. Implicitly bootstraps the `using-superpowers` skill before asking, if the environment lists it, so process discipline (brainstorming → plan → TDD → verify) is loaded before the direction is chosen. Supports `/resume-session-handoff list`, `/resume-session-handoff <n>`, and `/resume-session-handoff <slug-substring>` for non-newest selection.

Make progress and status reporting brutally concise.

Keeps agent updates short and direct while preserving full detail for real deliverables like docs, plans, and specs.

Universal conciseness directive for all LLM output.

A single prompt injector that eliminates verbosity from every response — answers, code, explanations, plans, emails, docs. Paste into any system prompt.

Mine the conversation for corrections, preferences, and do-differently lessons; write a dated feedback file; in future sessions, ask 'do I care about this at the moment?' before applying any remembered item.

Two modes. Write mode walks every user turn, classifies into three buckets (corrections the user made, preferences they stated, principles to apply differently next time), and emits a frontmatter-tagged feedback-<YYYY-MM-DD>.md with stable IDs (C1-Cn, P1-Pn, D1-Dn) into the project's Claude Code auto-memory directory, indexed in MEMORY.md. No per-item filtering at write time. Recall mode (auto-triggered in future sessions, plus explicit --recall for a bulk session-start walk) surfaces remembered items in a compact listing format and asks 'Do I care about this at the moment, or do I not?' before the agent applies anything. Just-in-time recall is mandatory whenever the agent is about to act on a past pattern; bulk recall is opt-in via --recall. Session-scoped decisions live in .active-feedback.json; 'always' or 'never' answers persist back to the feedback file's frontmatter. Nothing is ever silently applied. Captures the user's actual words for corrections so future-you recognises the pattern, not just the conclusion.

Sync an existing skill from a source path, or scaffold a new one via claude/codex/devin.

Wraps the skill-sync zsh utility (in ai-utils/skill-sync). Sync mode mirrors a source skill into the current repo and upserts catalog entries (README, site.js, CHANGELOG, skills-lock). Build mode hands a runtime prompt to claude/codex/devin to scaffold a new skill from raw source material. Idempotent on rerun.

Create new skills with the right structure and disclosure.

Fits skill authoring work where the user wants reusable instructions, bundled resources, and better invocation behavior.

Capture a wisdom snippet into a personal corpus — categorize, write, commit.

11-step flow that records one snippet as one file under `wisdoms/<YYYY>/<MM>/<ulid>.md`. Reads `wisdoms/_categories.yml` (closed taxonomy), proposes a primary bucket + tags, optionally proposes a new bucket if no fit, takes a personal note, writes frontmatter (id, created_at, body_hash, category, tags, source_url, source_author, note, import_origin), and commits with `wisdom: <category> — <body>…`. Vision-capable when the user pastes images (slide-style reels, quote cards). Designed for the companion `wisdom` CLI but works in any project that adopts the same data shape.

Turn raw notes into an outcome-first update leadership remembers.

Reformats messy status into three sentences — outcome, reasoning, next — ending with a clear ask. Auto-detects whether to reformat directly or run a 1–3 question interview. Verbal/standup script by default; offers Slack, email, and status-doc formats. Based on Yasar Ahmad's leadership-update framework.