Claude Skills by Vimalk0703

E-commerce cart management patterns — cart state, inventory reservation, price calculation, discount application, tax computation, and cart abandonment handling.

Order state machine, fulfillment flow, cancellation handling, refund processing, and notification triggers for e-commerce applications.

Design and evolve APIs without breaking existing consumers. Covers additive-only changes, versioning strategies, deprecation workflows, consumer-driven contract testing, and backward-compatible defaults. References Stripe's API stability as the gold standard.

REST API conventions — consistent naming, proper HTTP methods/status codes, pagination, versioning, error responses, and type-safe contracts.

Breaking change detection, versioning strategies (URL path vs header), deprecation policies, backward compatibility rules, and OpenAPI spec maintenance.

Schema design, migrations, indexing, naming conventions, and query performance. Prevents N+1 queries, missing indexes, and irreversible schema changes.

Apply distributed systems patterns including idempotency, saga pattern, outbox pattern, eventual consistency, and CQRS to build reliable, consistent distributed services.

Structured logging, request tracing, health checks, error tracking, and key metrics. Every service should be observable from day one.

Bundle size limits, API response time budgets, query limits, image optimization, lazy loading, and caching strategies.

Apply resilience patterns (circuit breakers, bulkheads, retries, timeouts, graceful degradation, DLQs) to distributed services to prevent cascading failures and maintain availability under partial outages.

Evaluate and apply the Twelve-Factor App methodology with modern 2025 interpretations. Covers all 12 factors with actionable checks for cloud-native applications running on containers, Kubernetes, and serverless platforms.

Use when the user wants Codex to review Claude's work, cross-validate PRs, or run high-volume PR review with dual-model verification using the codex-plugin-cc plugin.

Run independent agents concurrently for unrelated tasks. Maximizes throughput when tasks have no shared state.

Process code review feedback with technical verification — not performative agreement. Fix real issues, push back on incorrect feedback with evidence.

Invoke the code-reviewer agent with git-based commit ranges to get structured feedback on code quality, architecture compliance, and correctness.

Dispatch fresh subagents per task with precisely crafted instructions. Two-stage review (spec compliance + code quality) ensures high-quality output.

Detects project type, analyzes existing patterns, generates architecture specifications, and maintains architectural consistency across sessions. The key innovation that turns CLAUDE.md-style contracts into automatic, evolving project specifications.

Automatically generates a lightweight specification before code starts flowing. Captures what the user wants, what will be built, acceptance criteria, and constraints — in a single invisible pass. Skipped for Quick Fixes. Invisible for Builder tier, presented for Engineer tier.

Structured gap analysis that identifies what a project is missing — not what's done poorly (that's /audit), but what's absent entirely. Checks for tests, CI, security basics, linting, type safety, deployment readiness, and dependency health. Each finding has a severity and a concrete fix action.

Master routing skill — loaded at every session start. Defines skill priority hierarchy, mandatory invocation rules, user experience tiers, task size awareness, and routes to appropriate skills based on task type.

4-phase root cause investigation — observe, hypothesize, test, implement. Prevents trial-and-error debugging and enforces a 3-fix limit before reassessment.

JSDoc/docstrings on exports, README sync, API documentation, architecture decision records, and changelog entries.

WCAG 2.1 AA baseline — semantic HTML, ARIA labels, color contrast, keyboard navigation, screen reader compatibility, and focus management.

Component patterns, state management, styling conventions, and rendering strategies for modern frontend development.

Self-improving loop — after completing work, sub-agents analyze the conversation to extract signals (corrections, improvised steps, what worked first try, what failed). Proposes updates to project learnings and skill effectiveness. Every session makes the next one better.

Use when creating a new skill for the Shipworthy plugin, or when a recurring failure mode needs to be codified into a reusable guide. Covers TDD-for-documentation, CSO (Claude Search Optimization), adversarial testing, and the full skill lifecycle.

Pipeline design, environment configuration, secret management in CI, deployment rollback strategies, and feature flags for gradual rollout.

Use when the user asks about context organization, CLAUDE.md structure, where to store decisions or learnings, or when context feels bloated or ineffective. Teaches the 7 principles of context engineering and triages knowledge to the right destination automatically.

Eliminates the number one blocker for non-technical users — environment variable configuration. Explains what .env files are, auto-generates .env.example, provides step-by-step guides for getting API keys, and validates setup at startup.

Manage feature flags with discipline -- expiration dates, kill switches, percentage rollouts, user targeting, and mandatory cleanup. Prevent feature flags from becoming permanent tech debt.

5-step branch completion workflow — verify tests, determine base branch, present merge options, execute, and clean up.

Use when building systems that need centralized tracking of guardrail violations, security warnings, and compliance events. Ensures every block, warning, and override is logged immutably for governance and incident review.

Run blameless post-mortems, define incident severity levels, maintain runbooks, and prepare on-call readiness. Includes templates for post-mortem documents, runbooks, and severity classification.

Detects when a project could benefit from connecting to an MCP server and suggests it. Advisory only — never auto-installs. Recognizes common patterns (database, GitHub, file search, etc.) and maps them to known MCP servers.

Choose and execute the right migration strategy for system changes -- strangler fig, parallel run, expand-contract, blue-green, or feature flag migration. Each with rollback plans and verification strategies.

Pre-launch checklist covering security, performance, reliability, legal, SEO, monitoring, backups, and custom domains. Each item has both a plain-language explanation and technical implementation detail. Ensures nothing critical is missed before going live.

Use when a task is expanding beyond its original boundaries — detecting unplanned additions, feature creep, and yak-shaving that increase risk and delay delivery without explicit user approval.

Formalizes the .shipworthy/ directory as the cross-session memory system. Ensures specs, decisions, plans, and session summaries persist across Claude Code sessions for continuity. Surfaces in-progress work at session start.

Define SLIs (what to measure), SLOs (target values), SLAs (business contracts), error budgets (calculation and usage), and burn rate alerting for production services.

Track shortcuts with justifications, prevent debt accumulation, and surface outstanding debt at session start.

Create isolated workspaces via git worktrees for parallel development. Safety verification ensures worktree directories are gitignored before use.

Expand-contract pattern, backward-compatible schema changes, feature flags for migrations, rollback plans, and production-like testing for database migrations.

Design discovery process that scales with task size and user tier. Prevents wasted work on wrong assumptions while staying out of the way for small tasks. Enforces design-before-code discipline with architecture-aware constraints.

Guides non-technical users through technology choices with opinionated defaults. Recommends one option for Builder-tier users, presents comparisons for Engineer-tier users. Covers databases, hosting, payments, auth, email, and build-vs-buy decisions.

Formal RFC/design doc template for significant engineering changes. Covers context, goals, non-goals, proposed solution, alternatives considered, data model changes, API changes with backward compatibility analysis, security considerations, performance implications, rollout plan, rollback plan, second-order effects, open questions, and timeline.

Systematic task-by-task execution with TDD flow, verification checkpoints after each task, and architecture compliance checks. Updates tech debt tracker if shortcuts are taken.

Creates bite-sized (2-5 min) implementation plans with TDD flow, quality gate checkpoints, security considerations, and performance impact notes. Plans reference architecture.md constraints.

Enforce cyclomatic complexity limits, function/file length limits, nesting depth, parameter counts, and duplication detection. Keeps code readable and maintainable.

Use when the complexity or unfamiliarity of a task should increase guardrail enforcement. Scales verification depth based on how confident the system is in the correctness of the generated code.

Structured error types, recovery strategies, and boundary-aware error handling. Prevents raw string errors, leaked stack traces, and silent failures.