Skip to content

README.npm.md

Latest commit

 

History

History
205 lines (151 loc) · 8.47 KB

README.npm.md

File metadata and controls

205 lines (151 loc) · 8.47 KB
Raw

@claude-code-mastery/starter-kit

A Claude Code toolkit that installs 27 commands, 25 skills, 10 hooks, and scaffolding templates into Claude Code globally - so every project you open already has them available.

Requires: Node.js 20+ and Claude Code

Install

npx @claude-code-mastery/starter-kit init

That's the only command you need to run once. Everything else happens inside Claude Code.

What gets installed

After init, your ~/.claude/ directory looks like this:

~/.claude/
├── starter-kit/                  <- package files live here (single source of truth)
│   ├── commands/                 <- 27 slash commands
│   ├── hooks/                    <- 10 lifecycle hooks
│   ├── skills/                   <- 25 skill files
│   └── .starter-kit/             <- scaffolding templates for /new-project
├── commands/
│   ├── new-project.md  -> (symlink to starter-kit/commands/new-project.md)
│   ├── review.md       -> (symlink to starter-kit/commands/review.md)
│   └── ...             -> one symlink per command
├── skills/
│   ├── code-review/    -> (symlink to starter-kit/skills/code-review/)
│   └── ...
└── settings.json       <- hooks registered with absolute paths

Commands and skills are symlinked, not copied. When you update the package, the symlinks point to the new files immediately - no re-linking needed.

Hooks are registered by absolute path in ~/.claude/settings.json, which is the same pattern Claude Code uses for its own global configuration.

Commands

Once installed, these slash commands are available in every Claude Code session:

Command What it does
/new-project <name> [profile] Scaffold a new project with full Claude Code tooling
/convert-project-to-starter-kit Add kit infrastructure to an existing project (non-destructive)
/add-feature <capability> Add MongoDB, Docker, testing, etc. to an existing project
/review Review code for bugs, security issues, and best practices
/commit Generate a conventional commit message from staged changes
/create-api <resource> Scaffold a full API endpoint with route, handler, types, and tests
/create-e2e <feature> Create a Playwright E2E test with explicit success criteria
/refactor <file> Refactor a file following project best practices
/security-check Scan for exposed secrets, missing .gitignore entries, unsafe patterns
/optimize-docker Audit a Dockerfile against 12 best practices
/diagram <type> Generate architecture, API, database, or infrastructure diagrams
/worktree <name> Create an isolated git worktree and branch for a task
/setup Configure .env, GitHub, Docker, analytics, and services interactively
/test-plan <feature> Generate a structured test plan
/progress Show what's done, pending, and next in the project
/starter-kit update Update to the latest version from npm
/starter-kit status Show installed version vs latest
/starter-kit add Install the kit into the current project's .claude/ directory

Skills

Skills are expertise files Claude loads when relevant. These install automatically:

  • accessibility - a11y built in from the start: semantic HTML, real buttons, accessible names, keyboard operability
  • api-conventions - routing and layering conventions for service code
  • code-review - security, performance, and correctness checks with severity rankings
  • create-service - scaffolding patterns for new services
  • css-structure - keeps styles in external .css files; covers when inline style is actually correct
  • debugger - root cause diagnosis for crashes, stack traces, and intermittent bugs
  • dependency-vetting - supply-chain risk assessment before adding a package
  • design-review - usability, accessibility, and visual feedback on UI
  • dev-pitfalls - WSL filesystem, CRLF, import case sensitivity, misleading error messages
  • docker - multi-stage builds, exec-form ENTRYPOINT, non-root users, healthchecks
  • docker-swarm - what changes when compose goes to Swarm: deploy block, overlay networks, signal discipline
  • mcp-builder - MCP server development patterns
  • mdd-workflow - keeps .mdd/ docs in sync with code; guides when to use /mdd
  • mongo-backup - streaming backups to S3, --nsInclude trap, collection tiering for fast restores
  • mongodb-replica-sets - quorum, WiredTiger sizing, ingress-mode port trap, failover discipline
  • mongodb-rules - native-driver and StrictDB rules for MongoDB data access
  • nginx - Docker DNS resolver, proxy caching, security headers, stream block placement
  • nodejs - correct process lifecycle, graceful shutdown, crash-on-fault, modern built-in replacements
  • responsive-css - min-width:0 overflow fix, fluid type with clamp(), mobile-first breakpoints
  • schema-source-of-truth - one canonical Zod schema per entity, derived across all layers
  • terminal-tui - Ink + React TUI patterns, resize handling
  • test-writer - tests with explicit assertions and realistic data
  • waf - proactively recommends a WAF on deploy; CRS tuning, DetectionOnly rollout
  • web-architecture - server-rendered HTML as default; when to reach for a framework
  • web-performance - load strategy up front: inline, preload, defer, lazy-load; image/font/JS cost

Hooks

Hooks fire automatically during Claude Code sessions:

Hook When it fires What it does
check-branch.sh Before commit Blocks commits directly to main
check-rybbit.sh Before deploy commands Ensures analytics are configured
check-ports.sh Before starting servers Checks for port conflicts
check-e2e.sh Before E2E tests Validates test configuration
check-env-sync.sh After editing .env Flags when .env.example is out of sync
check-rulecatch.sh After commits Runs RuleCatch violation checks
block-dangerous-bash.py Before Bash tool Blocks destructive shell commands
check-file-length.py After Write/Edit Warns when files exceed 300 lines
lint-on-save.sh After Write/Edit Runs linter on changed files
verify-no-secrets.sh Before commit Scans staged files for secrets

How Claude Code discovers the installed content

Claude Code does not scan node_modules/. Instead it looks in specific directories:

Content type Where Claude Code looks
Commands ~/.claude/commands/ and <project>/.claude/commands/
Skills ~/.claude/skills/ and <project>/.claude/skills/
Hooks Absolute paths registered in ~/.claude/settings.json

After init, the package files live in ~/.claude/starter-kit/ and are exposed via symlinks and hook registrations in exactly the places Claude Code already checks. No configuration changes to Claude Code are needed.

Updating

npx @claude-code-mastery/starter-kit update

Or from inside Claude Code after the first install:

/starter-kit update

This overwrites ~/.claude/starter-kit/ with the latest package content. Because commands and skills are symlinked, they reflect the update without any re-linking step.

Adding to a specific project

To give a project its own local copy of the commands and hooks (useful for team repos):

/starter-kit add

This copies from ~/.claude/starter-kit/ into the current project's .claude/ directory. Existing files are not overwritten.

Checking what's installed

npx @claude-code-mastery/starter-kit status

Or from Claude Code:

/starter-kit status

Profiles for /new-project

The /new-project command uses profiles to scaffold different project types:

Profile What it creates
clean Minimal structure - just the Claude Code tooling, no framework
node (default) Node.js + TypeScript, Express or similar, StrictDB
go Go project with standard layout, golangci-lint, Makefile
python Python + FastAPI or Django, pytest, ruff, Pydantic 
# Examples inside Claude Code:
/new-project my-api node
/new-project my-service go
/new-project my-site clean

Source and contributing

The package content lives in the starter kit repo: github.com/TheDecipherist/claude-code-mastery-project-starter-kit

Clone the repo to customize commands, hooks, or skills for your own team, or fork it and publish under your own org.