Master Claude Code Suite

A Claude Code skill providing a comprehensive development toolkit that combines multiple coding disciplines into a unified workflow. Covers full-stack development patterns, from project initialization and code generation through testing, deployment, and maintenance — optimized for Claude Code's skill ecosystem.

When to Use This Skill

Choose Master CC Suite when:

• You want a comprehensive development assistant covering frontend, backend, and infrastructure
• You need to bootstrap a full-stack project with best practices
• You want consistent patterns applied across your entire codebase
• You need guidance that spans multiple domains (code, tests, docs, deploy)
• You're building a project that leverages multiple Claude Code skills together

Consider alternatives when:

• You need deep expertise in one area (use a specialized skill)
• You want only backend or only frontend (use domain-specific skills)
• You need a specific technology (use a technology-specific skill)

Quick Start

Copy
# Install the skill
claude install master-cc-suite

# Bootstrap a project
claude "Bootstrap a full-stack project: Next.js frontend, Express API, PostgreSQL, Docker Compose, and CI/CD with GitHub Actions"

# Apply comprehensive standards
claude "Review this codebase and apply best practices across: code quality, testing, error handling, security, and documentation"

# Generate a feature end-to-end
claude "Implement a user authentication feature end-to-end: database schema, API endpoints, frontend pages, tests, and docs"

Core Concepts

Full-Stack Development Workflow

Phase	Activities	Skills Involved
Plan	Architecture, requirements, tech stack	Architecture, product
Setup	Project scaffold, CI/CD, config	Development framework
Backend	API, database, auth, business logic	Backend patterns, database
Frontend	UI, components, state, routing	Frontend patterns, design
Test	Unit, integration, E2E tests	Testing framework
Deploy	Containerize, CI/CD, monitoring	DevOps, deployment
Maintain	Code review, refactor, update deps	Code review, best practices

Technology Stack Recommendations

Frontend:
  → Next.js (React) for web applications
  → Tailwind CSS for styling
  → React Query for server state
  → Zustand for client state

Backend:
  → Express or Hono for APIs
  → PostgreSQL for primary database
  → Redis for caching and sessions
  → BullMQ for background jobs

Infrastructure:
  → Docker for containerization
  → GitHub Actions for CI/CD
  → Vercel or Fly.io for deployment
  → Sentry for error monitoring

Testing:
  → Vitest for unit/integration tests
  → Playwright for E2E tests
  → Supertest for API testing

Project Quality Checklist

Area	Requirement	Tool
Type Safety	TypeScript strict mode	tsconfig.json
Linting	ESLint with recommended rules	.eslintrc
Formatting	Prettier with consistent config	.prettierrc
Testing	80%+ coverage on business logic	Vitest + Coverage
Security	No secrets in code, dep audit	git-secrets, npm audit
Performance	Core Web Vitals passing	Lighthouse
Accessibility	WCAG AA compliance	axe-core
Documentation	README, API docs, architecture	Markdown + OpenAPI

Configuration

Parameter	Type	Default	Description
stack	string	"nextjs_express"	Stack: nextjs_express, remix, sveltekit
database	string	"postgresql"	Database: postgresql, mongodb, sqlite
deployment	string	"docker"	Deploy: docker, vercel, fly, railway
testing	string	"vitest"	Testing: vitest, jest, playwright
strictness	string	"standard"	Quality: relaxed, standard, strict

Best Practices

1. Use TypeScript everywhere — From frontend to backend to scripts. TypeScript catches bugs at compile time, provides IDE autocompletion, and serves as living documentation. Enable strict mode from day one.

2. Automate quality checks — Linting, formatting, type checking, and testing should all run automatically on every commit (pre-commit hooks) and every PR (CI pipeline). Manual quality checks are inconsistently applied.

3. Structure for feature slicing — Organize code by feature/domain rather than by technical layer. All files for the "auth" feature (routes, services, components, tests) should live together, not scattered across routes/, services/, components/.

4. Deploy early, deploy often — Set up CI/CD before writing business logic. Deploy the scaffolded project to verify the pipeline works. Then every feature addition goes through the full build → test → deploy cycle.

5. Document decisions, not implementations — Code documents itself for implementation details. Use documentation for: why this architecture was chosen, how to set up the development environment, and what conventions the team follows.

Common Issues

Project setup takes too long — Use starter templates or scaffold scripts that include your standard configuration. The same ESLint, Prettier, TypeScript, and testing setup shouldn't be recreated for every project.

Inconsistency across frontend and backend — Establish shared conventions: same naming conventions, same error format, same date handling (UTC everywhere). Consider a shared types package for API contracts.

Everything works locally but breaks in production — Environment parity is key. Use Docker for development to match production. Never rely on globally installed tools — everything should be in package.json or Dockerfile.