Skip to content

Explore skills

Search every indexed skill by name, description, repository or instructions, then narrow the results.

Showing 47281–47310 of 62343 skills

contract-testingjacob-balslev/skillsContract testing: interface verification between consumers and providers via shared contract artifacts and independent two-phase verification.Stars: 2Updated Claude CodeCodexUnverifiedInstall
diff-analysisjacob-balslev/skillsUse when analyzing `git diff`, reviewing a patch before commit, or explaining what a changeset does. Covers unified diff anatomy, hunk interpretation, semantic-vs-formatting separation, blast-radius tracing, hidden-risk scanning, and intent-vs-diff comparison. Do NOT use for full code-review verdicts (use `code-review`), git workflow decisions (use `version-control`), or visual diffs.Stars: 2Updated Claude CodeCodexUnverifiedInstall
e2e-test-designjacob-balslev/skillsUse when designing end-to-end tests that exercise a user-visible path through the whole system, including the UI layer: the user-journey unit-of-test that distinguishes e2e from integration testing, the five-primitive structure (user journey, environment, test data, observable assertion, recovery), why e2e tests are expensive and how to keep them few-and-load-bearing, the wait/synchronization discipline that makes them not-flaky, the page-object and trace-test patterns, the role of e2e tests in the test pyramid/trophy (the top tier — fewest in count but highest in coverage of user-observable behavior), and the modern e2e tool landscape (Playwright, Cypress, Selenium). Do NOT use for testing internal seams of the system (use integration-test-design), single-unit isolated tests (use testing-strategy + test-doubles-design), consumer-driven contract verification (use contract-testing), or visual regression of specific components (use snapshot-testing).Stars: 2Updated Claude CodeCodexUnverifiedInstall
error-trackingjacob-balslev/skillsUse when designing or extending an application exception-reporting pipeline: error boundary placement, tracker SDK wrappers, sanitized reporting calls, environment gating, user context without PII leaks, breadcrumbs, and verification that each layer reports correctly. Covers component, route, global, and manual capture surfaces plus central `reportError`/`reportMessage` patterns. Do NOT use for the visual error UX shown to users (use `a11y` and interaction skills), chasing one captured error (use `debugging`), or broad privacy and retention policy (use `owasp-security`).Stars: 2Updated Claude CodeCodexUnverifiedInstall
graph-auditjacob-balslev/skillsUse when checking that SKILL.md files and audit-state.json sidecars conform to the live Skill Metadata Protocol schemas, that manifest entries match the joined source model, that relation targets point at real sibling skills, or that Skill Graph routing/audit claims are backed by the current deterministic gates. Covers schema conformance, sidecar consistency, manifest sync, protocol/schema parity, drift baselines, routing-eval honesty, relation metadata and target-existence ownership gaps, application-eval shape, eval-artifact coherence, corpus conformance-ledger signals, inline corpus-count hygiene, Markdown-link integrity, grounding presence, and name-directory parity. Do NOT use for general code review, runtime agent debugging, prose rewriting, body-section refactoring, new-skill scaffolding, or maintaining the health-tooling implementation itself.Stars: 2Updated Claude CodeCodexUnverifiedInstall
integration-test-designjacob-balslev/skillsUse when designing tests that verify the interaction between two or more units of a system — modules, services, layers, processes: the scope-and-boundary primitives that distinguish integration from unit and e2e tests, the test-pyramid (Cohn 2009) and test-trophy (Dodds) frameworks for how much integration testing belongs in the suite, the real-vs-faked-collaborator decision per dependency, the test-data lifecycle (per-test setup, transaction rollback, container reset), the difference between sociable-unit tests, integration tests, and contract tests, and the failure modes (over-broad scope that mimics e2e, over-narrow scope that mimics unit, shared mutable state that produces flakes). Do NOT use for testing one unit in isolation (use testing-strategy + test-doubles-design), full user-journey testing (use e2e-test-design), consumer-driven contract verification (use contract-testing), or test-suite quality measurement (use mutation-testing).Stars: 2Updated Claude CodeCodexUnverifiedInstall
lint-overlayjacob-balslev/skillsUse when adding or enforcing lint rules as part of a test or verification plan. Extends testing-strategy with lint-specific guidance: rule selection, gate placement, failure triage, and migration planning when introducing rules to an existing codebase. Do NOT use standalone — load the base testing-strategy skill alongside it — and do NOT use for chasing a specific lint failure in one file (that is debugging).Stars: 2Updated Claude CodeCodexUnverifiedInstall
mutation-testingjacob-balslev/skillsUse when reasoning about mutation testing as a behavioral signal of test-suite quality: the mutant-operator vocabulary (replace operator, negate condition, flip Boolean, remove statement, alter constant), the mutation-score metric (killed mutants / total non-equivalent mutants), why mutation testing is a stronger signal than code coverage (coverage measures execution; mutation measures whether the tests would catch a defect), the equivalent-mutant problem (mutants that produce no observable behavior change despite syntactic difference), selective and incremental mutation strategies that make the technique practical for large codebases (PIT, Stryker), and the relationship between mutation testing and TDD. Do NOT use for the structural signal of how much code tests reach (use test-coverage-strategy), the construction of test doubles (use test-doubles-design), the strategic question of what to test at which level (use testing-strategy), or generic fault injection at runtime (use chaos-engineering).Stars: 2Updated Claude CodeCodexUnverifiedInstall
owasp-securityjacob-balslev/skillsUse when reviewing code for security vulnerabilities, threat-modelling a new feature, implementing authentication or authorization, handling user input, hardening dependencies or CI/CD against software-supply-chain compromise, or auditing a codebase against the current OWASP Top 10 (2025, with the 2021 mapping retained). Covers broken access control (incl. SSRF), security misconfiguration, software supply chain failures, cryptographic failures, injection (SQL, NoSQL, command, LDAP, XSS), insecure design, authentication failures, software/data integrity failures, security logging and alerting failures, and mishandling of exceptional conditions (fail-open error paths, error leakage). Do NOT use for general code review (use `code-review` for the holistic per-PR pass), for chasing a known production bug (use `debugging`), for defending an LLM against prompt/RAG injection or agent-tool-authority abuse (use `prompt-injection-defense`), or for writing a security policy doc (use `documentation`).Stars: 2Updated Claude CodeCodexUnverifiedInstall
performance-budgetsjacob-balslev/skillsUse when declaring, measuring, or enforcing performance thresholds as a quality contract rather than as an aspirational target. Covers the three budget axes (time, size, count), the four governing properties of a real budget (metric, threshold, percentile, consequence), the Core Web Vitals set (LCP, INP, CLS), the RAIL model, Lighthouse budgets.json, lab vs field measurement, and the discipline of treating budget breach as a build or deploy failure rather than a tracked metric. Do NOT use for the activity of profiling and optimizing a specific slow path (use performance-engineering), the choice of rendering model that bounds achievable budgets (use rendering-models), or the design of observability and telemetry signals (use observability-modeling).Stars: 2Updated Claude CodeCodexUnverifiedInstall
performance-engineeringjacob-balslev/skillsUse when measuring, diagnosing, budgeting, or improving performance: latency, throughput, Core Web Vitals, database queries, caching, bundle size, concurrency, resource use, and regression prevention. Do NOT use for telemetry schema design alone (use `observability-modeling`), error capture setup (use `error-tracking`), or premature micro-optimization without a measured bottleneck.Stars: 2Updated Claude CodeCodexUnverifiedInstall
performance-testingjacob-balslev/skillsUse when measuring a system's non-functional properties — latency, throughput, error rate, resource utilization, saturation — by running it under controlled load and verifying against explicit SLO thresholds. Covers the five primitives (load profile, workload, latency metric, throughput metric, SLO target), load-shape taxonomy (smoke, load, stress, spike, soak, breakpoint), latency-percentile vocabulary (p50, p95, p99, p99.9), why average latency and coordinated omission mislead, tool selection (k6, JMeter, Locust, Gatling, Vegeta), and offline controlled measurement versus production observability. Do NOT use for optimization itself (use `performance-engineering`), threshold contracts (use `performance-budgets`), production runtime measurement (use `observability-modeling` or `error-tracking`), single-function microbenchmarks, fault injection, or test-suite quality measurement (use `mutation-testing`).Stars: 2Updated Claude CodeCodexUnverifiedInstall
property-based-testingjacob-balslev/skillsUse when reasoning about tests that specify universal properties of code rather than specific input-output pairs: the forall(input) → property quantification, the generator/shrinker primitives that produce inputs and minimize failing cases, the four-rules-of-simple-design analog (commutativity, associativity, idempotence, round-trip, oracle, invariant), the difference between example-based tests (one input, one assertion) and property-based tests (many generated inputs, one universal claim), why property tests find bugs example tests don't, the shrinking discipline that produces minimal failing cases, and the trade-off between generator complexity and bug-finding capacity. Do NOT use for specifying one concrete behavior with one input (use example-based tests under testing-strategy), for fuzz-testing focused on crashes (use fuzz-testing), for mutation testing as a test-suite quality signal (use mutation-testing), or for model-based testing of state machines (use state-machine-modeling).Stars: 2Updated Claude CodeCodexUnverifiedInstall
secrets-managementjacob-balslev/skillsManaging the full lifecycle of sensitive credentials — API keys, database passwords, tokens, certificates, signing keys, and encryption keys — so they are never exposed in code, logs, images, or version history. Covers the secret lifecycle (generation, storage, distribution, use, rotation, revocation, audit), the cardinal rule of never hardcoding secrets, externalizing values out of source into a secrets manager or vault, encryption at rest and in transit, least-privilege scoping per consumer, short-lived dynamically-issued credentials over long-lived static ones, automated rotation and emergency revocation, workload identity (OIDC/SPIFFE) to eliminate standing credentials, environment-variable and .env pitfalls, secret scanning and leak detection in commits and CI, blast-radius containment when a secret leaks, and audit logging of secret access. Tool-agnostic across HashiCorp Vault, cloud secret managers, and KMS-backed stores.Stars: 2Updated Claude CodeCodexUnverifiedInstall
security-fundamentalsjacob-balslev/skillsUse when reasoning about baseline application-security properties: threat modeling, trust boundaries, Saltzer and Schroeder design principles, input validation, authentication vs authorization, secrets handling, secure-by-default choices, least privilege, defense in depth, and OWASP vulnerability classes as recurring failure modes. Covers cross-cutting decisions about what is trusted, where validation belongs, where authn/authz checks live, and how to bound blast radius. Do NOT use for LLM-specific prompt injection or agent-tool authority (use prompt-injection-defense), OWASP-category deep code review (use owasp-security), vendor webhook mechanics (use webhook-integration), cryptographic primitive implementation or key-management mechanics (use vendor/KMS/library docs), compliance/legal artifacts, or the social/organizational side of security.Stars: 2Updated Claude CodeCodexUnverifiedInstall
seo-strategyjacob-balslev/skillsSEO implementation strategy for building pages that rank -- covering content strategy, programmatic SEO at scale, marketplace-specific SEO, and AI search optimization.Stars: 2Updated Claude CodeCodexUnverifiedInstall
snapshot-testingjacob-balslev/skillsUse when reasoning about snapshot testing as a tactical technique: capture-and-compare against a reviewed baseline, data snapshots, DOM snapshots, text/file snapshots, visual snapshots, approval-cycle discipline, snapshot churn, unstable inputs, large unreadable diffs, golden files, characterization tests, and visual regression review with tools such as Jest, Vitest, Playwright screenshots, Storybook/Chromatic, and Percy. Do NOT use for the overall test-level mix (use `testing-strategy`), universal property claims (use `property-based-testing`), test double construction (use `test-doubles-design`), strict test-first workflow design (use `test-driven-development`), or end-to-end user journey design (use `e2e-test-design`).Stars: 2Updated Claude CodeCodexUnverifiedInstall
test-coverage-strategyjacob-balslev/skillsUse when reasoning about code coverage as a strategic measurement rather than a quality target: structural reach versus behavioral verification (covered vs tested), the coverage-criterion hierarchy (function, line, branch, decision, condition, MC/DC, path) and matching the criterion to where a module's failure modes hide, Marick's floor-vs-ceiling distinction, Goodhart's Law applied to coverage and Goodhart-resistant policy (diagnostic use, diff/patch floors, risk-weighting, behavioral panels), denominator hygiene and cross-tool counter semantics, safety-critical MC/DC (DO-178C Level A required; ISO 26262 ASIL-D highly recommended) as requirements-based evidence, and interpreting coverage from AI-generated tests. Do NOT use for choosing test levels (use testing-strategy), mutation testing as a behavioral signal (use mutation-testing), test-double construction (use test-doubles-design), LLM eval iteration (use eval-driven-development), or specific coverage-tooling configuration (tool docs).Stars: 2Updated Claude CodeCodexUnverifiedInstall
test-doubles-designjacob-balslev/skillsUse when designing or reviewing test doubles — the stand-in objects that replace real collaborators in a test: the five-kind taxonomy (dummy, stub, spy, fake, mock) from Meszaros's xUnit Test Patterns, the difference between state verification (Detroit-school, classicist) and interaction verification (London-school, mockist) and how it determines which doubles fit, the cost of doubles (fragility, false confidence, divergence from real behavior), the role of fakes as the under-used middle ground, the verify_with relationship to test-driven-development, and the heuristics for when to use a real collaborator instead of any double. Do NOT use for choosing test levels or what to test (use testing-strategy), the design discipline of writing tests first (use test-driven-development), specific mocking-library API choice (library docs), or general production stubs and feature flags (use feature-gating or domain-specific skills).Stars: 2Updated Claude CodeCodexUnverifiedInstall
test-driven-developmentjacob-balslev/skillsUse when reasoning about Test-Driven Development as a design discipline rather than a workflow: the red-green-refactor cycle as a feedback loop, the difference between London-school (outside-in, interaction-heavy, mock-driven) and Detroit-school (inside-out, state-heavy, classicist) TDD, the role of TDD as a design tool (how tests pressure code into more decomposable shapes), the connection between TDD and emergent design, the boundary between TDD and prior-test-suites, why TDD's failure mode is not 'no tests' but 'tests that mirror implementation', and the empirical record of TDD's effects on defect density, design quality, and development velocity. Do NOT use for the strategy of what to test at which level (use testing-strategy), the construction of test doubles (use test-doubles-design), the discipline of LLM eval iteration (use eval-driven-development), or general-software process workflow (use the obra/superpowers test-driven-development workflow skill — this skill is the concept-shape complement).Stars: 2Updated Claude CodeCodexUnverifiedInstall
testing-strategyjacob-balslev/skillsUse when planning tests for a bug fix, feature, or refactor — deciding what deserves a test, at which level, with what evidence. Covers test-scope decisions, test-level selection (unit / integration / contract / e2e), effort-to-risk matching, regression targeting, evidence quality, and failure-case coverage. Do NOT use for chasing a known failure (that is `debugging`), for pure doc writing (that is `documentation`), or for conceptual architecture discussion with no verification target (no dedicated skill — treat as strategy, not testing).Stars: 2Updated Claude CodeCodexUnverifiedInstall
type-safetyjacob-balslev/skillsUse when reasoning about types as a quality property of code: what guarantees the type system actually provides, the difference between sound and unsound systems, structural vs nominal typing, type narrowing and exhaustiveness, the runtime/compile-time boundary, and where validation must happen because the type system cannot. Covers TypeScript, Flow, Hindley-Milner languages, and gradual typing in general. Do NOT use for runtime input validation library choice (use api-design for API surface validation; use individual library docs for library mechanics), for SQL type mapping (use entity-relationship-modeling), or for type system implementation (compilers — out of scope).Stars: 2Updated Claude CodeCodexUnverifiedInstall
ansoff-matrixjacob-balslev/skillsStars: 2Updated Claude CodeCodexUnverifiedInstall
balanced-scorecardjacob-balslev/skillsUse when building, reviewing, or applying a Balanced Scorecard for strategy execution and performance management: destination statement, strategy map, perspectives, strategic objectives, strategic readiness, measures/KPIs, targets, initiatives, owners, review cadence, cascading, and learning from performance gaps. Covers financial/stewardship, customer/stakeholder, internal process, and learning/growth or organizational-capacity perspectives, with sustainability/ESG embedded or added as a fifth perspective when strategic, and adaptation for business, nonprofit, public-sector, product, and transformation contexts. Do NOT use for upstream strategy formulation alone (use playing-to-win), quarterly goal-setting alone (use okrs), technical service thresholds (use performance-budgets), portfolio allocation (use bcg-matrix), generic internal/external factor inventory (use swot-tows), probability-weighted option valuation (use expected-value), or activity-level value/cost decomposition (use value-chain-analysis).Stars: 2Updated Claude CodeCodexUnverifiedInstall
bayesian-reasoningjacob-balslev/skillsUse when updating beliefs, forecasts, diagnoses, or decision assumptions under uncertainty using Bayesian reasoning: priors/base rates, likelihood, evidence strength, posterior direction, and residual uncertainty. Covers base-rate discipline, likelihood-vs-posterior separation, independent evidence updates, natural-frequency examples, confidence calibration, and when to stop at qualitative probability instead of fake precision. Do NOT use for expected monetary value calculations, strategy-cascade choices (use playing-to-win), industry-structure analysis (use porters-five-forces), or generic task prioritization (use prioritization).Stars: 2Updated Claude CodeCodexUnverifiedInstall
bcg-matrixjacob-balslev/skillsUse when analyzing product, brand, business-unit, or investment portfolio allocation with the BCG Growth-Share Matrix: market growth, relative market share, stars, cash cows, question marks, dogs/pets, cash generation, invest/harvest/divest/reposition choices, portfolio balance, and modern limitations. Covers defining portfolio units and markets, choosing comparable metrics, plotting quadrants, interpreting cash-flow logic, challenging share-growth assumptions, and handing off to valuation or strategy methods. Do NOT use for product-market growth paths (use ansoff-matrix), macro-environment scanning (use pestel), industry profit-pressure diagnosis (use porters-five-forces), internal/external factor inventory (use swot-tows), durable moat classification (use seven-powers), or quantified option valuation (use expected-value).Stars: 2Updated Claude CodeCodexUnverifiedInstall
blue-ocean-strategyjacob-balslev/skillsUse when creating, auditing, or pressure-testing a Blue Ocean Strategy: value innovation, strategy canvas, Four Actions Framework, ERRC grid, six paths, buyer utility, noncustomers, and commercial viability. Covers reconstructing market boundaries, breaking the value-cost trade-off, shifting from competitor benchmarking to alternative/noncustomer insight, and turning the result into a new value curve. Do NOT use for industry-structure diagnosis alone (use porters-five-forces), durable moat classification (use seven-powers), or integrated five-choice strategy cascades (use playing-to-win).Stars: 2Updated Claude CodeCodexUnverifiedInstall
constraint-awarenessjacob-balslev/skillsUse when prioritizing work in an AI-assisted codebase, designing agent autonomy levels, deciding what to automate vs keep manual, or evaluating whether a process/tool adds value. Covers Theory of Constraints for AI-era engineering: cheap code production, human review/validation/decision bottlenecks, Five Focusing Steps, constraint-aware process design, attention audits, and constraint-shift modeling. Do NOT use for task-effort estimation, backlog scoring with RICE/WSJF/ICE, or routing a task to a specific model.Stars: 2Updated Claude CodeCodexUnverifiedInstall
epistemic-groundingjacob-balslev/skillsUse when authoring any artifact that makes claims — skill content, documentation, audit findings, architecture proposals, code review comments, research summaries, or agent output. Covers the discipline of grounding every claim to a verifiable source, distinguishing verified-by-evidence from inferred-from-context, Chain-of-Verification-style claim checking, RFC 2119/RFC 8174 modality, Toulmin argument structure, citation faithfulness, native citation-tool limits, and honest handling of inference, absence, conflict, and currentness. Do NOT use for execution-level evidence protocols or output-completeness enforcement (use methodology), naming precision (use semantics), or grader/rubric design (use evaluation or eval-driven-development).Stars: 2Updated Claude CodeCodexUnverifiedInstall
expected-valuejacob-balslev/skillsUse when choosing among actions under quantified uncertainty by enumerating outcomes, assigning probabilities, valuing each outcome in one shared unit, computing probability-weighted value, testing sensitivity, and checking downside constraints before recommending. Covers expected value, expected utility, expected monetary value, payoff tables, break-even probability, value of information, and risk-of-ruin constraints. Do NOT use for updating probabilities from evidence (use bayesian-reasoning), broad mixed-criteria backlog ranking (use prioritization), or tracing consequences before outcomes are modeled (use second-order-thinking).Stars: 2Updated Claude CodeCodexUnverifiedInstall