jacob-balslev

@jacob-balslev source repo

375 skills
0 followers
last month last updated

▌
Type Safety 2 · jacob-balslev bundle
Use 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).

5 installs
▌
Bcg Matrix 2 · jacob-balslev bundle
Use 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).

5 installs
▌
Kano Model 2 · jacob-balslev bundle
Use when classifying product features, service attributes, customer needs, or roadmap candidates with the Kano model: must-be/basic quality, performance/one-dimensional quality, attractive/delighter quality, indifferent quality, reverse quality, and questionable responses. Covers paired functional/dysfunctional survey design, segment-specific classification, feature-priority implications, category migration over time, and the boundary between Kano analysis and general backlog scoring. Do NOT use for generic RICE/ICE/MoSCoW ranking without customer-response evidence (use prioritization), open-ended research synthesis (use user-research or research-synthesis), or product-market positioning (use positioning).

5 installs
▌
Opencode Free Models 2 · jacob-balslev bundle
Use when deciding WHICH free or cheap agent model to route a piece of work to (e.g. MiniMax M3 Free, NVIDIA Nemotron, GLM, GPT-5 Nano, or another OpenCode Zen free-tier model), what each is good at, where its quality ceiling sits, and when to escalate the same work to a frontier model instead. Covers cost-routing: matching deterministic/mechanical/high-volume work to the cheapest model that clears its bar, and the hard rule that quality-creating and quality-judging work never goes to a free/cheap model. Do NOT use for choosing or operating the OpenCode runtime itself (use `opencode`), for authoring the agent loop (use `autonomous-loop-patterns`), or for GitHub Copilot premium-request budgeting (use `github-copilot`).

6 installs
▌
Skill Infrastructure 2 · jacob-balslev bundle
Use when designing or auditing deterministic health tooling for a skill library: schema/source validation, manifest/protocol parity, relation integrity, routing health, drift/export checks, supply-chain scanning, and eval-verdict evidence honesty. Covers checker ownership, the library-as-database model, release gates, and maintenance workflows after batch skill changes. Do NOT use for authoring one SKILL.md (use `skill-scaffold`), repo conformance audits (use `graph-audit`), generic lint rules (use `lint-overlay`), or reviewing checker code (use `code-review`).

7 installs
▌
API Design 2 · jacob-balslev bundle
Use when designing or reviewing HTTP API surfaces: consumer tasks, audience class, protocol/paradigm fit, resources/actions, route taxonomy, request and response schemas, status codes in context, pagination, filtering, sorting, field selection, idempotency, auth and tenant boundaries, error envelopes, rate-limit signals, versioning, deprecation, discovery, and contract artifacts. Do NOT use for pure HTTP protocol semantics (use `http-semantics`), framework-specific route handler mechanics (use `route-handler-design`), non-HTTP system contracts (use `system-interface-contracts`), async event contracts (use `event-contract-design`), database design (use `entity-relationship-modeling`), inbound provider webhook mechanics (use `webhook-integration`), or post-failure diagnosis (use `debugging`).

6 installs
▌
Lint Overlay 2 · jacob-balslev bundle
Use 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).

5 installs
▌
Mckinsey 7s 2 · jacob-balslev bundle
Use when diagnosing organizational alignment with the McKinsey 7S framework: shared values, strategy, structure, systems, style, staff, and skills; how the seven elements reinforce or conflict; change-readiness gaps; and implementation risks. Covers internal organization effectiveness, operating-model alignment, transformation diagnostics, post-merger integration checks, and strategy-to-execution gap analysis. Do NOT use for external industry profit-pressure diagnosis (use porters-five-forces), activity-level value and cost mapping (use value-chain-analysis), durable resource advantage testing (use vrio), broad internal/external option generation (use swot-tows), or execution goal-setting alone (use okrs).

5 installs
▌
Positioning 2 · jacob-balslev bundle
Use when applying April Dunford-style product positioning to make a product's differentiated value obvious to the right buyers: competitive alternatives, unique attributes, value themes, best-fit target segments, market category, trend context, and reusable positioning output. Covers the Obviously Awesome 10-step workflow, positioning canvas logic, category choice, value-to-segment fit, and positioning-to-sales-message translation. Do NOT use for full strategy-cascade formulation (use playing-to-win), market-creating value innovation (use blue-ocean-strategy), industry-structure diagnosis (use porters-five-forces), or durable moat classification (use seven-powers).

5 installs
▌
AI Native Development 2 · jacob-balslev bundle
Use when reasoning about agent autonomy levels, designing auto-improve loops, evaluating AI-generated code quality, or measuring agent productivity in an LLM-assisted codebase. Covers Karpathy's three eras of software (1.0 explicit / 2.0 learned / 3.0 natural-language), the vibe-coding-vs-agentic-engineering distinction, the 0–5 autonomy slider with task-type recommendations, the one-asset / one-metric / one-time-box AutoResearch loop, Software 3.0 productivity metrics, and the documented quality regressions of ungated AI-generated code (the 'vibe hangover'). Do NOT use for choosing a specific autonomy-loop topology (use `agent-engineering`), for the per-prompt authoring discipline (use `prompt-craft`), or for reviewing the AI-generated code that comes out of a Software 3.0 workflow (use `code-review`).

5 installs
▌
Compression 2 · jacob-balslev bundle
This skill provides expertise in data and context compression: SaaS payload optimization (Zstd, Brotli, Gzip), database storage compression, and AI context window compression (Semantic Summarization, Token Pruning). Use when optimizing API latency, reducing storage costs, or managing long-running agent sessions near context limits. Do NOT use for image/video lossy compression (use product-photo) or file archiving.

5 installs
▌
Dark Mode Implementation 2 · jacob-balslev bundle
Use when implementing dark mode — prefers-color-scheme detection, theme persistence, flash-of-unstyled-theme prevention, color token mirroring, image and asset variants, and meta theme-color updates. Do NOT use for designing the dark palette itself, designing the token architecture, or generic theme-switching across more than two themes.

1 install
▌
Information Architecture 2 · jacob-balslev bundle
Use when structuring information for findability: navigation, page hierarchy, docs architecture, sitemap shape, labeling systems, wayfinding, and content grouping. Do NOT use for formal category-governance work (use `taxonomy-design`), responsive page composition (use `layout-composition`), component/token architecture (use `design-system-architecture`), or sentence-level UI text (use `microcopy`).

7 installs
▌
Keywords 2 · jacob-balslev bundle
Use when doing keyword research, evidence-quality triage of keyword sources, query normalization, mapping search intent, building topical clusters, choosing terms for product or marketplace listings, researching question/answer-intent and entity demand for AI search (AEO/GEO), detecting cannibalization, or translating query demand into page/listing targets. Covers seed expansion, intent classification, clustering, entity/topic research, platform field translation for Etsy, Amazon, Shopify, SaaS/content sites, long-tail marketplace strategy, marketplace semantic-intent (Amazon COSMO/Rufus) checks, cannibalization resolution, and rank/AI-citation tracking cadence. Do NOT use for building SEO pages, schema strategy, or AI-search content implementation (use `seo-strategy`), writing the finished prose (use `writing-humanizer`), or designing navigation/page hierarchy (use `information-architecture`).

5 installs
▌
Best Practice 2 · jacob-balslev bundle
Cross-cutting best practices enforcement across code, templates, skills, prompts, scripts, documentation, pages, and design. The enforcement layer that catches violations any specialist might miss. Do NOT use for deep code review methodology (use code-review), application security depth (use owasp-security), accessibility implementation depth (use a11y), or specialist design-system work (use design-system-architecture, color-system-design, or typography-system).

5 installs
▌
Diff Analysis 2 · jacob-balslev bundle
Use 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.

5 installs
▌
Lean Startup 2 · jacob-balslev bundle
Use when applying Lean Startup methodology to validate a new venture, product, feature, program, or business model under high uncertainty: build-measure-learn loops, minimum viable products, validated learning, riskiest assumptions, actionable metrics, innovation accounting, learning milestones, and pivot/persevere decisions. Covers experiment design and learning discipline before scaling. Do NOT use for generative customer interviews alone (use user-research), synthesizing existing research (use research-synthesis), feature satisfaction classification (use kano-model), OKR goal-setting, product positioning, or quantified option valuation.

6 installs
▌
Seven Powers 2 · jacob-balslev bundle
Use when diagnosing whether a business has, can build, or is falsely claiming durable strategic power using Hamilton Helmer's Seven Powers: scale economies, network economies, counter-positioning, switching costs, branding, cornered resource, and process power. Covers Power as benefit plus barrier, persistent differential returns, moat-source classification, Power Progression by company phase, false-positive checks, and strategy implications. Do NOT use for industry-structure analysis alone (use porters-five-forces), integrated strategy-cascade formulation (use playing-to-win), generic prioritization, financial valuation, or surface-level SWOT lists.

6 installs
▌
Design Module Composition 2 · jacob-balslev bundle
Use when designing reusable component modules — composition patterns, compound components, slot/children APIs, render props, headless component contracts, and the choice between configuration and composition. Do NOT use for application-level architecture, single-use feature components, or visual styling decisions.

5 installs
▌
Visual Design Foundations 2 · jacob-balslev bundle
Use when designing or auditing visual craft at foundation level: color palette, typography, spacing, elevation, rhythm, density, optical alignment, visual hierarchy direction, brand fit, contrast intent, and motion feel — making a surface more legible, polished, scannable, and tone-appropriate without changing its task structure. Do NOT use for sign-system meaning (use `semiotics`), token/component architecture (use `design-system-architecture`), responsive structure (use `layout-composition`), accessibility compliance (use `a11y`), or the DEEP contract of one dimension — formal color systems (use `color-system-design`), full type systems (use `typography-system`), deep hierarchy modeling (use `visual-hierarchy`), theming/token delivery (use `theme-system-design`), or interaction-state feedback (use `interaction-feedback`).

5 installs
▌
Semantics 2 · jacob-balslev bundle
Semantics: choosing and auditing the meaning encoded by names, status codes, versions, commits, tokens, and signals across code, APIs, and UIs.

6 installs
▌
Error Tracking 2 · jacob-balslev bundle
Use 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`).

6 installs
▌
Owasp Security 2 · jacob-balslev bundle
Use 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`).

6 installs
▌
Ansoff Matrix 2 · jacob-balslev bundle
Concept of the skill

5 installs
▌
Mental Models 2 · jacob-balslev bundle
Use when reasoning about how a system, user, or designer's internal model of behavior may diverge from reality — applies across UX, distributed systems, type systems, API design, and team collaboration. Covers the three-model frame (designer / system image / user), the two gulfs (execution and evaluation), analogy and metaphor as model-seeding, the five failure modes (transfer, overgeneralization, underspecification, drift, invariant blindness), the surface/operational/architectural/domain layering, and the discipline of validating a model against the system it claims to represent. Do NOT use for the visual representation of a model (use knowledge-modeling), for the formal-domain entities-attributes-relationships of conceptual modeling (use conceptual-modeling), for cognitive biases in decision-making (out of scope), or for empirically eliciting user models via research methods (use user-research).

4 installs
▌
Stp Marketing 2 · jacob-balslev bundle
Use when building, reviewing, or repairing an STP marketing strategy: segmentation, targeting, and positioning as one linked sequence from market definition to segment profiles, target selection, positioning statement, and marketing-mix implications. Covers consumer, B2B, nonprofit, and product-led contexts; segment bases; segment attractiveness; fit; primary/secondary targets; differentiated versus concentrated targeting; perceptual maps; positioning statements; evidence gaps; and handoff to campaign, product, pricing, channel, or sales work. Do NOT use for standalone product positioning/category design without segmentation and target choice (use positioning), macro-environment scanning (use pestel), industry profit-pressure diagnosis (use porters-five-forces), value-curve redesign/new-demand creation (use blue-ocean-strategy), product-market growth-path selection (use ansoff-matrix), or tactical marketing-mix design alone.

6 installs
▌
Task Analysis 2 · jacob-balslev bundle
Use when auditing a route, defining a route contract, reviewing onboarding or setup flows, diagnosing why a page feels confusing, or when the user asks about top tasks, time-to-value, branching, dead ends, or task complexity. Provides goal-driven UX analysis that turns vague critique into explicit goal -> task -> subtask decomposition and a primary / secondary / supporting hierarchy contract for the first viewport. Do NOT use for control-pattern choice (use `interaction-patterns`), visual craft (use `visual-design-foundations`), responsive layout (use `layout-composition`), or accessibility-only QA (use `a11y`).

5 installs
▌
Intent Recognition 2 · jacob-balslev bundle
Use BEFORE any tool call that could modify state, touch sensitive targets, rewrite history, install dependencies, publish packages, or expose credentials/environment data. Classifies intent into Passive/Read, Reconnaissance, Modification, or Destructive/Irreversible using operation type plus target sensitivity, then runs Identify / Confirm / Verify before action. Do NOT use for deciding what code to write, executing already-classified work, reactive post-execution guardrails, or defining upstream governance policy.

5 installs
▌
Tool Call Strategy 2 · jacob-balslev bundle
Use when an agent is making too many tool calls, when context is filling from verbose tool outputs, when the same operation could be a script instead of N individual calls, or when designing a tool-use protocol for a new agent or harness. Covers the three costs of every call (token, latency, context pollution), the script-vs-call decision gate, tool-selection decision trees (file-search vs content-search vs targeted-read vs full-read), call batching and parallelization, redundancy avoidance, the poka-yoke principle, subagent delegation for context protection, and cost-benchmark heuristics by task type. Do NOT use for prompt wording (use `prompt-craft`), broader context stack design across the five layers (use `context-engineering`), runtime tool failures or production debugging (use `debugging`), or behaviour-preserving refactor mechanics (use `refactor`).

5 installs
▌
Schema Evolution 2 · jacob-balslev bundle
Use when reasoning about how a database schema changes over time without breaking deployed application code — the multi-release path from the current schema to a target schema: the expand/contract pattern (Ambler & Sadalage / Fowler's parallel change), the zero-downtime change rules, the backwards-and-forwards compatibility envelope (deploy ordering and rollback discipline), the catalog of schema changes (add column, drop column, rename, type change, add constraint, add index) and the safe procedure for each, the dual-write and dual-read transitions (with named source-of-truth and production consistency-check discipline) that make non-trivial changes safe, the lock-acquisition hazard (why even a metadata-only DDL needs a bounded lock-acquisition budget — Postgres lock_timeout + retry, or the engine equivalent — because lock acquisition is a FIFO queue), the cross-engine online-change mechanisms (Postgres CONCURRENTLY / NOT VALID, MySQL INSTANT/INPLACE/COPY Online DDL, gh-ost / pt-osc ghost-table cutover, Vite

5 installs
▌
Ref Patterns 2 · jacob-balslev bundle
Use when designing or reviewing React ref usage: the distinction between refs (mutable handle that survives renders without triggering them) and state (reactive value that triggers renders when changed), the `useRef` hook for DOM access and mutable instance values, ref callbacks for fine-grained mount/unmount hooks, `forwardRef` for passing refs through component boundaries (and the React 19 ref-as-prop change that retires it for new code), `useImperativeHandle` for exposing a controlled imperative surface to parent refs, ref forwarding through compound-component primitives (the Radix `Slot` / Headless UI pattern), and the design rule that refs are an escape hatch — for DOM access, integration with non-React DOM libraries, focus management, animation, measurement, and exposing imperative APIs sparingly, never as a substitute for state. Do NOT use for the broader hook discipline — Rules of Hooks, dependency arrays, custom hooks (use hooks-patterns), for the cross-product component-layering question — primitive

9 installs
▌
E2e Test Design 2 · jacob-balslev bundle
Use 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).

5 installs
▌
Expected Value 2 · jacob-balslev bundle
Use 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).

5 installs
▌
Playing To Win 2 · jacob-balslev bundle
Use when turning a vague business strategy, product strategy, market-entry decision, or initiative plan into an integrated Playing to Win strategy cascade: winning aspiration, where to play, how to win, must-have capabilities, and management systems. Covers Lafley/Martin choice-making, fit across the five choices, trade-off pressure, reverse tests, capability-system alignment, and the difference between strategy and planning. Do NOT use for competitive-industry structure analysis (use a five-forces skill when available), generic backlog scoring (use prioritization), or broad process-gate design (use methodology).

5 installs
▌
Three Horizons 2 · jacob-balslev bundle
Use when balancing an innovation, growth, transformation, or venture portfolio across McKinsey's Three Horizons: Horizon 1 current core businesses, Horizon 2 emerging growth businesses, and Horizon 3 future options. Covers concurrent portfolio balance, resource allocation (the 70-20-10 benchmark and its caveats), evidence maturity, governance and metrics by horizon, metered funding, ring-fenced budgets, transitions from option to emerging business to core, the collapsed-time critique that disruption can now arrive on core timelines, and the risk that short-term core demands or incentives starve future growth. Do NOT use for BCG growth-share portfolio allocation (use bcg-matrix), Ansoff product-market growth path selection (use ansoff-matrix), Blue Ocean value-curve redesign (use blue-ocean-strategy), scenario construction and stress-testing across alternative futures (use scenario-planning), OKR goal-setting (use okrs), or quantified probability-weighted valuation (use expected-value).

7 installs
▌
Autonomous Loop Patterns 2 · jacob-balslev bundle
Use when designing, reviewing, or debugging an autonomous AI agent loop: repeated agent execution, completion signals, checkpoints, supervisor respawn, stall detection, safety caps, and human handoff rules. Covers the core loop patterns from simple bounded runs through sentinel-based continuation, checkpoint-resume, and external supervisor loops. Do NOT use for choosing a specific agent product command (use agent-engineering or the product's docs), writing ordinary task instructions (use prompt-craft), or optimizing individual tool calls (use tool-call-strategy).

6 installs
▌
HTTP Semantics 2 · jacob-balslev bundle
Use when designing or reviewing HTTP-based systems where method semantics, status codes, idempotency, safe methods, conditional requests, content negotiation, caching headers, range requests, integrity digests, or representation metadata are load-bearing. Covers the RFC 9110/9111/9112 contract layer below any specific framework. Do NOT use for API surface shape and route taxonomy (use api-design), for WebSocket or SSE bidirectional streams (use streaming-architecture skill when available), for vendor-specific webhook signing (use webhook-integration), or for transport-level concerns like TLS or QUIC (use platform-level documentation).

5 installs
▌
Indexing Strategy 2 · jacob-balslev bundle
Use when designing or auditing the maintained index set for a database workload: choosing index structures, matching access patterns, setting composite order, balancing read speed against write/storage cost, and deciding when to add, keep, or drop indexes. Do NOT use for tuning one slow query (use query-optimization), applying production DDL (use database-migration), isolation choices, schema design, or sharding.

4 installs
▌
Sharding Strategy 2 · jacob-balslev bundle
Use when reasoning about horizontal partitioning of data across nodes for storage capacity and write throughput beyond a single node: the three foundational partitioning schemes (range, hash, directory/lookup), the shard-key choice that determines whether the system scales or hotspots, the resharding problem and how consistent hashing addresses it, cross-shard queries and the joins-and-transactions trade-off, the relationship to replication (sharding partitions data; replication copies each shard), and the failure modes (hot shard, skewed distribution, cross-shard transactions, range-end overload). Do NOT use for replicating the same data across nodes (use replication-patterns), the CAP/PACELC frame (use cap-theorem-tradeoffs), single-node performance tuning (use query-optimization), or indexing within a shard (use indexing-strategy).

5 installs
▌
Generative UI 2 · jacob-balslev bundle
Use when reasoning about the pattern where a language model emits, as structured output, a description of UI components or a UI sub-tree that an application then renders for the user: the typed-schema component palette, the structured-output mechanism (JSON Schema, function-calling) that constrains emission to renderable specs, the two render substrates (typed-component-tree vs sandboxed-iframe), the application-side render pipeline that turns the spec into pixels, the bidirectional interaction loop (postMessage/JSON-RPC) by which user actions on the rendered UI flow back into the next turn, the security boundary between model-author and application-renderer, and the difference between this and adjacent patterns (chat with markdown, prebuilt-widget routing, RSC streaming, model-emits-code). Do NOT use for the page-level rendering taxonomy (use rendering-models), the protocol cycle of tool calls (use tool-call-flow), the trust boundary against untrusted content (use prompt-injection-defense), or general compon

5 installs
▌
Linguistics 2 · jacob-balslev bundle
Use when choosing semantically precise names for files/functions/variables/types/columns, resolving overloaded terms, reviewing error messages or UI copy for blame/register clarity, or adapting language for end-user/agent/developer/global-audience contexts. Covers morphology, compound-word order, abbreviation policy, verb-noun naming, polysemy qualification, audience register, blame-free error structure, and cross-cultural language awareness. Do NOT use for casing convention policy (use `naming-conventions`), call-site-wide renames (use `refactor`), docs/navigation structure (use `information-architecture`), specialized UI text pattern catalogs (use `microcopy`), or final prose humanization (use `writing-humanizer`).

5 installs
▌
Contract Testing 2 · jacob-balslev bundle
Contract testing: interface verification between consumers and providers via shared contract artifacts and independent two-phase verification.

5 installs
▌
Mutation Testing 2 · jacob-balslev bundle
Use 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).

5 installs
▌
Snapshot Testing 2 · jacob-balslev bundle
Use 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`).

7 installs
▌
Testing Strategy 2 · jacob-balslev bundle
Use 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).

5 installs
▌
Problem Framing 2 · jacob-balslev bundle
Use when a team is converging on solutions before agreeing on the problem, when a brief reads as a feature request, when symptoms and root needs are tangled, or when assumptions need surfacing before design work proceeds. Do NOT use for code-level bug triage, runtime failure diagnosis, or root-cause analysis of system errors — those are engineering investigation tasks, not design problem framing.

4 installs
▌
Background Jobs 2 · jacob-balslev bundle
Use when moving slow or failure-prone work out of a request path, designing job queues, retries, checkpoints, progress reporting, cancellation, or worker concurrency. Covers inline-vs-background decisions, queue contracts, state machines, idempotency, retry/backoff, progress signals, worker leases, and user-visible completion reporting. Do NOT use for time-based schedule design (use `cron-scheduling`), live browser transport choice (use `real-time-updates`), or async message schema ownership (use `event-contract-design`).

5 installs
▌
Cron Scheduling 2 · jacob-balslev bundle
Use when designing time-based scheduled work in web applications: Vercel Cron routes, Inngest cron-triggered functions, recurring-job idempotency, overlap prevention, retry/failure handling, UTC/timezone decisions, and monitoring for missed or failed schedules. Covers cron expressions, scheduler selection, authorization of cron endpoints, dispatch-to-worker patterns, execution-window idempotency, concurrency locks, and heartbeat/alert design. Do NOT use for general background job queue architecture (use background-jobs), event-driven orchestration without a time trigger, browser freshness transports, or one-off task debugging unrelated to recurring schedules.

7 installs
▌
Database Migration 2 · jacob-balslev bundle
Use when planning or applying a raw-SQL database migration to a live PostgreSQL database — adding columns, renaming columns or tables, changing types, creating indexes, adding foreign keys, or running data backfills. Covers zero-downtime patterns (expand / contract, batched backfill, NOT VALID foreign keys, CONCURRENTLY indexes), the direct/unpooled connection requirement for migration tooling, branched-database workflows, and rollback strategy. Do NOT use for ORM-managed migrations driven by Prisma/Drizzle/TypeORM CLI scaffolding, for chasing a migration that has already failed in production (use debugging), for multi-release schema lifecycle planning outside one migration (use schema-evolution), or for designing the row-level-security model itself (use owasp-security).

5 installs
▌
Query Optimization 2 · jacob-balslev bundle
Diagnosing and tuning a specific slow relational-database query from plan evidence: workload impact, exact query context, EXPLAIN / actual execution plans, row-estimate accuracy, access path choice, join order, sort/hash spills, JIT/planning overhead, parameter-sensitive plans, plan regressions, statistics, and rewrite-vs-index-vs-operational response selection. Start from the actual plan and runtime evidence, not from the reflex to add an index; modern engine features such as Query Store, PSP/OPPO, SQL Plan Management, pg_stat_statements, auto_explain, MySQL histograms, Oracle DBMS_XPLAN, and PostgreSQL planner improvements are evidence sources and response tools, not replacements for diagnosis. Do NOT use for designing the durable index portfolio (use indexing-strategy), schema design (use entity-relationship-modeling), distributed partitioning (use sharding-strategy), isolation-level correctness (use transaction-isolation), or whole-system load testing (use performance-testing).

4 installs
▌
Error Boundary 2 · jacob-balslev bundle
Use when designing or reviewing React error boundaries: what an error boundary catches (rendering errors, lifecycle errors, constructor errors) and what it does not (event handler errors, async errors, SSR errors, errors in the boundary itself), why React still requires class components for error boundaries, how to place boundaries by granularity (page / feature / leaf), how error boundaries pair with Suspense, the reset-and-recover pattern (resetKeys, error.reset), the Next.js error.tsx route-segment convention, and how to integrate boundaries with error reporting (Sentry, observability). Covers React 18+ and Next.js App Router. Do NOT use for Suspense boundary placement (use suspense-patterns), for general error-handling discipline (try/catch in async code, validation errors), for backend error contracts (use api-design), or for observability infrastructure (use error-tracking).

5 installs
▌
Hooks Patterns 2 · jacob-balslev bundle
Use when reasoning about React Hooks as a discipline: why the Rules of Hooks exist as a call-order invariant, how dependency arrays encode a contract between closure and rerender, when useEffect is the wrong primitive, the distinction between derived state and stored state, when to extract a custom hook, when memoization (useMemo, useCallback, memo) is useful or obsolete, and how React 18/19 semantics (automatic batching, concurrent rendering, Strict Mode effect checks, Effect Events, React Compiler) change the calculus. Do NOT use for general React rendering models (use rendering-models), the client/server boundary (use client-server-boundary), component API architecture (use component-architecture), Suspense boundary design (use suspense-patterns), or application-wide state location (use state-management).

5 installs
▌
Scenario Planning 2 · jacob-balslev bundle
Scenario planning: a strategic-foresight method for making decisions under deep uncertainty by constructing and stress-testing several plausible future worlds.

5 installs
▌
Event Storming 2 · jacob-balslev bundle
Use when discovering a domain through events, commands, actors, policies, aggregates, read models, external systems, and temporal workflows before implementation. Do NOT use for event schema/topic contracts (use `event-contract-design`), webhook handler implementation (use `webhook-integration`), generic state transition modeling (use `state-machine-modeling`), or persistence schema design (use `entity-relationship-modeling`).

8 installs
▌
Refactor 2 · jacob-balslev bundle
Use when reorganizing existing code without changing external behavior — extracting functions, reducing duplication, renaming for clarity, splitting modules, or tightening structure. Covers behavior preservation, duplication reduction, decomposition, naming improvements, structural reorganization, and before/after verification. Do NOT use for bug investigation, adding new product behavior, or writing documentation (even when the docs describe the refactored code).

5 installs
▌
Real Time Updates 2 · jacob-balslev bundle
Use when designing browser-facing freshness for live dashboards, notifications, progress views, feeds, and data that can change after initial render. Covers freshness contracts, transport choice among adaptive polling, Server-Sent Events, and bidirectional sockets, webhook-to-UI propagation, client cache invalidation, stale-data indicators, reconnect and catch-up behavior, centralized subscription ownership, and non-disruptive update UX. Do NOT use for low-level stream/backpressure protocol design (use `streaming-architecture`), async event envelope/topic contracts (use `event-contract-design`), recurring schedule design (use `cron-scheduling`), durable worker execution semantics (use `background-jobs`), generic UI action feedback (use `interaction-feedback`), or serialization/trust boundaries (use `client-server-boundary`).

6 installs
▌
Replication Patterns 2 · jacob-balslev bundle
Use when designing how a database keeps multiple copies of its data in agreement across nodes for availability, read scaling, and disaster recovery: the three foundational topologies (single-leader / primary-replica, multi-leader / multi-primary, leaderless / quorum), synchronous vs asynchronous replication and the replication-lag trade-off, log shipping vs statement replication vs trigger-based replication, the read-after-write consistency problem and its mitigations (sticky session, read-from-leader, monotonic reads), the failover model and split-brain risk, and the relationship to the CAP/PACELC choices the topology realizes. Do NOT use for horizontal partitioning across nodes (use sharding-strategy), the CAP theoretical frame itself (use cap-theorem-tradeoffs), single-node transactional guarantees (use transaction-isolation), or query tuning (use query-optimization).

3 installs
▌
Rendering Models 2 · jacob-balslev bundle
Use when reasoning about how a web UI is produced and delivered: client-side rendering, server-side rendering, static-site generation, incremental static regeneration, React Server Components, streaming SSR, edge rendering, and partial prerendering. Covers the time × place grid (build/request/stream/interaction × server/edge/client), the trade-offs between first-paint latency and time-to-interactive, the relationship between rendering and hydration, and how a route's content profile (dynamic / static / personalized) maps to a model. Do NOT use for organizing the frontend codebase (use frontend-architecture), the serialization frontier between server and client code (use client-server-boundary), the wire protocol itself (use http-semantics), or specific deploy-platform composition patterns (use vercel-composition-patterns).

6 installs
▌
State Management 2 · jacob-balslev bundle
Use when deciding where state lives, how it propagates, and how it composes: local component state vs lifted/shared state vs application state, server state vs client state, URL as state, persistent state, derived state, and the cross-cutting decision of who owns which piece. Covers state colocation, lifting up, derivation vs duplication, single source of truth, optimistic updates, server-state cache invalidation (React Query/SWR model), URL state for deep-linking, and anti-patterns like prop-drilling, state sprawl, and global-state-by-default. Do NOT use for specific state library choice (Redux vs Zustand — tactical), data fetching mechanics (use api-design or rendering-models), client/server boundary (use client-server-boundary), distributed system state (use replication-patterns), or finite state machines (use state-machine-modeling).

4 installs
▌
Performance Budgets 2 · jacob-balslev bundle
Use 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).

5 installs
▌
Performance Testing 2 · jacob-balslev bundle
Use 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`).

5 installs
▌
Test Doubles Design 2 · jacob-balslev bundle
Use 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).

6 installs
▌
Balanced Scorecard 2 · jacob-balslev bundle
Use 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).

5 installs
▌
Bayesian Reasoning 2 · jacob-balslev bundle
Use 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).

5 installs
▌
Debugging 2 · jacob-balslev bundle
Use when behavior is broken, a test is failing, or runtime output contradicts expectations. Covers failure reproduction, scope reduction by bisection, evidence capture at the moment of failure, root-cause isolation (not symptom patching), fix verification against the same evidence path, and regression-test creation. Do NOT use for feature planning, architectural design, or behavior-preserving refactor.

5 installs
▌
Diagnosis 2 · jacob-balslev bundle
Use when facing an unknown software failure, when symptoms point to different root causes, or when an initial debugging attempt has not converged. Provides a triage-first diagnostic routing framework: classify the failure, collect the right evidence, choose a technique, track confidence, and escalate when stuck. Do NOT use for executing scientific debugging after triage (use `debugging`), code-quality review (use `code-review`), or proactive observability setup.

5 installs
▌
Connection Pooling 2 · jacob-balslev bundle
Use when reasoning about how an application manages its database connections: why every connection has a server-side cost, the difference between application-level pools (HikariCP, pgx pool, node-postgres Pool) and proxy-level pools (PgBouncer, Pgpool, ProxySQL), the three PgBouncer modes (session, transaction, statement) and their feature compatibility, the canonical pool-sizing math (Little's Law applied to database concurrency; Wooldridge's analyses), the failure modes (connection exhaustion, hot-loop reconnects, prepared-statement breakage under transaction pooling, idle-in-transaction leaks), and the diagnostic procedure when a workload is contending on connections instead of query work. Do NOT use for query-level performance (use query-optimization), for index design (use indexing-strategy), for read/write replica routing (use replication-patterns), or for cross-shard query coordination (use sharding-strategy).

6 installs
▌
Cap Theorem Tradeoffs 2 · jacob-balslev bundle
Use when reasoning about the consistency-availability-partition-tolerance trade-off for distributed data systems: Brewer's CAP conjecture (2000), Gilbert & Lynch's 2002 formal proof, why P is not optional in any real distributed system, the CP-vs-AP dichotomy that follows, PACELC as the extension that names the latency-vs-consistency trade-off that exists even without partition, the relationship between CAP's C and ACID's C (different concepts with the same letter), and the choice procedure of naming what the system must guarantee under partition. Do NOT use for single-node transactional guarantees (use transaction-isolation), choosing an isolation level (use transaction-isolation), the design of replication topologies (use replication-patterns), or sharding decisions (use sharding-strategy).

5 installs
▌
Suspense Patterns 2 · jacob-balslev bundle
Use when designing or reviewing React Suspense usage: where to place Suspense boundaries to control loading granularity, the difference between Suspense for data fetching and Suspense for code splitting, how Suspense interacts with Server Components for streaming HTML, how error boundaries pair with Suspense (and why they must be distinct components), the relationship between Suspense and React's transition APIs (useTransition, startTransition), and the design rules that prevent waterfall fetches, layout shift, and SEO regressions. Covers React 18+ and 19's `use` hook for unwrapping Promises in Client Components. Do NOT use for general React rendering strategy choice (use rendering-models), for the underlying hook primitives (use hooks-patterns), for streaming protocols beyond Suspense (use streaming-architecture), or for Server Component design (use server-components-design).

5 installs
▌
Semantic Center 2 · jacob-balslev bundle
Use when you need to explain how parts of a system, feature, concept, page, workflow, or problem connect; identify the single most important part of something; untangle dense dependencies into a core plus typed relations; or answer 'what is the load-bearing part?' without drifting into implementation or task prioritization. Provides a five-step workflow — classify the unit of analysis, find the single primary part using removal/governance/purpose/weight/decision tests, map secondary parts via typed relations (dependency, input/output, parent/child, owner/owned, cause/effect, constraint/enabler, and others), produce a structured output, and reduce the whole to one final sentence — that forces explanation through one-primary reduction rather than flat lists or chronology. Do NOT use for implementation work (use the relevant domain skill), choosing what to do next (use a prioritization skill), or formal architectural-ownership design (use a domain-modeling skill).

8 installs
▌
Taxonomy Design 2 · jacob-balslev bundle
Use when designing a controlled classification system: category trees, facets, browse taxonomies, SKOS broader/narrower relationships, tagging rules, and duplicate-category cleanup. Do NOT use for formal ontology axioms with reasoning constraints (use `ontology-modeling`), broad knowledge-representation choice (use `knowledge-modeling`), or one-off edge typing (use `semantic-relations`).

6 installs
▌
Blue Ocean Strategy 2 · jacob-balslev bundle
Use 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).

3 installs
▌
Epistemic Grounding 2 · jacob-balslev bundle
Use 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).

5 installs
▌
Pattern Recognition 2 · jacob-balslev bundle
Use when auditing for recurring issues, clustering errors, detecting drift from conventions, or when an agent keeps fixing symptoms instead of root causes. Covers the Observe -> Cluster -> Name -> Codify -> Detect -> Prevent loop, grep-based audits, normalize-then-hash error clustering, board-health patterns, design-token and heading drift, domain-encoding patterns, eval-as-pattern-tests, 5 Whys, pattern lifecycle states, and drift traps. Do NOT use for one-off bug localization without recurrence, or for designing the classification system itself; this skill detects violations of conventions that already exist.

5 installs
▌
Porters Five Forces 2 · jacob-balslev bundle
Use when analyzing an industry's competitive structure and profit pool using Porter's Five Forces: rivalry among existing competitors, threat of new entrants, bargaining power of suppliers, bargaining power of buyers, and threat of substitutes. Covers industry-boundary definition, force-by-force diagnostics, structural drivers, dynamic trends, profitability implications, strategic positioning options, and the distinction between industry attractiveness and firm-specific advantage. Do NOT use for creating an integrated strategy cascade (use playing-to-win), classifying durable moat sources (use Seven Powers when available), backlog scoring (use prioritization), or generic market sizing.

6 installs
▌
Methodical 2 · jacob-balslev bundle
Enforces disciplined, complete, evidence-backed execution for tasks where honesty and coverage matter more than brevity: audits, diagnostic reports, tracked-task creation from findings, acceptance-criteria verification, research briefs, and any enumerated output that later work will depend on. Teaches WHY agents fail at completeness — sycophancy, premise adoption, summary-first compression, instruction-density loss, long-horizon attention decay, self-critique echo chambers, reasoning-masked agreement, verification theater, and delegation-as-proof — and the structural countermeasures: pre-task scope declaration, count-preserving enumeration, step-level evidence receipts, externally grounded critique, provenance labels, explicit partial/completeness receipts, and runtime enforcement where available. Do NOT use for choosing the shortest task route (use `task-path-optimization`), broad artifact-quality standards (use `best-practice`), result scoring (use `evaluation`), the compact pre-output enforcement gate (use

7 installs
▌
Graph Audit · jacob-balslev bundle
Use 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.

9 installs
▌
SEO Strategy · jacob-balslev bundle
SEO implementation strategy for building pages that rank -- covering content strategy, programmatic SEO at scale, marketplace-specific SEO, and AI search optimization.

10 installs
▌
Secrets Management · jacob-balslev bundle
Managing 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.

11 installs
▌
Caching Strategies · jacob-balslev bundle
Deciding what to cache, where, and how to keep it coherent — trading freshness for speed and load reduction across the cache layers (client, CDN/edge, application in-memory, distributed cache, database). Covers the two hard problems (cache invalidation and choosing the layer), the write/read patterns (cache-aside/lazy, read-through, write-through, write-behind, refresh-ahead), expiry and TTL design, eviction policies (LRU/LFU/FIFO/TTL), staleness budgets and tolerated inconsistency, cache coherence and invalidation strategies (TTL expiry, explicit invalidation, key/tag versioning, write-through), the thundering-herd / cache-stampede problem and its mitigations (request coalescing, locks, jitter, stale-while-revalidate), HTTP caching semantics (Cache-Control, ETag, conditional requests, stale-while-revalidate/stale-if-error), CDN and edge caching, multi-layer cache hierarchies, cache key design and cardinality, negative caching, and measuring hit ratio and the cost of a miss. Stack-agnostic across Redis/Memcac

10 installs
▌
Skill Evolution · jacob-balslev bundle
Use when running or auditing Skill Graph's corpus-level `evolve` operation: the continuous skill-improvement loop that analyzes a skill library, triages a priority queue, executes bounded improve/scaffold/eval-generation actions, verifies the result, records checkpoints, and repeats. Covers `skill-graph evolve`, `lib/audit/skill-evolution-loop.js`, the Karpathy keep-or-revert spine, the priority signals based on Audit Status, standalone workspace flags, and the boundary between corpus walking and single-skill audit/improve/evaluate operations. Do NOT use for initial skill scaffolding alone (use skill-scaffold), single-skill schema/eval checks (use graph-audit or the audit operation), or generic evaluation rubric design (use evaluation / eval-driven-development).

9 installs
▌
CI CD Pipelines · jacob-balslev bundle
Designing continuous integration and continuous delivery pipelines that turn every commit into a verified, releasable artifact and move it safely toward production. Covers the CI/CD distinction (integration vs delivery vs deployment), the pipeline as a staged graph of fast-to-slow gates, trunk-based integration and short-lived branches, build-once/promote-the-same-artifact discipline, hermetic and reproducible builds, dependency and layer caching for fast feedback, the test pyramid mapped onto pipeline stages, required status checks and branch protection, quality and security gates (lint, type-check, SAST, dependency/SCA scanning, license checks) as blocking vs advisory, artifact and container registries with immutable versioning and provenance, environment promotion (build → test → stage → prod), deployment strategies the pipeline triggers (blue-green, canary, rolling, feature-flag-gated), pipeline secrets and least-privilege CI credentials (OIDC over long-lived tokens), DORA delivery metrics (deployment fre

12 installs
▌
Experimentation · jacob-balslev bundle
Designing, running, and interpreting controlled experiments to decide whether a change is genuinely better — online A/B tests, randomized controlled trials, and offline hypothesis tests. Covers hypothesis framing, randomization and unit-of-assignment, sample-size and statistical-power calculation, metric design (primary, guardrail, invariant, and the overall evaluation criterion), variance reduction (CUPED/CUPAC) for sensitivity, significance testing and confidence intervals, sequential and anytime-valid testing for the peeking problem, multiple-comparison correction, the trust checklist led by sample-ratio-mismatch, interference-aware designs (cluster and switchback), long-term holdouts and reverse experiments, bandit/adaptive-allocation boundaries, experiment ethics and blast-radius limits, quasi-experimental fallbacks when randomization is infeasible, and the validity threats that quietly invalidate results (novelty and primacy effects, interference/SUTVA violations, Simpson's paradox, and survivorship).

10 installs
▌
Canonical Repo Structure · jacob-balslev bundle
Use when organizing or cleaning a project/repository so every script, command, prompt, doc, generated artifact, compatibility shim, and legacy path has one canonical home under version control. Covers owner selection, repo-boundary verification, generated-vs-authored separation, duplicate implementation cleanup, compatibility-shim registration, delete-to-git-history discipline, timestamped changelog explanations, and path-limited commits in the owning repo. Do NOT use for ordinary branching/rebase/tag strategy alone (use `version-control`), behavior-preserving code restructuring alone (use `refactor`), documentation-sync routing alone (use `doc-updater`), or controlled category taxonomy design alone (use `taxonomy-design`).

45 installs
▌
Skill Router · jacob-balslev bundle
Use when routing an agent request across multiple skills, building or auditing a routing table, detecting routing coverage gaps, or answering questions like 'which skill handles this?', 'who routes X?', or 'why did skill A activate instead of B?'. Covers trigger-label matching, file-path matching, keyword matching, description-based semantic matching, project-fit filtering, relation-aware co-loading and exclusion, eval/staleness annotations, and coverage-gap detection. Do NOT use when the target skill is already known (load it directly), when authoring a new skill (use `skill-scaffold` instead), or when evaluating a SINGLE skill's quality (use `graph-audit`).

9 installs
▌
Payment Provider Router · jacob-balslev bundle
Use when dispatching a verified payment event (Stripe webhook or future provider) to the correct downstream handler based on event type. Routes `checkout.session.completed` to subscription provisioning, `invoice.payment_failed` to dunning logic, and `customer.subscription.deleted` to cancellation. Do NOT use for signature verification of the incoming event (use stripe-webhook-signature-verification first) or for the actual subscription database writes (use the per-handler skill or postgres-rls-pattern).

8 installs
▌
Migrate Posts To V2 Frontmatter · jacob-balslev bundle
Use when migrating every existing post in `content/posts/**/*.md` to the v2 frontmatter schema — adding the new required `summary` field, normalizing `tags` to the controlled vocabulary, converting bare-date `date` strings to ISO 8601 with timezone, and re-validating every post against the v2 schema before the next build runs. Activate this skill whenever the task references migration `0007-frontmatter-v2`, the v2 frontmatter rollout, or asks how to safely change a required-field set across a populated content tree without breaking the build. Do NOT use for unrelated migrations (use a generic content-migration skill or write a fresh one) or for general schema-design questions (use a schema-design skill).

10 installs
▌
Nextjs Server Action Validation · jacob-balslev bundle
Use when writing a Next.js Server Action that accepts user-submitted form data, mutation parameters, or any client-originated input. Every Server Action is a public HTTP endpoint regardless of how it is called — validate with Zod and check authentication as the first two operations before touching the database. Do NOT use for GET route handlers or Server Components that fetch data (those have no user-supplied input); do NOT use for Stripe webhook handlers (use stripe-webhook-signature-verification instead).

10 installs
▌
Image Optimization Pipeline Config · jacob-balslev bundle
Use when authoring or reviewing the build-time image pipeline config — defining responsive srcset breakpoints, picking output formats (AVIF / WebP / JPEG fallback), tuning compression quality per format, and ensuring the pipeline never produces a lossy artifact for source PNGs with transparency. Activate this skill whenever the task touches `lib/images/pipeline.config.ts`, `scripts/build-images.ts`, or any code path that resizes or recompresses content images. Do NOT use for runtime image rendering choices (use a frontend skill) or for chasing a specific build failure (use debugging).

10 installs
▌
Migrate Orders To Canonical Schema · jacob-balslev bundle
Use when running migration 0004 that normalizes the orders table from a Stripe-specific shape (stripe_session_id, stripe_customer_id as top-level columns) to a canonical provider-agnostic shape (provider, provider_order_id, provider_customer_id). Covers the four-phase safe migration procedure — add nullable columns, backfill from existing data, validate, drop legacy columns — and the RLS policy update that must accompany the column rename. Do NOT use for unrelated schema migrations (write a fresh skill anchored to that migration's number), for designing a new canonical schema from scratch, or for the ongoing orgQuery access pattern (use postgres-rls-pattern).

10 installs
▌
Markdown Post Frontmatter Validation · jacob-balslev bundle
Use when authoring or reviewing the frontmatter of a markdown post — checking required fields (title, date, slug, tags), validating against the content schema in `lib/content/schema.ts`, catching ambiguous date formats or tags not in the controlled vocabulary, and ensuring the slug matches the file path. Activate this skill whenever the task touches files under `content/posts/**/*.md`, the `parsePostFrontmatter()` helper, or any code path that reads YAML frontmatter from a content file. Do NOT use for general YAML schema design (use a generic schema-design skill) or for chasing a specific build-time validation failure (use debugging).

12 installs
▌
Stripe Webhook Signature Verification · jacob-balslev bundle
Use when validating incoming Stripe webhook requests in a Node.js or Next.js backend before processing any payment event. Verifies the `stripe-signature` header against `STRIPE_WEBHOOK_SECRET` using Stripe's HMAC-SHA256 scheme, and rejects replays older than 300 seconds. Do NOT use for general HTTP signature validation (use a generic crypto-signature skill), for processing the webhook payload after signature is confirmed (use payment-provider-router), or for Stripe API calls that are not webhook-driven.

10 installs
▌
Design Module Composition · jacob-balslev
Use when designing reusable component modules — composition patterns, compound components, slot/children APIs, render props, headless component contracts, and the choice between configuration and composition. Do NOT use for application-level architecture, single-use feature components, or visual styling decisions. Do NOT use for Choose the border radius value for cards. Do NOT use for Decide where the OrderDetailPage component lives in the folder structure. Do NOT use for Pick the brand font for headings.

12 installs
▌
First Principles Thinking · jacob-balslev
Use when a problem is trapped inside inherited assumptions, copied convention, analogy, or local optimization and needs to be rebuilt from irreducible premises. Covers decomposition to primitives, assumption stripping, primitive tests, reconstruction from constraints, derivation chains, and reality checks. Do NOT use for root-cause analysis of an observed failure (use debugging or problem-locating-solving), formal argument grounding (use epistemic-grounding), domain entity modeling (use conceptual-modeling), or recurring issue clustering (use pattern-recognition). Do NOT use for This incident happened yesterday. Find the root cause. Do NOT use for Update the probability after new evidence arrives. Do NOT use for Score these options by expected monetary value. Do NOT use for Imagine this plan failed and list why.

18 installs
▌
Visual Design Foundations · jacob-balslev
Use when designing or auditing visual craft at foundation level: color palette, typography, spacing, elevation, rhythm, density, optical alignment, visual hierarchy direction, brand fit, contrast intent, and motion feel — making a surface more legible, polished, scannable, and tone-appropriate without changing its task structure. Do NOT use for sign-system meaning (use `semiotics`), token/component architecture (use `design-system-architecture`), responsive structure (use `layout-composition`), accessibility compliance (use `a11y`), or the DEEP contract of one dimension — formal color systems (use `color-system-design`), full type systems (use `typography-system`), deep hierarchy modeling (use `visual-hierarchy`), theming/token delivery (use `theme-system-design`), or interaction-state feedback (use `interaction-feedback`). Do NOT use for what does this icon or badge color communicate to users? Do NOT use for define semantic tokens and component variants.

13 installs
▌
Data Modeling Fundamentals · jacob-balslev
Use when reasoning about the theory beneath data modeling: Codd's relational model and algebra, normal forms from 1NF through 5NF/BCNF, functional dependencies and closure, Chen ER modeling, principled denormalization, relational-vs-document tradeoffs, and immutable-data alternatives such as event sourcing or append-only tables. Do NOT use for practical persistence design (use entity-relationship-modeling), applying schema changes (use schema-evolution), index choices (use indexing-strategy), or conceptual modeling above the data model (use conceptual-modeling).

11 installs
▌
Design System Architecture · jacob-balslev
Use when designing or auditing a design system's architecture: token taxonomy, semantic tokens, component APIs, theming, accessibility contracts, documentation, governance, and migration strategy. Do NOT use for information hierarchy and navigation (use `information-architecture`), page-specific layout (use `layout-composition`), visual craft direction (use `visual-design-foundations`), sentence-level UI copy (use `microcopy`), or accessibility-only audits (use `a11y`). Do NOT use for organize pages, nav, sitemap, and wayfinding. Do NOT use for rewrite the empty-state text and tooltip labels. Do NOT use for add aria-labels and keyboard behavior to this component. Do NOT use for draft an architecture note explaining why we chose Postgres over DynamoDB.

13 installs
▌
System Interface Contracts · jacob-balslev
Use when defining or reviewing contracts between systems, modules, services, agents, jobs, events, APIs, or teams: ownership, inputs, outputs, invariants, compatibility, errors, idempotency, and versioning. Do NOT use for REST resource design alone (use `api-design`), async event contract detail (use `event-contract-design`), database schemas (use `entity-relationship-modeling`), or post-failure debugging (use `debugging`). Do NOT use for design the REST endpoints, status codes, and pagination. Do NOT use for create database tables and constraints. Do NOT use for investigate why this existing integration is failing in production. Do NOT use for write an ADR after the interface decision has already been accepted.

12 installs
▌
Vercel Composition Patterns · jacob-balslev
Use when refactoring React components with boolean-prop proliferation, designing flexible component APIs, building reusable component libraries, or reviewing component architecture — compound components, explicit variant components, children-over-render-props, the context provider state/actions/meta interface, boolean state-explosion auditing, and the React 19 API migration (ref-as-prop, use() over useContext()). Do NOT use for render performance optimization (memoization, suspense, profiling), visual styling, or Next.js routing/server-component framework patterns. Do NOT use for Memoize this component tree to stop re-renders. Do NOT use for Style this card with the brand spacing and color tokens. Do NOT use for Set up the App Router route and a server component for this page.

15 installs
▌
Entity Relationship Modeling · jacob-balslev
Use when designing database tables, reviewing schema changes, planning migrations, or translating conceptual models into physical database structures. Covers ER notation, entity/attribute/key design, normalization and denormalization, junction tables, inheritance mapping, temporal modeling, ER-to-SQL translation, indexing, and constraints. Do NOT use for conceptual domain analysis (use `conceptual-modeling`), formal ontology (use `ontology`), or cross-system API contracts (use `system-interface-contracts`).

13 installs

375 published skills · page 2 of 4