1.0.0 • Published 3d agoCLI

claude-packs

Licence

MIT

Version

1.0.0

Deps

Size

305 kB

Vulns

Weekly

Summary Dependency Versions

claude-packs

Install production-grade Claude Code skills and agents into any codebase, one command at a time — or one whole tech stack at a time.

claude-packs distributes a curated library of Claude Code skills and agents, modelled after the shadcn/ui add command: point it at your project, name what you're building with, and it drops in .claude/skills/ and .claude/agents/ files that teach Claude your stack's production conventions — component structure, API design, database access, CI/CD, security basics — and an agent that audits your codebase against them on demand.

No versioning, no runtime dependencies, no lock-in. Everything is plain Markdown your team can read, edit, and own.

Why this exists

Most teams re-explain the same conventions to an AI agent in every new chat: "we use default exports," "always go through the shared API client," "don't hardcode secrets," "one migration per change." claude-packs turns that tribal knowledge into an installable, versionable-in-your-own-repo artifact:

A SKILL.md documents the conventions for a given stack/domain — concrete rules, real anti-pattern → correct-pattern examples, not generic advice.
A companion AGENT.md is a read-only auditor that checks your codebase against exactly those documented conventions and reports back a severity-ranked list of findings — it never edits your code.
Every module detects your actual setup (TypeScript vs. JavaScript, Express vs. NestJS vs. Fastify, Vitest vs. Jest, App Router vs. Pages Router...) before applying anything — it never forces the wrong stack's rules onto your project.

Because the audit agents are strictly read-only, it's safe to install and run against a real, already-shipping codebase — nothing gets modified except the audit report it writes.

Install

No global install required:

npx claude-packs add @web-development/frontend

Or install the CLI once:

npm install -g claude-packs
claude-packs add @web-development/frontend

Quick start

# Install one module
npx claude-packs add @web-development/frontend

# Install everything a whole stack needs, in one shot
npx claude-packs add --stack next-node

# No idea what you need? Walk through an interactive picker
npx claude-packs add

# See what's available
npx claude-packs list
npx claude-packs list --stacks
npx claude-packs list @web-development

# See what's installed in the current project
npx claude-packs list --installed

# Remove or refresh a module
npx claude-packs remove @web-development/frontend
npx claude-packs update

# Or skip the CLI entirely — browse and install from a local dashboard
npx claude-packs ui

Once installed, ask Claude Code to use it directly — e.g. "use @frontend-audit-agent to audit this codebase" — or just describe the task ("audit our frontend against our conventions") and the matching agent activates on its own.

Tech stacks and modules

`web-development`

Module	Detects	What you get
`frontend`	TypeScript/JavaScript, React (Vite/CRA) or Next.js (App/Pages Router)	Component structure, one shared Axios client + interceptors, TanStack Query, Redux Toolkit/Zustand, shadcn/ui + Tailwind tokens, a shared modal shell, Next.js Server/Client Component data-fetching rules
`backend`	Express, NestJS, or Fastify	Resource-modular structure, one shared response envelope, one centralized error handler, validate-once request handling
`database`	Prisma, Knex/raw SQL, or Mongoose	One shared DB client, explicit field selection, N+1 avoidance, forward-only migrations
`devops`	GitHub Actions + AWS, GitHub Actions + Kubernetes, or GitLab CI	Reusable pipeline steps, one canonical multi-stage Dockerfile, secrets management, SHA-based image tagging
`testing`	Vitest/Jest + Playwright/Cypress	One shared render/test-utils helper, per-feature fixtures, behavior-over-implementation assertions, journey-organized e2e specs
`directus`	Directus instance and/or `@directus/sdk` consumer	One shared SDK client, schema/permissions as source of truth, explicit-`fields` queries
`payloadcms`	Payload 3 (Next.js-native)	One shared Local API access helper, access control in collection config, explicit `depth`/`select` queries
`shopify`	Headless storefront, theme (Liquid), or app development	Context-specific conventions for whichever of the three applies — Storefront/Admin API clients, webhook HMAC verification, Liquid schema-settings discipline
`wordpress`	Classic PHP theme/plugin, or headless (REST/WPGraphQL + React/Next.js)	Named hook callbacks, parameterized `$wpdb` queries, nonce + sanitize/escape discipline, or API field-exposure rules for headless setups

Other departments

Department	Modules
`hr`	`recruitment`, `onboarding`, `policies`
`finance`	`reporting`, `invoicing`, `forecasting`
`sales`	`outreach`, `proposals`, `crm`
`shared`	`writing`, `ai-prompting`, `data-analysis`

Run npx claude-packs list any time for the current, authoritative list — this table can drift, the CLI output can't.

Stacks — install a whole combination at once

A stack bundles the modules a real project needs together, so you don't have to know or remember the individual module names:

Stack	Installs
`react-node`	`frontend` + `backend`
`next-node`	`frontend` + `backend`
`react-directus`	`frontend` + `directus`
`next-directus`	`frontend` + `directus`
`directus`	`directus` (standalone)
`react-payloadcms`	`frontend` + `payloadcms`
`next-payloadcms`	`frontend` + `payloadcms`
`payloadcms`	`payloadcms` (standalone)
`shopify`	`shopify`
`wordpress`	`wordpress`

npx claude-packs add --stack react-directus

Framework differentiation (React vs. Next.js, Express vs. NestJS, etc.) happens inside each module's own stack-detection, not in the stack definition — a stack is just "install these modules together."

CLI reference

`add`

npx claude-packs add @<department>/<module>   # install one module
npx claude-packs add --stack <name>            # install a whole stack
npx claude-packs add                           # interactive department → module picker

Installs everything the module has — SKILL.md/AGENT.md plus any supporting scripts//tools/. There's no partial install: if a module ships both a skill and an agent, the agent needs the skill to function, so you always get both. Prompts before overwriting an existing install.

`list`

npx claude-packs list                    # every available module
npx claude-packs list @web-development    # modules in one department
npx claude-packs list --stacks           # every available stack
npx claude-packs list --installed        # what's installed in this project

`remove`

npx claude-packs remove @<department>/<module>

`update`

npx claude-packs update                            # refresh every installed module
npx claude-packs update @<department>/<module>     # refresh one module

`ui`

npx claude-packs ui                # start the dashboard on the first available port
npx claude-packs ui --port 4523    # pin a specific port

Starts a local, 127.0.0.1-only web dashboard (no external dependencies — plain node:http) and opens it in your browser. It lists every department, module, and stack, shows what's already installed in the current project, and lets you install/reinstall/remove directly from the page — every action calls straight into the same add/remove logic the CLI uses, so behavior is identical either way. Installing over an existing module prompts for confirmation in the browser instead of the terminal. Runs until you stop it with Ctrl+C.

How a module works

Every module is a flat folder — no version subfolders, this package has no versioning:

departments/<department>/<module>/
├── SKILL.md        # the conventions — what "correct" looks like for this stack
├── AGENT.md         # a read-only auditor that checks code against SKILL.md
├── CHANGELOG.md     # append-only history of what changed and why
├── scripts/         # optional supporting scripts for the skill
└── tools/           # optional supporting tools for the agent

Installing a module copies SKILL.md (+ scripts/) into .claude/skills/<department>/<module>/ and AGENT.md (+ tools/) into .claude/agents/<department>/<module>/ in your project — nothing else is touched.

Because there's no versioning, a module's conventions evolve in place. CHANGELOG.md is the record of what changed; re-run npx claude-packs update to pick up the latest.

Extending claude-packs

Registering a new module means adding it to registry/index.json first, then writing its SKILL.md/AGENT.md following the templates in CLAUDE.md. If you're working in this repo directly, its own .claude/agents/module-builder.md is an interactive scaffolding agent for exactly this — ask it to build you a new module and it'll interview you for the specifics rather than filling in generic placeholder text.

License

See package.json for the current license. Update it (and flip "private" to false) before publishing to npm.