Claude Coding Commands

A collection of reusable Claude Code skills for structured software development workflows. These skills cover the full arc from requirements through implementation, testing, and review.

Installation

To make all skills globally available across every Claude Code project:

make install

To remove all installed skills:

make uninstall

To list available skills without installing:

make list

Skills

Design & Planning

Skill	Description
/requirements-doc	Generate a structured requirements document from unstructured plans or ideas.
/design-doc-high-level	Generate a high-level architecture design document from a requirements document. Covers technology choices, compute platforms, databases, data models, data flows, and security posture.
/design-doc-low-level	Generate a low-level design specification from requirements and high-level design documents. Covers class diagrams, package structure, class interactions, and testing strategy.
/narrative-doc	Write a narrative design or proposal document iteratively, section by section, with human sign-off at each step.
/implementation-task-plan	Generate an implementation task plan from design documents. Breaks a low-level design into ordered, dependency-aware tasks with explicit parallelization analysis.

Implementation

Skill	Description
/implement-task-code	Implement a specific task from the implementation plan using strict TDD. Writes failing tests first, then minimal code to pass, with human approval before committing.
/run-implementation-plan	Execute an entire implementation plan end-to-end. Parallelizes tasks within batches, reviews each batch, fixes issues, commits, and opens a PR when done.
/improve-test-coverage	Diagnose and fix test coverage gaps. Identifies uncovered code paths, adds targeted tests, refactors untestable code, and introduces mocking where needed. Never lowers thresholds.
/setup-code-scaffolding	Bootstrap or fill gaps in a project's code quality tooling. Sets up pre-commit hooks, linting, formatting, test coverage enforcement, static analysis, and dependency auditing.

Review

Skill	Description
/review-code	Review code changes for correctness, security, error handling, performance, testing, and more. Dynamically selects review perspectives based on what changed.
/review-design-high-level	Review a high-level design document for gaps in architecture, security posture, data model soundness, technology choices, and deployment readiness.
/review-design-low-level	Review a low-level design document for gaps in code structure, class design, error handling, and testing strategy.

Research

Skill	Description
/research	Launch a deep research task. Investigates a topic and produces a structured report. Supports templates for different output types.
/quick-research	Quick research — get a sourced answer in under a minute. Use instead of /research when you need a fast answer, not a deep dive.

Meta

Skill	Description
/grill-me	Interview the user relentlessly about a plan or design until reaching shared understanding, resolving each branch of the decision tree.
/capture-skill	Capture what was done in the current conversation as a repeatable, well-structured skill (SKILL.md).

Workflows

Software Design

Note that each skill encourages a naming prefix for your designs, to help separate them. It's strongly encouraged to use this! You can also reference other documents if you're building on top of an existing design.

1. /requirements-doc: Builds functional requirements. Start by giving it unstructured thoughts on the requirements you want. HUMAN REVIEW IS MOST CRITICAL AT THIS STEP - I don't even use AI review for now, you really want to spend time with this because the other skills tend to really accurately turn requirements into software. Wrong requirements, wrong software.
2. /design-doc-high-level: Will ask a number of questions about architecture decisions, but it's encouraged to give unstructured thoughts on the high level decisions you already have made up in your mind.
3. /review-design-high-level: Once you have a high level design, get a fresh window (or different teammate in Claude Code teams) to review it. Then for feedback, you can work to address it one-by-one and re-review until satisfied.
4. /design-doc-low-level and /review-design-low-level: These skills bridge your high level design into something concrete enough to turn over to coding agents and task graph builders.
5. /implementation-task-plan: Will build the most efficient task ordering for coding agents to complete, including identifying parallelizable tasks.

Optionally, you can start with /narrative-doc and feed that into your /requirements-doc. /grill-me is the canonical best skill for reviewing narrative docs (and probably would work well with requirements too).

Software Development

I typically give a Claude Code window a prompt similar to this, in plan mode.

You are going to implement the task plan in plans/cool-service-plan.md. You can and should reference cool-service designs in teh designs/ folder as appropriate. For any new repos we need to create, bootstrap them with `/setup-code-scaffolding` and then commit that scaffolding to the `main` branch and push to remote. For all existing packages, and new packages once scaffolded, you MUST operate in a feature branch, and use the same feature branch name for all repos. For each task in a batch, spin up a parallel agent implementing that task with `/implement-task-code`. Once the batch is done, review each repo's changes with `/review-code` in a fresh subagent. Fix code review feedback in a TDD style until the review passes, then commit to the branch and mark the tasks complete. Continue until all tasks are complete, then push the changes to their branches.

Critically, I do not auto-allow git commit so that I can human review changes before they are pushed for each batch. This tends to be about the right size for check-in reviews.