Research-backed SaaS design principles drawn from Linear, Stripe, Shopify Polaris, and Nielsen Norman Group research.

Skills (13):

• speed-is-the-feature -- Optimistic UI, skeleton screens, performance budgets, code splitting
• saas-navigation -- Sidebar nav, Cmd+K command palette, breadcrumbs, org switching
• progressive-disclosure -- Onboarding, empty states, checklists, signup optimization
• form-design -- Inline validation, auto-save vs explicit save, error messages
• notification-hierarchy -- Toasts, banners, modals, inline messages, alert fatigue
• error-handling -- Validation, 403s, session expiry, offline, conflicts
• data-tables -- Pagination, alignment, bulk actions, column defaults
• permissions-and-settings -- RBAC, invitations, account vs workspace settings
• authentication -- Magic links, MFA, OTP, session management, GDPR
• accessibility -- WCAG 2.2 AA, keyboard nav, focus management, SPA a11y
• design-tokens -- Three-tier tokens, dark mode, CSS custom properties
• saas-responsive -- Breakpoints, table-to-card, touch targets, mobile nav
• using-saas-principles -- Meta-skill: index of all principle skills

Commands: /saas-design-principles:saas-review -- Review code against all SaaS design principles

Agents: saas-design-reviewer -- Comprehensive audit with severity-rated findings

Examples:

• I'm building a form for user onboarding. Review my component against the SaaS design principles.
• Our notification system is overwhelming users. Help me apply the notification hierarchy principle.
• Build a data table with pagination and bulk actions following SaaS table best practices.

Visual design principles grounded in VisAWI, Gestalt psychology, and empirical aesthetics research.

Skills (12):

• layout-spatial-structure -- 12-column grid, 8px spacing, CSS Grid/Flexbox, Gestalt proximity, F/Z-patterns
• typography -- Modular type scales, font pairing, line height/length, responsive type
• color-theory-application -- HSL model, 60-30-10 rule, shade scales, WCAG contrast, dark mode
• whitespace-density -- Spacing systems, density spectrum, separation techniques, vertical rhythm
• visual-hierarchy -- 3 levers (size/weight/color), 3-tier architecture, CTA design
• consistency-design-systems -- Design tokens (primitive/semantic/component), atomic design, governance
• craftsmanship-polish -- Pixel alignment, shadows, border-radius, micro-interactions, CLS
• visual-interest-expression -- Brand personality, illustrations, motion design, layout variety
• responsive-design -- Mobile-first, breakpoints, fluid grids, container queries, touch targets
• accessibility-inclusive-design -- WCAG 2.2 AA, contrast ratios, keyboard nav, screen readers
• design-evaluation-scoring -- 8-dimension scoring framework, anti-pattern detection
• using-visual-design-principles -- Meta-skill: index with 25 quick-reference rules

Commands: /visual-design-principles:design-review -- Review visual artifacts with 8-dimension scoring (total out of 40)

Agents: visual-design-reviewer -- Per-dimension 1-5 scoring with severity-classified findings

Examples:

• Score this landing page against the 8-dimension framework. What's the weakest dimension?
• Apply the color theory principle to improve the 60-30-10 distribution in my dashboard.
• Review this component for accessibility. Check contrast ratios and keyboard nav.

API design principles drawn from Stripe, GitHub, Twilio, Google, OWASP, and industry RFCs.

Skills (13):

• routes-and-naming -- Plural nouns, nesting depth, snake_case, query vs path params
• http-methods -- GET/POST/PUT/PATCH/DELETE semantics, idempotency, CRUD patterns
• prefixed-ids -- Stripe-style prefixed IDs, ULID/KSUID, validation, prefix registries
• errors-and-status-codes -- HTTP status codes, RFC 9457, error envelopes, per-field validation
• response-design-and-pagination -- Envelopes, cursor pagination, expand/embed, list metadata
• auth-and-api-keys -- Prefixed API keys, OAuth 2.0, JWT, key rotation, 401 vs 403
• rate-limiting-and-security -- Sliding window, token bucket, OWASP Top 10, CORS
• versioning-and-evolution -- URL versioning, additive evolution, sunset headers
• caching-and-performance -- Cache-Control, ETags, CDN, compression, circuit breakers
• webhooks-and-events -- HMAC-SHA256 signing, retries, event naming, deduplication
• documentation-and-dx -- Three-panel docs, time-to-first-call, SDKs, contract testing
• advanced-patterns -- Bulk/batch, REST vs GraphQL vs gRPC, SSE/WebSockets
• using-api-principles -- Meta-skill: index of all principle skills

Commands: /api-design-principles:api-review -- Review API code against all 12 design principles

Agents: api-design-reviewer -- Comprehensive audit with severity-rated findings

Examples:

• Review my error responses. Are they compliant with RFC 9457?
• Design a REST endpoint for user auth following API key best practices.
• I need to version my API without breaking clients. Guide me through additive evolution.

Cloud infrastructure principles distilled from production experience across multiple cloud migrations. Cloud-agnostic with provider-specific translation tables.

Skills (16):

• multi-account-from-day-one -- Account structure, environment isolation, landing zones
• naming-and-labeling-as-code -- Labels module, naming conventions, cost centers, tag enforcement
• architecture-decision-records -- Numbered ADRs, exemption documentation, immutable history
• repository-and-state-strategy -- Multi-repo, numbered layers, state-per-layer, blast radius
• terraform-module-patterns -- Wrapping community modules, smart defaults, version pinning
• network-architecture -- VPC/VNet design, subnet tiers, API gateways, DNS, private connectivity
• zero-static-credentials -- SSO for humans, OIDC for CI/CD, session-based instance access
• security-monitoring-from-day-one -- Centralized threat detection, compliance scanning
• secrets-and-configuration-management -- Credential rotation, config values, secret hierarchy
• managed-services-over-self-hosted -- Managed vs self-hosted, container orchestration, databases
• service-owned-infrastructure -- Service-owned Terraform, shared modules, no platform bottleneck
• container-image-tagging -- Git SHA traceability, registry lifecycle policies, no "latest"
• tag-based-production-deploys -- Git tag releases, manual approval gates, pipeline stages
• unified-cicd-platform -- Platform consolidation, OIDC auth, eliminating multi-provider burden
• operational-hygiene -- Resource cleanup, cost attribution, monitoring, drift detection
• using-cloud-foundation-principles -- Meta-skill: index of all principle skills

Commands: /cloud-foundation-principles:cloud-foundation-review -- Review infrastructure code against all 15 principles

Agents: cloud-foundation-reviewer -- Comprehensive infra audit with severity-rated findings

Examples:

• Architect a multi-account AWS setup from day one. How do I structure landing zones?
• Review my Terraform modules. Do they follow proper guardrails and smart defaults?
• Guide me through migrating from passwords to OIDC for CI/CD.

Zero-tolerance code pedantry. The obsessive details that separate clean code from correct code.

Skills (16):

• naming-precision -- Every name is a contract; no generic names like "data" or "temp"
• casing-law -- One convention, zero exceptions; enforce consistency across files
• abbreviation-policy -- Spell it out or document it; consistent abbreviation conventions
• boolean-naming -- is/has/can/should prefix; always positive; no exceptions
• import-discipline -- Grouped, sorted, separated; one blank line between groups
• declaration-order -- Constants, types, classes, functions in predictable order
• symmetry -- Parallel things look parallel; create/update/delete have identical structure
• one-pattern-one-way -- One problem, one pattern enforced everywhere
• magic-value-elimination -- Every literal has a name; named constants required
• dead-code-intolerance -- Delete commented-out code, unused imports, TODO comments
• visual-rhythm -- Blank lines separate ideas; consistent spacing; code is prose
• guidelines-compliance -- Scans CLAUDE.md files, builds inheritance chain, checks compliance
• python-pedantry -- str | None not Optional, Pydantic, StrEnum, exception chaining
• typescript-pedantry -- strict tsconfig, discriminated unions, Zod schemas, barrel exports
• go-pedantry -- error wrapping with %w, interface design, package naming, golangci-lint
• using-pedantic-principles -- Meta-skill: index of all principle skills

Commands:

• /pedantic-coder:pedantic-review -- Review current code with severity-rated findings
• /pedantic-coder:pedantic-audit -- Full repository audit: discovers structure, samples files, finds convention conflicts
• /pedantic-coder:guidelines-review -- Scan CLAUDE.md files and check code compliance against project rules

Agents: pedantic-reviewer -- Comprehensive pedantry audit with a pedantry score

Examples:

• Audit my Python codebase. Are my type hints using modern PEP 695 syntax?
• Review my TypeScript imports. Grouped, sorted, and following strict ESLint config?
• Check this Go package for error wrapping consistency.

Modern Python packaging best practices. Everything from src/ layout to trusted publishing.

Skills (13):

• project-structure -- src/ layout, init.py design, _internal/ convention, py.typed marker
• pyproject-toml -- PEP 621 metadata, build backends, PEP 735 dependency groups, SPDX licenses
• code-quality -- Ruff as unified tool, mypy strict mode, modern type hints (PEP 695/649)
• testing-strategy -- pytest strict config, coverage (80-90%), fixtures, async testing
• ci-cd -- GitHub Actions, trusted publishing (OIDC), test matrix, SLSA/Sigstore
• documentation -- MkDocs Material, Diataxis framework, mkdocstrings, Google-style docstrings
• versioning-releases -- SemVer, PEP 440, Keep a Changelog, Towncrier, deprecation strategy
• api-design -- all, progressive disclosure, exception hierarchy, async/sync dual API
• packaging-distribution -- Wheels, platform tags, maturin, cibuildwheel, package size
• security-supply-chain -- Trusted publishing, Sigstore/PEP 740, pip-audit, OpenSSF Scorecard
• developer-experience -- One-command setup, CONTRIBUTING.md, Makefile/justfile, issue templates
• using-python-package-principles -- Meta-skill: index of all principle skills

Commands:

• /python-package:package-review -- Targeted review of current code against python-package principles
• /python-package:package-audit [path] -- Full repository audit with migration path recommendations

Agents: package-reviewer -- Autonomous package auditor for release readiness checks

Examples:

• Review my Python package structure. Is it using src/ layout with proper __init__.py?
• Check my pyproject.toml against PEP 621 and PEP 735 standards.
• Audit my package for release readiness. Versioning, changelog, deprecation strategy?

Structured deep research methodology. Three-stage pipeline: research-workers (Sonnet) produce findings with Verifiable Claims Tables, research-verifiers (Sonnet) independently fact-check, research-synthesizer (Opus) merges with corrections and Confidence Assessment.

Skills (5):

• research-methodology -- Query decomposition, effort scaling, dynamic replanning, stopping criteria
• source-evaluation -- Source credibility tiers (T1-T6), multi-provider search, SEO spam detection
• hallucination-prevention -- 7-type taxonomy, citation verification, circuit breaker patterns
• synthesis-and-reporting -- Deduplication, conflict resolution, thematic analysis, citation management
• using-deep-research -- Meta-skill: index of all research skills

Commands: /deep-research:research <topic> -- Orchestrated session with parallel workers, verification, and synthesis

Agents:

• research-worker -- Parallel web research with source credibility evaluation
• research-verifier -- Independent fact-checking against actual source content
• research-synthesizer -- Merges findings with corrections and confidence scoring

Examples:

• /deep-research:research "What are the latest advances in production LLM agents?"
• Research the impact of supply chain attacks on open source packages in 2025.
• /deep-research:research "Best practices for multi-agent system architecture"

Structured thinking methods that counteract LLM reasoning biases: first principles, inversion, constraint manipulation, perspective forcing, analogy search, MECE decomposition, assumption surfacing, and diverge-then-converge.

Skills (1):

• structured-brainstorming -- Core methods and subagent dispatch for all 8 thinking methods

Commands: /structured-brainstorming:brainstorm "Problem statement" -- Interactive brainstorming with parallel exploration

Agents: brainstorm-explorer -- Applies different methods to the same problem in parallel

Examples:

• /structured-brainstorming:brainstorm "How should we design the auth system for our SaaS product?"
• I'm stuck on reducing latency. Help me explore this from multiple angles.
• /structured-brainstorming:brainstorm "Best architecture for a real-time collaboration tool?"

Transform Claude Code conversation transcripts into polished, first-person blog posts through an interactive 5-stage pipeline (parse, triage, outline, draft, polish) with human editorial gates at every stage.

Skills (2):

• conversation-format -- JSONL schema, entry types, signal classification, subagent linking
• narrative-craft -- Story arc detection, beat classification, quote handling, first-person voice rules

Commands: /retell:retell [uuid] -- Without UUID shows recent conversations; with UUID runs all 5 stages

Agents:

• triage-analyst -- Assesses blog-worthiness, proposes 3-5 story angles with recommendation
• outline-architect -- Structures post into sections with beat treatments and word count estimates

Examples:

• /retell:retell -- Browse recent conversations and pick one to turn into a post
• /retell:retell 8c439a20 -- Transform a specific conversation into a blog post
• Use retell to turn my architecture session into a technical blog post.

Compress LLM agent instructions and code documentation through iterative section-by-section compression with a compressor-reviewer adversarial loop.

Skills (1):

• markdown-compression -- Core compression principles for both lossless and lossy modes

Commands:

• /markdown-compressor:compress path/to/file.md -- Lossy compression with per-section review
• /markdown-compressor:compress path/to/file.md --lossless -- Structure-only compression
• /markdown-compressor:compress path/to/file.md --auto -- Hands-off lossy compression

Agents:

• section-compressor -- Applies aggressive compression to one section
• compression-reviewer -- Adversarial review for information loss (runs even in auto mode)

Examples:

• /markdown-compressor:compress ./CLAUDE.md -- Compress project guidelines while preserving critical rules
• /markdown-compressor:compress ./architecture.md --lossless --auto -- Structural optimization only, no review stops
• Compress my LLM agent instructions for minimal token usage.

Adversarial plan review using two independent agents: a red team generates what-if questions targeting gaps and unverified assumptions, then a blue team answers each with a grounded verdict. Configurable tool scope lets the blue team verify against local artifacts, web research, or live systems.

Skills (1):

• stress-test-methodology -- When/how to use adversarial plan review, verdict system, tool scope guidance

Commands: /stress-test:stress-test <plan-file> -- Orchestrates red-team/blue-team flow with QA report

Agents:

• red-team -- Generates adversarial what-if questions grounded in plan artifacts (local-only)
• blue-team -- Answers what-ifs with verdicts (ANSWERED, PARTIALLY ADDRESSED, NOT COVERED, UNCERTAIN)

Examples:

• /stress-test:stress-test ./docs/implementation-plan.md -- Stress-test a code implementation plan
• /stress-test:stress-test ./strategy/go-to-market.md -- Challenge a business plan against supporting docs
• Is my plan sound? Run a stress test on it.

Two complementary workflows. Master-plan authoring: long, multi-phase planning documents that live in your project and decompose work into actionable phases -- drafted by parallel context workers plus a synthesizing architect, audited against a verification checklist, then ticked and tracked as work lands. Integer-only phases, no sizing, one PR per plan, list-shape phases (never tables), a plan-level TL;DR plus bulleted context block, and Open Questions at the top. Plan-mode cleanup: each session reuses one slug in ~/.claude/plans/.md across re-plans and compactions, so content accumulates unless explicitly cleared. Detection uses the authoritative "slug" field in the session transcript -- never file mtime (breaks with parallel sessions).

Skills (4):

• master-plan-methodology -- Universal core sections, integer-only phases, list-shape mandate, per-phase and plan-level TL;DRs, evidence attribution
• plan-verification-checklist -- The audit dimensions, severity guide, and PASS/FAIL verdict rules
• progress-methodology -- Dense-paragraph progress entries, SHA-based idempotency, markdown / Linear / GitHub adapters
• using-planning-tools -- Meta-skill: index of commands, the master-plan lifecycle, plan-mode file storage

Commands:

• /planning-tools:plan-context -- Pre-load context: Triage proposes domains, you confirm, workers explore in parallel
• /planning-tools:plan-master -- Draft a multi-phase master plan (optional ticket fetch)
• /planning-tools:plan-open-questions -- Walk a plan's Open Questions one at a time, each with its cited evidence
• /planning-tools:plan-verify -- Audit a plan against the verification checklist
• /planning-tools:plan-tick -- Auto-tick provenly-achieved phases from the current branch
• /planning-tools:plan-progress -- Synthesize a per-branch progress entry with SHA-based idempotency
• /planning-tools:plan-delete -- Clear the current session's plan file

Agents (3): plan-context-worker (parallel domain discovery), plan-master-architect (synthesis), plan-verifier (audit)

Examples:

• /planning-tools:plan-master CI-21 -- Draft a multi-phase plan from a ticket
• /planning-tools:plan-verify context/tickets/CI-21-PLAN.md -- Audit it before committing to it
• /planning-tools:plan-delete -- Reset the current session's plan file before drafting a new plan

Agent A finishes its work and passes a baton -- a completion signal file, optionally carrying a payload. Agent B, in another terminal or another tool entirely, waits for that baton, then starts the work that depended on it. The protocol is harness-agnostic: each agent picks its own waiting mechanism, so one side can be Claude Code and the other Codex or Gemini.

Use it only when there is no shared parent. If both agents live in one session, the harness already chains them and a baton is strictly worse. The uncovered case is two independent processes with no channel between them.

The baton tells you when. It never tells you what. The waiting agent already knows its task -- the human gave it. An optional payload lets A hand B the branch it pushed, the SHA, or why it failed; that payload is content, not instructions, and informs how B works rather than what B does. Two threats drive the design: forgery (batons live in world-writable /tmp, so the 0700 directory is verified owned-by-you) and laundering (a legitimate agent echoing hostile content it read elsewhere -- which no permission fixes, only the content-not-instructions rule).

Skills (1):

• agent-baton -- The full protocol: signal format, optional payload, payload-first publish ordering, derived-not-followed paths, atomic claim, unique-id-per-run, mandatory deadlines, and the failure modes each rule buys off

Commands: /agent-baton:baton-pass <id> [done|failed] [payload] -- publish a completion signal. /agent-baton:baton-wait <id> [timeout] [interval] -- block until a baton with that id appears, then start the dependent task.

Examples:

• /agent-baton:baton-pass ship-2026-07-15 done -- Signal that this agent's 15 tasks are finished
• /agent-baton:baton-wait ship-2026-07-15 2h 5m -- Wait in another terminal, then run the dependent task
• When you're done, pass the baton 'migrate-db-run-3' with the branch you pushed in the payload.