Jagreehal Claude Skills

Builds production-ready HTTP APIs with thin handlers, consistent error envelopes, health checks, CORS, idempotency, rate limiting, and graceful shutdown. Use this skill when designing or implementing HTTP endpoints, orpc routes, Zod request/response schemas, or mapping domain errors to status codes. Do not use when/for pure domain logic without HTTP (use fn-args-deps and result-types) or frontend data fetching alone.

Adds retry, timeout, circuit breaker, and backoff strategies around fallible operations returning Results. Use this skill when hardening workflows against transient failures or composing resilient sagas. Do not use when/for defining Result types themselves (use result-types) or HTTP rate-limit headers alone (use api-design).

Breaks work into concrete, verifiable tasks with clear done criteria and ordering. Use this skill when turning an approved plan or ambiguous request into an executable task list before coding. Do not use when/for designing product requirements (use design-exploration) or writing the full implementation plan with copy-pasteable code (use implementation-planning).

Enforces the fn(args, deps) pattern: business logic as functions with explicit dependency injection instead of service classes. Use this skill when writing or refactoring TypeScript business logic, replacing classes, structuring deps, or setting up a composition root. Do not use when/for React component structure (use react-development) or Result/error modeling alone (use result-types).

Models fallible operations with Result/TaggedError instead of thrown exceptions for expected failures. Use this skill when designing function return types, mapping errors, or composing success/failure flows in TypeScript. Do not use when/for Zod parsing at the trust boundary alone (use validation-boundary) or HTTP status mapping alone (use api-design).

Runs red-green-refactor with tests first, no production code without a failing test, and explicit loophole closure. Use this skill when implementing behavior with TDD or when tempted to code before tests. Do not use when/for test strategy/pyramid selection alone (use testing-strategy) or mutation scoring (use mutation-testing).

Automates real browsers from the CLI using a ref-based snapshot-then-interact workflow. Use this skill when driving a live browser to navigate, fill forms, click, screenshot, scrape, log in, mock network, or verify responsive layouts. Do not use when/for unit-testing React components in jsdom or Storybook-only visual work covered by storybook-journeys.

Acts as a critical peer who challenges assumptions, proposes better options, and avoids sycophancy. Use this skill when reviewing plans, designs, or decisions, or when the user asks for honest critique rather than agreement. Do not use when/for literal yes/no questions that need answer-questions-directly, or when implementing an already-decided change.

Isolates feature work in a dedicated git worktree with directory selection, gitignore checks, setup, and baseline tests. Use this skill when starting isolated feature work, before multi-task plans, parallel branches, or discardable experiments. Do not use when/for finishing and merging work (use branch-completion) or dispatching parallel agents without a worktree need (use parallel-agent-dispatch).

Adds OpenTelemetry-style tracing and structured logging around fn(args, deps) boundaries without leaking PII. Use this skill when instrumenting TypeScript services, adding spans/logs/metrics, or correlating request failures. Do not use when/for debugging a single local failure without telemetry design (use debugging-methodology) or HTTP envelope design alone (use api-design).

Writes focused unit and integration tests for fn(args, deps) code with explicit deps mocks and clear arrange-act-assert. Use this skill when authoring or refactoring test files for TypeScript functions and modules. Do not use when/for TDD process discipline alone (use tdd-workflow) or load testing (use performance-testing).

Enforces extreme brevity and high signal-to-noise so every word justifies its existence. Use this skill when writing any response, commit message, PR description, README, plan, or status update, or when output drifts into filler preambles. Do not use when/for long-form articles that need spine-framework, or when structured-writing requires fuller narrative sections.

Researches existing code, docs, and prior art before proposing designs or writing code. Use this skill when entering an unfamiliar area, choosing a library, or before design-exploration when facts are missing. Do not use when/for executing an already-researched implementation plan, or debugging with a live failing signal (use debugging-methodology).

Treats questions as questions, not orders: answer literally, state uncertainty, and ask before acting. Use this skill when interpreting user questions that could be misread as directives or criticism. Do not use when/for the fast tripwire on question-shaped messages (use answer-questions-directly) or non-question task execution.

Creates, rewrites, and reviews Agent Skills that are concise, unambiguous, progressively disclosed, and agent-actionable. Use this skill when authoring or revising a SKILL.md, its routing description, references, assets, scripts, or reusable workflow guidance. Do not use when/for installing third-party skills, writing application code, prose docs, or commit messages.

Structures long-form technical articles with the SPINE narrative framework for clarity and retention. Use this skill when writing or restructuring essays, deep-dives, or tutorial articles. Do not use when/for short README/API docs (use documentation-standards) or Agent Skill authoring (use skill-authoring).

Uses mutation testing to measure test effectiveness and close gaps that coverage alone misses. Use this skill when evaluating whether tests would catch real faults, tuning Stryker, or improving weak suites after green coverage. Do not use when/for writing the first tests (use writing-tests) or load/chaos testing (use performance-testing).

Chooses test pyramid layers, what to mock, and where tests live for fn(args, deps) systems. Use this skill when deciding unit vs integration vs e2e coverage or structuring a test approach for a feature. Do not use when/for the red-green-refactor loop itself (use tdd-workflow) or writing individual test cases (use writing-tests).

Guides completion of development work by verifying tests, presenting merge/PR/keep/discard options, and executing cleanup. Use this skill when implementation is complete and tests pass, when wrapping up a feature branch, or when deciding how to land or discard work. Do not use when/for mid-implementation commits, opening a PR before verification-before-completion, or starting work (use git-worktrees).

Forces honest, calibrated confidence with percentages, evidence, and explicit gaps below 100%. Use this skill when stating a root cause, diagnosis, or conclusion, or when wording like "definitely" or "clearly" would overstate certainty. Do not use when/for pure implementation tasks with no uncertain claim, or when debugging-methodology already owns the evidence-gathering loop.

Centralizes typed configuration with validated env loading, fail-fast startup, and no scattered process.env reads. Use this skill when adding config, environment variables, feature flags, or startup validation in TypeScript services. Do not use when/for validating untrusted HTTP input at the edge (use validation-boundary) or secrets rotation runbooks.

Applies software design rules beyond syntax (fail-fast, explicit over implicit, composition, illegal states unrepresentable) and runs structured design analysis. Use this skill when reviewing or refactoring for design quality, naming, coupling, or type safety. Do not use when/for UI visual design (use ui-design-principles) or enforcing only fn(args, deps) syntax (use fn-args-deps).

Builds React apps with container/view split, typed props, URL state, and data-fetching boundaries that stay testable. Use this skill when implementing or refactoring React features, hooks, or component architecture. Do not use when/for Storybook journey authoring alone (use storybook-journeys) or pure visual design tokens (use ui-design-principles).

Configures and applies strict TypeScript safety (tsconfig flags, ts-reset, narrowing, exhaustive checks). Use this skill when tightening compiler options, eliminating unsafe patterns, or reviewing type-safety gaps. Do not use when/for runtime Zod validation at boundaries (use validation-boundary) or general design review (use design-principles).

Traces a code execution path with file:line references and an execution diagram before any change. Use this skill when about to fix a bug, implement a feature, refactor, or start a TDD cycle on non-trivial code. Do not use when/for pure design discussion without code (use design-exploration) or after a fix is already validated.

Chooses encodings, chart types, layouts, and rendering tech so visualizations communicate accurately and accessibly. Use this skill when building charts, graphs, or dashboards, picking SVG/Canvas/WebGL, or making visuals colorblind-safe and screen-reader accessible. Do not use when/for general UI layout without data graphics (use ui-design-principles) or backend analytics pipelines.

Explores intent, requirements, and trade-offs through dialogue before code, producing a validated design document. Use this skill when requirements are ambiguous before features, components, or significant behavior changes. Do not use when/for bite-sized coding plans after design is approved (use implementation-planning) or debugging an existing failure.

Preserves durable session context, handoffs, and next-step clarity across interruptions. Use this skill when pausing work, resuming a thread, or writing handoff notes so another agent or human can continue. Do not use when/for choosing investigation mode (use investigation-modes) or completing a branch (use branch-completion).

Authors Storybook journeys that document real user flows with MSW and meaningful states. Use this skill when building or reviewing Storybook stories for multi-step UX flows. Do not use when/for scaffolding a new testable component (use react-testable-storybookable) or live production browser automation (use agent-browser).

Produces structured technical prose with clear hierarchy, scannable sections, and purposeful formatting. Use this skill when drafting specs, ADRs, or multi-section explanations that need consistent structure. Do not use when/for extreme brevity alone (use concise-output) or full article narrative arcs (use spine-framework).

Chooses and sticks to an investigation mode (debug, explore, compare) with matching depth and output shape. Use this skill when starting analysis of a bug, unfamiliar area, or trade-off and mode selection would otherwise thrash. Do not use when/for implementing a fix already diagnosed, or session handoff notes alone (use session-continuity).

Audits and enforces the TypeScript pattern stack (fn(args, deps), Result, validation boundaries, observability) across a codebase. Use this skill when reviewing PRs or modules for pattern compliance or remediating violations systematically. Do not use when/for teaching a single pattern in depth (use that pattern's skill) or visual UI review.

Designs load and chaos tests (for example k6 and Toxiproxy) to verify latency, throughput, and failure behavior. Use this skill when proving system performance under load or injected faults. Do not use when/for unit/mutation testing (use writing-tests or mutation-testing) or micro-optimizing React renders (use react-development).

Documents and evolves system architecture with explicit boundaries, ADRs, and trade-off records. Use this skill when making or recording cross-cutting architectural decisions. Do not use when/for local function design (use design-principles or fn-args-deps) or UI component structure (use react-development).

Validates untrusted input once at the boundary with Zod and branded types, then trusts domain args inward. Use this skill when parsing request bodies, env edges, or external payloads into domain types. Do not use when/for Result composition of already-validated domain errors (use result-types) or central app config loading (use config-management).

Applies UI visual hierarchy, spacing, typography, and interaction clarity for product interfaces. Use this skill when designing or critiquing UI layout and visual design quality. Do not use when/for data-chart encoding choices (use data-visualization) or React state architecture (use react-development).

Receives code review feedback through technical verification rather than performative agreement or blind implementation. Use this skill when receiving review comments, before implementing reviewer suggestions, when feedback is unclear, or when a suggestion may be wrong for this codebase. Do not use when/for authoring reviews of others' code or when branch-completion is only about landing already-agreed work.

Debugs failures by gathering evidence before proposing fixes, enforcing no fix without root-cause investigation. Use this skill when encountering bugs, test failures, unexpected behavior, intermittents, or works-locally-fails-in-CI, before changing code. Do not use when/for implementing a feature with no failure under investigation, or pure code-flow-analysis without a live failure.

Turns policy documents into self-contained, accessible HTML explainers with clear structure and intact mandatory language. Use this skill when the user wants a policy as a shareable HTML page or printable explainer. Do not use when/for story-led markdown rewrites without HTML (use policy-story-explainer) or general marketing landing pages.

Rewrites long policy, compliance, HR, legal, or governance documents into accurate story-led explanations. Use this skill when the user wants a policy made relatable and scenario-based without watering down obligations. Do not use when/for HTML page packaging (use policy-html-explainer) or inventing policy that is not in the source.

Frames documentation around reader needs using quality dimensions, document-type requirements, and review checklists. Use this skill when writing or reviewing READMEs, API references, tutorials, changelogs, or error messages. Do not use when/for long-form article structure (use spine-framework) or authoring Agent Skills (use skill-authoring).

Creates bite-sized, TDD-ordered plans with exact paths, copy-pasteable code, and verification steps for a zero-context executor. Use this skill when an approved design or clear multi-step change is ready and coding is about to start. Do not use when/for exploring requirements (use design-exploration) or only listing high-level tasks (use create-tasks).

Dispatches independent subagents in parallel with clear contracts and merge discipline. Use this skill when multiple independent research or implementation strands can proceed without shared mutable state. Do not use when/for sequential dependent steps, or creating git worktrees themselves (use git-worktrees).

Detects question-shaped input and forces a literal answer before any action. Use this skill when the user's message contains "?" or patterns like "why did you", "will that work", "have you considered", "shouldn't we", "doesn't that", or "is that correct", especially when the question challenges a decision. Do not use when/for non-question instructions, or when literal-answers already covers the principle without a live tripwire.

Scaffolds React components that are jointly unit-testable and Storybook-ready with MSW and clear seams. Use this skill when creating new components that need tests and stories from day one. Do not use when/for end-to-end browser automation (use agent-browser) or journey-level Storybook docs without scaffolding (use storybook-journeys).

Requires fresh verification evidence before claiming work complete. Use this skill when about to say done, open a PR, or hand off, before asserting tests pass or behavior is correct. Do not use when/for choosing merge vs discard options after verification (use branch-completion) or mid-debug evidence gathering (use debugging-methodology).