dotfiles

Review a proposed feature set or implementation plan for requirements whose engineering cost is disproportionately high relative to their apparent product value.

Generate a scannable PR title and description from `gh pr diff` for busy reviewers, creating a placeholder PR first when needed so the diff source is always the PR diff. The core rule: describe CONCEPTS (what changed and why), not file lists — busy reviewers already have the file list, they need the semantic summary that answers "what would I want to know before reviewing this?" Use this skill whenever the user wants to write, update, rewrite, or summarize a pull request description, including phrases like "write a PR description", "update the PR body", "summarize this PR", "make a PR title", "draft PR writeup", or asks for a PR writeup on the current branch's open PR. Also trigger proactively when the user is wrapping up work on a branch and mentions they need to update a PR before requesting review.

Analyze code for unnecessary complexity, vestigial code, over-engineering, and dependency bloat, applying YAGNI principles to identify minimal viable implementations. Use when the user wants a YAGNI review, asks "is this over-engineered?", "what can I delete?", "find dead code", "trim dependencies", "simplify this", or wants abstractions challenged and unused code paths surfaced. Also trigger when the user mentions YAGNI, vestigial code, code bloat, or minimal viable implementation.

Methodology for using AskUserQuestion to help the user work through a fuzzy decision -- one where they know they're stuck but haven't articulated the structure of the choice yet. The job is to decompose the decision into sub-decisions and ask about the one with the most downstream leverage. Use when the user says "ask me questions", "help me think through this", "use AskUserQuestion", or hands you something like "I'm not sure what the right move is for X -- help me figure it out." Also referenced by CLAUDE.md for default AskUserQuestion behavior.

Search the user's past Claude Code conversation history for a specific focused fact. Trigger ONLY when the user explicitly asks to look in past conversations — phrases like "search our past conversations", "find that conversation where...", "what did I tell Claude about X", "did I mention Y before in chat", "look in my Claude history for Z". Greps conversation transcripts (JSONL), memory files, audit logs, and session metadata under ~/.claude and the Claude desktop app's local-agent-mode-sessions directory. Do NOT trigger on "have I worked on X before" or "what was the fix I did for Y" — those are questions about the codebase or git history, not the conversation log; check the code or git log instead.

Review pull requests from an engineering manager's perspective. Use this skill whenever the user asks to review a PR, look at a pull request, check someone's code, give feedback on a diff, or anything involving GitHub PRs and code review. Also trigger when the user pastes a GitHub PR URL, mentions a PR number with a repo context, or says things like "review PR #123", "what do you think of this PR", "look at this diff", "check this change", or "review what [name] submitted". This is a manager-level review — not a nitpick pass. It focuses on design quality, operational maturity, growth signals, and making stats/data-science concepts accessible.

Give your AI agents something more useful than a prompt. Velocity through clarity.

Extract an Allium specification from an existing codebase. Use when the user has existing code and wants to distil behaviour into a spec, reverse engineer a specification from implementation, generate a spec from code, turn implementation into a behavioural specification, or document what a codebase does in Allium terms.

Run a structured discovery session to build an Allium specification through conversation. Use when the user wants to create a new spec from scratch, elicit or gather requirements, capture domain behaviour, specify a feature or system, define what a system should do, or is describing functionality and needs help shaping it into a specification.

Generate tests from Allium specifications. Use when the user wants to propagate tests, generate test files from a spec, write tests for a specification, create property-based tests, produce state machine tests, check test coverage against spec obligations, or understand what tests a specification requires.

Tend the Allium garden. Use when the user wants to write, edit, update, add to, improve, clarify, refine, restructure, fix or migrate Allium specs. Covers adding entities, rules, triggers, surfaces and contracts, fixing syntax or validation errors, renaming or refactoring within specs, migrating specs to a new language version, and translating requirements into well-formed specifications. Pushes back on vague requirements.

Weed the Allium garden. Find where Allium specifications and implementation code have diverged, and help resolve the divergences. Use when the user wants to check spec-code alignment, compare specs against implementation, audit for spec drift or violations, sync specs with code or code with specs, or verify whether the implementation matches what the spec says.

Orchestrate complex implementation tasks by decomposing them into focused, serial sub-agent phases. The parent stays at the strategy/QA layer while sub-agents handle contained implementation chunks. Use when: the user says "use sub-agents", "preserve context", "delegate to agents", "break this into phases", "serial agents", "use agents to implement", or when you receive a multi-phase plan that would consume significant context to implement directly. Also trigger when the user asks you to implement a plan and the plan has 3+ distinct steps that touch different files or concerns. Also trigger mid-conversation when the user redirects you to use sub-agents instead of implementing directly.

spEARS (Simple Project with EARS) methodology for requirements-driven development. Provides Socratic discovery of user needs, EARS-formatted specification writing, implementation tracking, and spec validation -- all built on a strict three-document pattern (requirements.md, design.md, executive.md). MUST BE USED when the user mentions spEARS, EARS requirements, spec writing, requirements discovery, or wants to create/update/validate feature specifications. Also use when the user wants to plan a feature with clear acceptance criteria, track implementation progress against requirements, or do a context-window reflection for spEARS work. Use proactively when the user describes wanting to "spec out" or "define requirements" for any feature, even if they don't mention spEARS by name. Also triggers for "lint my specs", "clean up my design docs", or "check my requirements".

Mine the user's Claude Code conversation transcripts to find recurring patterns and codify them into reusable skills. Use when: the user says "extract this pattern into a skill", "codify this into a skill", "I do this a lot", "make a skill from my history", or describes a workflow they've been doing ad-hoc across conversations and wants formalized. The user may reference a specific pattern from the current conversation or describe one abstractly.

Spawn a panel of agents with distinct personas to review, critique, brainstorm, or debate an artifact from multiple perspectives. Use when: the user says "give them personas", "make them disagree", "panel of experts", "get multiple perspectives", "chorus of reviewers", "brainstorm with personas", "advisory board", or asks for diverse viewpoints on a design decision, document, plan, code review, or problem. Also trigger when the user asks you to spawn 2+ agents with different roles, lenses, or expertise areas.

Write self-contained, single-file Python scripts using uv and PEP 723 inline metadata. Use this skill whenever writing a Python script, CLI tool, one-off automation, or helper that should run without a virtualenv or requirements.txt -- especially when the user says "script", "single-file", "uv", or asks for something quick in Python that needs third-party packages.