jagreehal-jagreehal-claude-skills

Plugin jagreehal-jagreehal-claude-skills from marketplace cascade-code-languages-misc-1 in joshuarweaver/cascade-code-languages-misc-1. Commands read from the repo's manifest — 1 month ago.

Skills (46)

• agent-browser

  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 Sto

• answer-questions-directly

  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 de

• api-design

  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.

• branch-completion

  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-implement

• code-flow-analysis

  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 afte

• code-review-reception

  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

• concise-output

  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-frame

• confidence-levels

  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

• config-management

  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 (u

• create-tasks

  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 implementat

• critical-peer

  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-dir

• data-visualization

  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 la

• debugging-methodology

  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 wi

• design-exploration

  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 im

• design-principles

  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 (u

• documentation-standards

  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 a

• fn-args-deps

  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 compo

• git-worktrees

  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 bra

• implementation-planning

  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

• investigation-modes

  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 ha

• literal-answers

  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) o

• mutation-testing

  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/

• observability

  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 desi

• parallel-agent-dispatch

  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-

• pattern-enforcement

  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

• performance-testing

  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 r

• policy-html-explainer

  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-expla

• policy-story-explainer

  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

• react-development

  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 pu

• react-testable-storybookable

  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

• research-first

  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

• resilience

  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 heade

• 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-bo

• session-continuity

  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 bra

• skill-authoring

  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-pa

• spine-framework

  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-aut

• storybook-journeys

  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 automat

• strict-typescript

  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

• structured-writing

  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 ar

• system-architecture

  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-devel

• tdd-workflow

  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 sc

• testing-strategy

  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 t

• ui-design-principles

  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-developme

• validation-boundary

  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 ce

• verification-before-completion

  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 evidenc

• writing-tests

  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 (

Slash commands (7)

• /jagreehal-jagreehal-claude-skills:full-review

  Comprehensive codebase review against all jag-reehal-real-claude-skills patterns. Uses pattern-checker agent with chunking for large codebases.

• /jagreehal-jagreehal-claude-skills:init-project

  Initialize a TypeScript project with jagreehal-claude-skills patterns (tsconfig, eslint, dependencies)

• /jagreehal-jagreehal-claude-skills:learn-from-prs

  Analyze PR feedback patterns and suggest config updates to catch issues locally

• /jagreehal-jagreehal-claude-skills:scaffold-function

  Scaffold a new function following the fn(args, deps) pattern with Result types

• /jagreehal-jagreehal-claude-skills:track-improve

  Capture mistake or improvement opportunity with 5 whys root cause analysis

• /jagreehal-jagreehal-claude-skills:verify-patterns

  Verify that code follows jagreehal-claude-skills patterns (fn-args-deps, validation, result types, etc.)

• /jagreehal-jagreehal-claude-skills:workflow-modes

  Define the collaboration style between Claude Code and the user for the current session

Subagents (2)

• pattern-checker

  Verify code follows jagreehal-claude-skills patterns and report violations

• task-check

  Verify task completion before finishing work. Spawn with task ID, location, and work summary.

Hooks (1)

• Stop

  ${CLAUDE_PLUGIN_ROOT}/hooks/tools/checks.sh

Similar plugins