claude-code-tool-kit

Accessibility audit of UI code or a running site against WCAG 2.1 AA. Walks every WCAG criterion that maps to common patterns: keyboard reach, focus visibility, contrast, semantic HTML, ARIA, labels, alt text, motion, screen-reader sense. Severity-graded with code fixes.

Comprehensive business-logic blueprint for SaaS, ERP, e-commerce, and marketplace applications. Walks through every domain (auth, billing, multi-tenancy, inventory, audit, compliance, etc.), surfaces the edge cases that actually break in production, and proposes a concrete plan tailored to the user's context.

Reviews existing business code (billing, multi-tenancy, state machines, inventory, GL postings, audit logs, etc.) for missing real-world edge cases. Severity-graded findings — invariant violations, race conditions, missing idempotency, currency precision bugs, audit gaps, jurisdiction issues.

Research how 2–4 mature competitors solve a specific business problem (billing, RBAC, search, onboarding, multi-tenancy, etc.) and produce a side-by-side comparison so the team can pick the right approach for their context. Uses web search + scraping; cites every source.

Designs an end-to-end user flow before any pixels are drawn — entry point, screens, decisions, branches, error/recovery paths, edge cases, microcopy hooks. Outputs a structured spec engineering and design can build from.

Writes or reviews UX copy — button labels, error messages, empty states, success messages, tooltips, form labels, onboarding text, confirmation dialogs. Voice-consistent, action-led, recovery-oriented. Localizable. No dark patterns.

Generates textual or ASCII wireframes for screens, layouts, and information architecture. Pixel-free; focused on structure, hierarchy, and component placement. Output is reviewable in a PR diff and translates directly to component code.

Runs a comprehensive pre-deployment verification checklist covering tests, security, environment config, migrations, rollback plan, and breaking changes. Use before deploying to staging or production.

End-of-session summary written to .claude/memory/handoffs/<date>.md so the next session can pick up cleanly. Captures what was done, what's pending, what's blocked, what to verify, and any decisions awaiting the user.

Scaffolds production-ready legal page templates for a website: Privacy Policy, Terms of Service, Cookie Policy, Cookie Consent banner, Refund Policy, Contact / Imprint. Templates are clearly marked as a starting point — the user must customize and have a lawyer review before going live.

Inherit memories from another workspace. Reads .claude/memory/ from a source path and imports its memories into the current workspace under .claude/memory/inherited/<source-name>/. Tagged with provenance so the user can tell where each came from.

Manage the persistent memory layer in .claude/memory/ — list, search, save, update, delete, dedupe. Use to inspect what memories exist, write a new one, or clean up stale entries.

Analyze a fully-built reference application that the user wants to use as a model. Reads its architecture, conventions, tech stack, and patterns; stores a structured summary in .claude/memory/reference/ so subsequent sessions can compare the current project against it.

Scaffolds production-grade SEO for any website: per-page meta tags, Open Graph, Twitter Cards, canonical URLs, JSON-LD structured data, sitemap.xml, robots.txt, and security.txt. Auto-detects the framework and uses its idiomatic approach (Next.js metadata API, Astro layouts, etc.).

Pre-launch audit for any website. Verifies privacy policy, ToS, cookie consent, sessions, sitemap, robots.txt, SEO meta tags, structured data, accessibility (WCAG AA), Core Web Vitals, and compliance frameworks (GDPR/CCPA). Returns severity-graded findings with a GO / NO-GO verdict.

Generates a CI/CD pipeline configuration for the project. Auto-detects the stack and creates GitHub Actions, GitLab CI, or other CI configs with lint, test, build, and deploy stages.

Generates Dockerfile, docker-compose.yml, and .dockerignore for the project. Auto-detects the stack and creates optimized multi-stage builds with caching, health checks, and dev/prod configurations.

Environment setup assistant — detects project requirements, generates .env.example, documents prerequisites, creates setup scripts, and verifies the development environment is ready. Use when setting up a project for the first time.

Sets up error monitoring and tracking for the project. Detects the framework and generates integration code for Sentry, Bugsnag, or custom error tracking with proper error boundaries and middleware.

Relentlessly interviews you about your plan, feature, or design until every edge case, failure mode, and assumption is resolved. Does NOT implement anything — only asks probing questions. Use before starting implementation to bulletproof your thinking.

Assists with migrating between frameworks or major versions — Express to Fastify, CRA to Vite, Vue 2 to Vue 3, class components to hooks, etc. Creates a migration plan, identifies breaking changes, and provides file-by-file migration order.

Generates a comprehensive codebase onboarding guide by scanning the project structure, detecting the stack, mapping architecture, and identifying key entry points. Use when joining a new project or onboarding teammates.

Generates a well-structured pull request description from the current branch diff. Includes summary, changes list, test plan, and breaking changes. Use before opening a PR.

Implements features using strict test-driven development — red-green-refactor cycle. Writes a failing test first, then minimal code to pass, then refactors. Use when building features that need high reliability.

Meta-skill that creates new Claude Code skills. Describe what you want the skill to do and this generates a complete SKILL.md with proper frontmatter, shell injection, structured instructions, and output format.

Designs REST or GraphQL APIs with endpoint definitions, request/response schemas, error codes, authentication requirements, and OpenAPI spec generation. Use when building new APIs or extending existing ones.

Reviews the system architecture for structural issues, dependency cycles, layer violations, scalability concerns, and single points of failure. Use for periodic health checks or before major new features.

Generates a changelog from git history following Keep a Changelog format. Categorizes commits into Added, Changed, Fixed, Removed, Security, and Breaking Changes. Use before releases or to document recent work.

Analyzes test coverage, identifies untested code paths, and generates tests for the most critical uncovered areas. Use to improve test coverage before releases.

Converts code between programming languages while preserving logic, error handling, and idiomatic patterns. Use when migrating modules between languages or frameworks.

Scaffolds a new component, module, or package following the project's existing structure, naming conventions, and patterns. Auto-detects framework and generates all necessary files including tests.

Generates database migration files for schema changes with up/down migrations, safety checks, rollback instructions, and index recommendations. Auto-detects the ORM/migration tool in use.

Systematically debugs issues using structured diagnosis — reproduce, isolate, identify root cause, and fix. Use when facing bugs, errors, unexpected behavior, or failing tests.

Audits project dependencies for known vulnerabilities, outdated packages, unused dependencies, and license compliance. Works with npm, pip, cargo, go modules, and more.

Analyzes a task or GitHub issue and provides effort estimation broken into subtasks with T-shirt sizing, risk assessment, and dependency mapping. Use for sprint planning or before committing to deadlines.

Explains code with multiple levels of detail — high-level purpose, line-by-line walkthrough, data flow diagrams, and design rationale. Use when onboarding to unfamiliar code or trying to understand complex logic.

Fetches a GitHub issue by number, analyzes the requirements, finds the relevant code, implements a fix, and optionally creates a PR. Use when working through your issue backlog.

Generates documentation matching the project's style — README files, API docs, inline documentation, or architecture docs. Auto-detects the documentation format in use.

Cleans up stale git branches, merged branches, orphaned remote refs, and identifies large files in history. Use for periodic repository maintenance.

Analyzes code for performance bottlenecks and produces prioritized, actionable optimization recommendations with before/after code. Use before shipping performance-critical features or when code feels slow.