jacob-balslev

@jacob-balslev source repo

206 skills
0 followers
1 day ago last updated

▌
Middleware Patterns · jacob-balslev
Use when designing or reviewing Next.js middleware: the single middleware.ts request preprocessor, Edge Runtime constraints, matcher config, NextRequest/NextResponse APIs, redirects, rewrites, pass-through responses, direct responses, auth gates, locale routing, A/B rewrites, security-header delivery, geo routing, bot blocking, and request ID injection. Use for fast cross-cutting request concerns that apply across many routes. Do NOT use for per-route API handlers, Server Actions, HTTP semantics, full security policy design, streaming logic, or webhook signature handling. Do NOT use for implement a /api/posts POST endpoint (use route-handler-design). Do NOT use for implement a delete-comment mutation triggered from a form button (use server-actions-design). Do NOT use for explain what an HTTP 308 means vs 307 (use http-semantics). Do NOT use for design the full CSP policy and the rest of the security-header strategy (use security-fundamentals).

1
install
▌
Testing Strategy · jacob-balslev
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). Do NOT use for my existing test is failing — why? Do NOT use for write a testing-patterns guide for the contributor docs. Do NOT use for clean up this duplicated test setup across three files.

1
install
▌
Visual Hierarchy · jacob-balslev
Use when establishing visual hierarchy — type scale ratios, spacing rhythm, contrast as ordering signal, weight and size as importance, and the layered relationship between primary, secondary, and tertiary information. Do NOT use for content writing, information architecture, or specific color palette construction. Do NOT use for Write the H1 copy that should appear at the top of the landing page. Do NOT use for Choose between sans-serif and serif typefaces for the brand. Do NOT use for Pick the brand's primary color.

1
install
▌
Agent Engineering · jacob-balslev
Use when designing or evaluating a production AI agent system, choosing a multi-agent coordination pattern (orchestrator/worker, fan-out, consensus, sequential chain, evaluator/optimizer), diagnosing coordination failures (claim races, silent stalls, context contamination, runaway loops), or auditing whether an agent loop is truly production-ready. Covers the four pillars (architecture and lifecycle, task decomposition, coordination patterns, production reliability), the six reliability requirements (observability, cost budgets, idempotency, failure recovery, safety caps, claim locks), the delegation decision framework with overhead crossover, and the most common anti-patterns. Do NOT use for prompt wording (use `prompt-craft`), per-call tool efficiency (use `tool-call-strategy`), context-stack design within a single agent (use `context-engineering`), or runtime debugging of a deployed system (use `debugging`). Do NOT use for improve this prompt's wording to get better outputs.

1
install
▌
Indexing Strategy · jacob-balslev
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. Do NOT use for choose a database schema (use entity-relationship-modeling). Do NOT use for decide how to partition data across nodes (use sharding-strategy).

1
install
▌
Ontology Modeling · jacob-balslev
Use when formalizing domain meaning with classes, properties, constraints, RDF/OWL-style semantics, SHACL-like validation shapes, or reasoning-ready axioms. Do NOT use for simple category trees (use `taxonomy-design`), pre-implementation business entity sketches (use `conceptual-modeling`), database schemas (use `entity-relationship-modeling`), or broad representation choice (use `knowledge-modeling`). Do NOT use for make a simple browse category tree for skills. Do NOT use for identify the business entities and relationships before implementation. Do NOT use for design the SQL tables, keys, and indexes. Do NOT use for choose whether this knowledge belongs in rules, frames, a graph, or a hybrid.

1
install
▌
Real Time Updates · jacob-balslev
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`). Do NOT use for design the backpressure protocol for an HTTP stream. Do NOT use for choose the cron expression for a daily refresh.

1
install
▌
Scenario Planning · jacob-balslev
Scenario planning: a strategic-foresight method for making decisions under deep uncertainty by constructing and stress-testing several plausible future worlds. Do NOT use for Scan political, economic, social, technological, environmental, and legal forces for market entry. Do NOT use for We have three options with probabilities and payoffs. Compute expected value and recommend one. Do NOT use for Update our confidence in this forecast after new evidence arrived. Do NOT use for Balance our innovation portfolio across core, adjacent, and transformational bets. Do NOT use for Turn strengths, weaknesses, opportunities, and threats into SO, WO, ST, and WT options. Do NOT use for Answer the five Playing to Win choices for this business. Do NOT use for constructing and using alternative futures from critical uncertainties (use pestel). Do NOT use for deep-uncertainty exploration (use expected-value). Do NOT use for multiple plausible future worlds and strategic robustness (use bayesian-reasoning).

1
install
▌
Sharding Strategy · jacob-balslev
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).

1
install
▌
Suspense Patterns · jacob-balslev
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).

1
install
▌
Typography System · jacob-balslev
Use when designing a typography system — typeface selection and pairing, modular type scale, vertical rhythm, line-height and measure rules, and web font delivery (subsetting, font-display, variable fonts). Do NOT use for body copy writing, single-headline font pairing, or non-text design tokens. Do NOT use for Write the headline copy for the landing page. Do NOT use for Pick the brand's primary color. Do NOT use for Decide where the headline component lives in the folder structure.

1
install
▌
Usability Testing · jacob-balslev
Use when observing representative real users attempting realistic tasks on a prototype or live product to surface usability issues: moderated or unmoderated, remote or in-person, concurrent or retrospective think-aloud, task scenarios, participant screening, tree/first-click testing for IA findability questions, pilot runs, severity rating, sample sizing by claim type, and ethical recording/consent. Do NOT use for automated test suites, code coverage, CI pipelines, unit/integration testing, load testing, or replacing participants with AI/synthetic users; those are engineering verification or synthetic-analysis concerns, not human-behavior observation. Do NOT use for Add unit tests for the order-total calculation function. Do NOT use for Set up the CI pipeline for the new repo. Do NOT use for Run a load test against the checkout API. Do NOT use for Run a card sort to design the navigation hierarchy and labels for this site. Do NOT use for Cluster the findings from ten completed user sessions into themes.

1
install
▌
Writing Humanizer · jacob-balslev
Use when writing or editing human-readable prose such as docs, PRs, issues, release notes, errors, UI copy, commits, tooltips, or support replies, especially when text sounds robotic, padded, monotonous, or overly formal. Covers AI-tell removal, active voice, hedging reduction, readability diagnosis, sentence rhythm, vocabulary variety, tone mapping, paragraph rhythm, bullets-vs-prose choice, and the 5-step humanization workflow. Do NOT use for documentation routing/type selection, code-identifier naming, or in-product UI-text pattern catalogs. Do NOT use for decide kebab-case vs camelCase for this new database column. Do NOT use for draft the marketing headline for the pricing page with strong persuasion. Do NOT use for restructure this doc into a tutorial format with progressive disclosure. Do NOT use for rewrite this UI button label so it names the actual action instead of saying Submit. Do NOT use for rename this React component across all call-sites in the repo. Do NOT use for audit this WCAG 2.

1
install
▌
Balanced Scorecard · jacob-balslev
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).

1
install
▌
Bayesian Reasoning · jacob-balslev
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). Do NOT use for calculate the expected value of these three options. Do NOT use for turn this growth plan into a strategy cascade. Do NOT use for analyze supplier power and substitutes in this industry. Do NOT use for rank these roadmap items by impact and effort. Do NOT use for build a statistical model from a dataset.

1
install
▌
Connection Pooling · jacob-balslev
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). Do NOT use for choose the transaction isolation level for concurrent account transfers.

1
install
▌
Context Management · jacob-balslev
Use when deciding what to load into an active agent session, recovering from context drift, preparing compaction or restart, distilling raw inputs into a working summary, or writing a handoff another agent can resume quickly. Covers intake triage, the active-context contract, the six-step context-management loop, working-set shaping, evidence capsules and observation masking, just-in-time handle-before-payload loading, prompt-caching alignment, context-rot defenses, drift signals and reset, the runtime-primitives boundary, compaction-ready handoffs, and selective rebuild after context loss. Do NOT use for token math (use `context-window`), prompt wording (use `prompt-craft`), persistent memory curation, or multi-graph context architecture (use `context-graph`). Do NOT use for calculate the per-zone token budget for the 200K context window. Do NOT use for improve this prompt template for the grader. Do NOT use for curate the persistent memory index file.

1
install
▌
Database Migration · jacob-balslev
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). Do NOT use for design the row-level-security model for our new tenant table. Do NOT use for the migration crashed in production — find the root cause. Do NOT use for plan the full multi-release schema evolution for this domain.

1
install
▌
Intent Recognition · jacob-balslev
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. Do NOT use for design the deterministic safety hook that blocks destructive commands. Do NOT use for decide whether to use a switch or a chain of ifs. Do NOT use for actually execute the migration after we've classified the risk. Do NOT use for scan this repo for OWASP top 10 vulnerabilities. Do NOT use for review this AI-generated PR for correctness. Do NOT use for the loop is stalling — what's the steering signal.

1
install
▌
Tool Call Flow · jacob-balslev
Use when reasoning about the protocol-level cycle by which a language model uses external tools: declaration, request, execution, continuation, model-visible transcript or provider-resumed state, ID pairing, tool-result formatting, vendor encodings (Anthropic Messages, OpenAI Responses and Chat Completions, MCP, Gemini generateContent and Interactions), client tools vs hosted/server tools, strict schemas and grammar-constrained custom tools, streaming arguments, tool search/deferred loading, programmatic tool calling, computer-use/browser-control screenshot-action loops, parallel vs sequential calls, error handling, and the separation between model intent and runtime execution. Do NOT use for deciding when or how many tools to call (use tool-call-strategy), multi-agent architecture (use agent-engineering), prompt wording (use prompt-craft), or eval design for tool-use behavior (use eval-driven-development).

1
install
▌
Background Jobs · jacob-balslev
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`). Do NOT use for choose the cron expression for a daily run. Do NOT use for design an SSE or WebSocket browser update channel. Do NOT use for define an event envelope and topic naming standard. Do NOT use for debug why this already-running worker crashed. Do NOT use for model the database schema for the business entity being processed.

1
install
▌
Content Monitor · jacob-balslev
Use when building or operating multi-source intelligence pipelines across video, GitHub, Reddit, curated lists, search, and RSS feeds. Covers source adapters, discovery/transcription/summarization/evaluation phases, deduplication, schedules, model-stage choice, and actionable brief generation. Do NOT use for SEO keyword research (use `keywords`) or competitive product analysis (use `user-research`).

1
install
▌
Cron Scheduling · jacob-balslev
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. Do NOT use for move a slow export out of an API handler but it is user-triggered, not scheduled. Do NOT use for design a generic queue contract with retries and progress. Do NOT use for choose Server-Sent Events versus WebSockets for live progress. Do NOT use for define an event payload schema for an async integration.

1
install
▌
Design Thinking · jacob-balslev
Use when orchestrating a full human-centered design process across discovery, definition, ideation, prototyping, and testing — when uncertain which stage of the arc a team is in, when deciding whether to loop back, or when routing to the right stage-specific sibling skill. Do NOT use for single-stage execution (go directly to problem-framing, user-research, research-synthesis, journey-mapping, ideation, prototyping, or usability-testing) or for engineering domain discovery (use event-storming). Do NOT use for Run a single crazy-8s round on this specific how-might-we. Do NOT use for Write the React component for the dashboard widget. Do NOT use for Model the bounded contexts for the order-fulfillment domain. Do NOT use for single-stage divergent/convergent concept generation (use ideation).

1
install
▌
E2e Test Design · jacob-balslev
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).

1
install
▌
Journey Mapping · jacob-balslev
Use when mapping a user's experience across multiple touchpoints and time, surfacing emotional peaks and troughs, identifying opportunity moments in a cross-channel flow, or aligning a team on the end-to-end experience including back-stage support processes. Do NOT use for decomposing a single screen into UI steps (use task-analysis) or for drawing back-end service architecture diagrams — journey maps describe human experience, not system topology. Do NOT use for Break down the steps a user takes inside the upload modal. Do NOT use for Draw the microservice call graph for the checkout API. Do NOT use for Diagram the database schema for the order entity.

1
install
▌
Problem Framing · jacob-balslev
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. Do NOT use for Find the bug causing the 500 error in the checkout endpoint. Do NOT use for Why is the test suite flaky on CI? Do NOT use for Classify whether this agent request is high-risk before executing.

1
install
▌
Semantic Center · jacob-balslev
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).

1
install
▌
Taxonomy Design · jacob-balslev
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`). Do NOT use for define OWL class restrictions and property domains for this knowledge base. Do NOT use for decide whether this knowledge should be represented as a graph, frame, rules, or hybrid. Do NOT use for type this single relation as meronymy, causality, synonymy, or thematic role. Do NOT use for write user-facing labels for this navigation item.

1
install
▌
Version Control · jacob-balslev
Use when designing or maintaining the shape of a repository's git history — choosing a branching model, deciding rebase vs merge, sizing commits, linking commits to tracker tickets, tagging releases, running parallel work across worktrees, and resolving the merge conflicts that arise from any of the above. Covers trunk-based development, short-lived feature branches, atomic commit discipline, linear-history conventions (rebase + squash), release tagging with annotated tags and SemVer, hotfix flows from tags, and worktree lifecycle for parallel agents or contributors. Do NOT use for the words inside the commit message (Conventional Commits format, identifier naming — use `naming-conventions`), for chasing a release-pipeline failure (use `debugging`), or for reviewing a PR's content (use `code-review`). Do NOT use for draft a Conventional Commits message for this change. Do NOT use for the release pipeline failed at the tag-creation step — find out why. Do NOT use for review this PR before we merge it.

1
install
▌
Contract Testing · jacob-balslev
Contract testing: interface verification between consumers and providers via shared contract artifacts and independent two-phase verification. Do NOT use for Test internal seams of a system (use integration-test-design). Do NOT use for Validate an HTTP response against an OpenAPI schema (use API-spec tooling). Do NOT use for Test a complete user journey through the UI (use e2e-test-design).

1
install
▌
Mutation Testing · jacob-balslev
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).

1
install
▌
Rendering Models · jacob-balslev
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).

1
install
▌
Schema Evolution · jacob-balslev
Use when reasoning about how a database schema changes over time without breaking deployed application code — the multi-release path from current to target schema: the expand/contract pattern (parallel change), zero-downtime change rules, the backwards/forwards compatibility envelope (deploy ordering + rollback), the catalog of schema changes (add/drop/rename column, type change, add constraint/index) and the safe procedure for each, dual-write/dual-read transitions with a named source-of-truth, the lock-acquisition hazard (bounded lock_timeout + retry), cross-engine online-change mechanisms (Postgres CONCURRENTLY/NOT VALID, MySQL Online DDL, gh-ost/pt-osc, Vitess/PlanetScale), view-based multi-version tooling (pgroll, Reshape), and migration-lint enforcement (Strong Migrations, Squawk, Atlas). Do NOT use for executing one migration (use database-migration), schema design from scratch (use data-modeling), query tuning (use query-optimization), or partitioning (use sharding-strategy).

1
install
▌
Snapshot Testing · jacob-balslev
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`). Do NOT use for choose the overall unit integration e2e and performance test mix for this feature. Do NOT use for use property-based testing with fast-check generated arrays to assert sort output is ordered and preserves items.

1
install
▌
State Management · jacob-balslev
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). Do NOT use for implement a specific Redux reducer (tactical, library-specific). Do NOT use for design the JSON shape of an API response (use api-design).

1
install
▌
Summarization · jacob-balslev
Use when condensing prose while preserving meaning: session findings, wrap reports, research briefs, executive summaries, TLDRs, agent handoffs, progressive summaries, audit summaries, and long-document distillation. Covers extractive vs abstractive summarization, what to keep vs drop, evidence preservation, summary levels, handoff summaries, and audit-report condensation without hiding findings. Do NOT use for byte/data compression algorithms (use `compression`), context-window budget math or compaction triggers (use `context-window`), working-set selection (use `context-management`), prose tone repair (use `writing-humanizer`), or quality scoring (use `evaluation`).

1
install
▌
Task Analysis · jacob-balslev
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`). Do NOT use for review this PR for code quality. Do NOT use for audit this UI for WCAG 2.2 violations. Do NOT use for decide the CSS grid layout for this hero section. Do NOT use for pick the right colors for this status badge. Do NOT use for build the navigation taxonomy for the whole product. Do NOT use for should we use a dropdown or a stepper here.

1
install
▌
User Research · jacob-balslev
Use when planning or conducting generative qualitative research with real users — interviews, contextual inquiry, ethnographic observation, diary studies — to learn what people do, think, and need in their own context. Do NOT use for analytics review, survey statistics, A/B test interpretation, or agent-side intent classification — those are different research practices entirely. Do NOT use for Analyze last quarter's NPS results and produce a dashboard. Do NOT use for Classify whether this agent request from the user is high-risk before executing. Do NOT use for Set up an A/B test of two onboarding flows.

1
install
▌
Context Window · jacob-balslev
Use when allocating context-window budget across system, skill-injection, working, and output zones; monitoring context health; deciding when to compact; preserving state before compaction; recovering after compaction; or choosing strategies for 1M, 200K, or 128K context windows. Covers zone budgets, practical model-budget tables, the 80% compaction rule, pre/post-compact protocols, persistence hierarchy, operation token costs, and token-reduction techniques. Do NOT use for deciding what information belongs in the working set (use `context-management`), prompt design (use `prompt-craft`), graph architecture (use `context-graph`), or memory curation. Do NOT use for decide what context to load or drop in the working set. Do NOT use for design the multi-graph architecture for skills + docs + memory. Do NOT use for improve the prompt template the agent uses. Do NOT use for curate the durable memory index across sessions. Do NOT use for which skill should activate for this query.

1
install
▌
Error Boundary · jacob-balslev
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). Do NOT use for handle a Promise rejection in an event handler (use code-review for the local try/catch pattern).

1
install
▌
Error Tracking · jacob-balslev
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`). Do NOT use for design accessible error-message copy and recovery UI for the 404 page. Do NOT use for the boundary fired but the tracker shows no event — root-cause it. Do NOT use for explain our error-tracking architecture in the contributor docs. Do NOT use for review this AI-generated error handler for correctness. Do NOT use for decide if the new error path needs an integration regression test.

1
install
▌
Event Storming · jacob-balslev
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`). Do NOT use for implement Shopify webhook signature verification and idempotent retries. Do NOT use for draw the state machine for this one status field. Do NOT use for create a normalized data model and indexes. Do NOT use for write event-bus infrastructure code. Do NOT use for define the schema, topic, compatibility, and fixtures for a selected event.

1
install
▌
Expected Value · jacob-balslev
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). Do NOT use for Update these probabilities after new customer evidence. Do NOT use for Prioritize this backlog with RICE using reach, impact, confidence, and effort. Do NOT use for Trace the second- and third-order consequences before we model outcomes.

1
install
▌
Github Copilot · jacob-balslev
Use when deciding whether to spend GitHub Copilot's metered budget on a task (its premium-request / post-June-2026 AI-credit model, where 1 credit = $0.01 and cost = tokens × per-model rate), what Copilot is good at vs expensive at, which plan allowance (Pro 300 / Pro+ 1500, no rollover) applies, and when a cheaper or free lane should take the work instead. Covers the June 1 2026 shift from premium-request multipliers to usage-based token billing, the always-free completions/next-edit surface, and the IDE-native frontier-model lane. Do NOT use for choosing or operating the OpenCode runtime (use `opencode`), for picking a specific free model (use `opencode-free-models`), or for authoring an agent loop (use `autonomous-loop-patterns`). Do NOT use for how do I invoke the opencode CLI non-interactively? Do NOT use for which free model fits this bulk job? Do NOT use for how do I write the agent's retry loop?

1
install
▌
Hooks Patterns · jacob-balslev
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). Do NOT use for choose between Server Components and Client Components for a new page. Do NOT use for decide where app state lives across server, client UI, URL, and persistent storage.

1
install
▌
HTTP Semantics · jacob-balslev
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). Do NOT use for decide between WebSocket and SSE for live updates (use streaming-architecture).

1
install
▌
Owasp Security · jacob-balslev
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`).

1
install
▌
Playing To Win · jacob-balslev
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). Do NOT use for analyze whether this industry has attractive supplier power and threat of substitutes. Do NOT use for score these ten backlog items by impact and effort. Do NOT use for design a quality gate process for this multi-step implementation. Do NOT use for write OKRs for this strategy after it has already been chosen.

1
install
▌
Prioritization · jacob-balslev
This skill provides prioritization frameworks for AI engineering: RICE-A (adding AI Ambiguity to RICE) for product features, ICE for research experiments, and MoSCoW for MVP/Release scoping. Use when ranking the backlog, deciding which model research path to follow, or defining the scope of a new feature. Do NOT use for one-off task sequencing (use task skill) or personal time management.

1
install
▌
Skill Scaffold · jacob-balslev
Use when creating a new SKILL.md from scratch, restructuring a draft before it becomes a stable skill, or teaching another author the canonical Skill Metadata Protocol frontmatter, body, and audit-state.json sidecar structure. Covers flat schema-conformant frontmatter, the sidecar split, v8 classification, body layout by skill intent, semantic-layer discipline (description vs activation vs Coverage), teaching-layer mechanics (TEMPLATE NOTE blockquotes), native skill-creator handoff, public/private safety, and routing-eval honesty. Do NOT use when modifying an already-written skill (edit it directly), writing general technical documentation, routing an existing request across skills, or fixing malformed library health at scale (use `skill-infrastructure`). Do NOT use for refactor my existing skill to be more concise. Do NOT use for my skill's routing isn't activating — why? Do NOT use for audit my skill library for stale frontmatter. Do NOT use for write a developer guide for the contributor docs.

1
install
▌
Three Horizons · jacob-balslev
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).

1
install
▌
Positioning · jacob-balslev
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). Do NOT use for Turn this whole company plan into winning aspiration, where to play, how to win, capabilities, and systems. Do NOT use for Create a blue ocean strategy canvas and ERRC grid for this market. Do NOT use for Analyze rivalry, buyer power, supplier power, entrants, and substitutes.

1
install
▌
Prototyping · jacob-balslev
Use when building an artifact whose purpose is to answer a specific question — paper sketch, wireframe, clickable mockup, wizard-of-oz, role-play, service prototype, or code spike — at the lowest fidelity sufficient to produce that learning. Do NOT use for production-grade component construction, design-system contribution, or building the actual ship-ready feature — those are design-module-composition and engineering implementation. Do NOT use for Build the production React component for the new dashboard widget. Do NOT use for Add this component to the design system library. Do NOT use for Write the migration script for the production database.

1
install
▌
Type Safety · jacob-balslev
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). Do NOT use for implement HMAC verification for an inbound webhook (use webhook-integration). Do NOT use for design the JSON shape of an API endpoint (use api-design).

2
installs
▌
Claude Haiku · jacob-balslev
Use when deciding whether to route a task to the fast/cheap tier (Claude Haiku) — transcription, polling, format conversion, structured-output slot-filling, small-diff review, high-volume low-latency work — and where the boundary is that should escalate to Sonnet/Opus. Covers the cost/latency floor, the 200K context ceiling (vs the upper tiers' 1M), the absence of the effort knob, the separate rate-limit pool, and when to drop below Haiku to a script. Do NOT use for ordinary multi-step feature work (use claude-sonnet), the hardest reasoning (use claude-opus), loop design (use autonomous-loop-patterns), or Claude API request syntax (read the claude-api reference).

1
install
▌
Lean Startup · jacob-balslev
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. Do NOT use for Plan interviews to discover what users need before we have a product concept. Do NOT use for Synthesize these interview transcripts into themes and insights. Do NOT use for Classify these roadmap items as must-be, performance, delighter, indifferent, or reverse features. Do NOT use for Turn this strategy into quarterly Objectives and Key Results.

1
install
▌
Lint Overlay · jacob-balslev
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). Do NOT use for decide whether to unit-test or integration-test this handler. Do NOT use for extract this repeated code pattern into a shared util.

1
install
▌
Prompt Craft · jacob-balslev
Use when writing, tightening, evaluating, or repairing an LLM prompt or reusable prompt template for completion, agent dispatch, grading, structured extraction, tool use, or prompt-engineered workflows. Covers instruction hierarchy, message roles, context placement, few-shot examples, structured output, positive constraints, reasoning guidance, prompt-injection resistance, provider differences, and eval-driven iteration. Do NOT use for whole context-system design (use context-engineering), eval dataset or grader design (use eval-driven-development), reviewing generated code (use code-review), authoring SKILL.md files (use skill-scaffold), choosing which skill or agent should activate (use skill-router), or root-causing a deployed failure after outputs already exist (use debugging). Do NOT use for review this AI-generated PR for correctness. Do NOT use for scaffold a new skill that teaches prompt engineering.

1
install
▌
Ref Patterns · jacob-balslev
Use when designing or reviewing React ref usage: refs as mutable handles that survive renders without triggering them, useRef for DOM access and instance values, ref callbacks for mount/unmount hooks, forwardRef and React 19 ref-as-prop, useImperativeHandle for controlled imperative APIs, and ref forwarding through compound-component primitives such as Radix Slot. Use for focus, measurement, animation, third-party DOM integration, and sparse imperative APIs; never as a substitute for reactive state. Do NOT use for the broader hook discipline (use react-hooks-patterns), state ownership decisions (use state-management), component-layering strategy (use component-architecture), Client/Server serialization boundaries (use client-server-boundary), or form validation UX (use form-ux-architecture). Do NOT use for design the Rules of Hooks and dependency-array discipline for useEffect (use hooks-patterns).

1
install
▌
Seven Powers · jacob-balslev
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. Do NOT use for analyze the attractiveness of this industry using entrants, suppliers, buyers, substitutes, and rivalry. Do NOT use for turn this market-entry plan into a winning aspiration, where to play, how to win, capabilities, and systems. Do NOT use for rank these roadmap items by impact and effort. Do NOT use for make a SWOT table for this company.

1
install
▌
V3 1 Skos Fixture · jacob-balslev
Test fixture exercising SKOS predicates (related, broader, narrower), routing-layer suppresses, the ADR 0006 split between routing exclusion and disjoint_with (OWL class-disjointness), and the io_contract composition hook. Used by scripts/__tests__/test-v3-1-skos-runtime.js to verify that the manifest generator, lint, and router all recognize the full canonical predicate set. Not a production skill.

1
install
▌
Ansoff Matrix · jacob-balslev
Use when choosing or reviewing growth strategy options with the Ansoff product-market matrix: market penetration, market development, product development, diversification, existing vs new products, existing vs new markets, strategic distance, risk, assumptions, and sequencing. Covers growth-option framing, quadrant classification, evidence needs, option comparison, and handoff to deeper validation methods. Do NOT use for internal/external factor inventory (use swot-tows), macro-environment scanning (use pestel), industry profit-pressure diagnosis (use porters-five-forces), integrated strategy cascades (use playing-to-win), durable moat classification (use seven-powers), or quantified option valuation (use expected-value). Do NOT use for Allocate our R&D budget across existing business units based on market growth rate and relative market share. Do NOT use for Turn strengths, weaknesses, opportunities, and threats into SO, WO, ST, and WT options.

1
install
▌
Best Practice · jacob-balslev
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). Do NOT use for designing the color system and contrast model (use color-system-design). Do NOT use for implementing font loading and vertical rhythm (use typography-system). Do NOT use for designing a skill's comprehension or application eval suite (use eval-driven-development).

1
install
▌
Claude Sonnet · jacob-balslev
Use when deciding whether to route a task to the balanced implementation tier (Claude Sonnet) — feature work, bug fixes, test writing, multi-step code — as the default lane that is cheaper/faster than the frontier tier and more capable than the fast tier. Covers the cost/quality tradeoff vs Opus and Haiku, the shared 1M context window, effort behavior, and the 1M-context subscription billing caveat. Do NOT use for the hardest reasoning/architecture/security work (use claude-opus), high-volume mechanical or low-latency work (use claude-haiku), loop design (use autonomous-loop-patterns), or Claude API request syntax (read the claude-api reference).

1
install
▌
Context Graph · jacob-balslev
Use when designing or auditing the multi-graph context architecture of an AI-coding workspace: skill graph, document routing graph, memory index, script registry, and the cross-graph edges between them. Covers edge typing, orphan detection, connectivity health, deterministic graph synthesis signals, change-propagation checks, and drift or hub-and-spoke anti-patterns. Do NOT use for authoring one SKILL.md (use `skill-scaffold`), validating one skill (use `skill-infrastructure`), live routing decisions (use `skill-router`), context-window budgeting (use `context-window`), or session load/drop choices (use `context-management`). Do NOT use for scaffold a new SKILL.md from a template. Do NOT use for validate that this single skill's frontmatter matches the schema. Do NOT use for decide which skill to inject for this query right now. Do NOT use for this skill says 'use orgQuery'; that one says 'never use orgQuery' — fix the conflict.

1
install
▌
Diff Analysis · jacob-balslev
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.

1
install
▌
Generative UI · jacob-balslev
Use when reasoning about the pattern where a language model emits structured output describing UI components or a UI sub-tree that an application renders for the user. Covers the typed-schema component palette, JSON Schema/function-calling constraints, two render substrates (typed component tree vs sandboxed iframe), the app-side render pipeline, bidirectional interaction loop via postMessage/JSON-RPC, the security boundary between model author and application renderer, and distinctions from chat markdown, prebuilt-widget routing, RSC streaming, and model-emits-code patterns. Do NOT use for page-level rendering taxonomy (use rendering-models), the tool-call protocol cycle (use tool-call-flow), untrusted-content defenses (use prompt-injection-defense), or general component-library architecture (use design-system-architecture). Do NOT use for design the JSON shape of an HTTP API endpoint (use api-design).

1
install
▌
Mental Models · jacob-balslev
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). Do NOT use for name the React hook for managing form state (tactical implementation choice).

1
install
▌
Stp Marketing · jacob-balslev
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.

1
install
▌
Swot Tows · jacob-balslev
Use when turning internal/external situation analysis into strategic options with SWOT and TOWS: strengths, weaknesses, opportunities, threats, evidence quality, SO/WO/ST/WT option generation, and action hypotheses. Covers separating internal from external factors, avoiding unsupported laundry lists, crossing quadrants into strategy options, and naming what evidence or method should follow. Do NOT use for industry profit-pressure diagnosis (use porters-five-forces), durable moat classification (use seven-powers), value-curve redesign (use blue-ocean-strategy), integrated strategy cascades (use playing-to-win), or quantified option comparison (use expected-value). Do NOT use for Analyze supplier power, buyer power, entrants, substitutes, and rivalry. Do NOT use for Classify this company's durable moat source. Do NOT use for Create a strategy canvas and ERRC grid for a new market space. Do NOT use for Turn this strategy into winning aspiration, where to play, how to win, capabilities, and systems.

1
install
▌
API Design · jacob-balslev
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`). Do NOT use for define the broader contract between a job, service, and dashboard. Do NOT use for design database tables, foreign keys, and views.

1
install
▌
Bcg Matrix · jacob-balslev
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). Do NOT use for Classify growth ideas as market penetration, market development, product development, or diversification.

1
install
▌
Evaluation · jacob-balslev
Use when scoring a completed agent task, implementation, document, skill upgrade, or other deliverable against the original request, acceptance criteria, verification evidence, quality rubric, and residual risks before calling it done. Covers skeptical critic review, 1-5 scoring, score ceilings, evidence sufficiency, finding/action capture, and the evaluation-revision loop. Do NOT use for designing eval datasets or graders (use eval-driven-development), line-by-line diff review (use code-review), choosing test levels (use testing-strategy), or designing the overall process and gates before work starts (use methodology). Do NOT use for design a new eval dataset, grader, and hard negatives for this router. Do NOT use for review this pull request line by line for bugs and security issues. Do NOT use for choose unit versus integration versus end-to-end tests for this feature. Do NOT use for design the whole implementation methodology and quality gate sequence before work starts.

1
install
▌
Gemini Pro · jacob-balslev
Use when deciding whether to route a task to Google's Gemini Pro frontier model (current Gemini 3.1 Pro generation, moving to Gemini 3.5 Pro) instead of Claude Opus or GPT-5 — especially for very-large-context reasoning (1M-token input), whole-codebase or long-document analysis, native multimodal input (audio/video/PDF/image in one call), or capability-per-dollar at the frontier. Covers the context window, the 200K context-tier pricing cliff, multimodal support, and the per-lane comparison against Claude Opus / GPT-5. Do NOT use for choosing the cheap/fast tier (use `gemini-flash`), for general agent-system architecture (use `agent-engineering`), or for dispatching among local skills (use `skill-router`). Do NOT use for I just need a cheap classifier for 10k rows. Do NOT use for design the multi-agent orchestration for this system. Do NOT use for which of my local skills should handle this request?

1
install
▌
Guardrails · jacob-balslev
Use when planning or executing agent/tool operations that touch protected files, credentials, destructive git commands, destructive SQL, PII, secrets, deployments, package publication, or irreversible system mutations. Covers proactive safety policy, tool-call tripwires, blocking vs advisory enforcement, secret-exposure prevention, and excessive-agency containment. Do NOT use for application input validation, routine git workflow design, migration authoring, or general code correctness review (use `code-review`, `version-control`, or `database-migration`).

1
install
▌
Kano Model · jacob-balslev
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). Do NOT use for Rank this backlog by reach, impact, confidence, and effort. Do NOT use for Synthesize these interview transcripts into research themes. Do NOT use for Design a generic quality-improvement process with DMAIC or PDCA.

1
install
▌
Methodical · jacob-balslev
Use when disciplined, complete, evidence-backed execution matters more than brevity: audits, diagnostic reports, tracked-task creation from findings, acceptance-criteria verification, research briefs, and enumerated outputs future work depends on. Covers 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, delegation-as-proof) and countermeasures: pre-task scope declaration, count-preserving enumeration, evidence receipts, externally grounded critique, provenance labels, explicit completeness/partial receipts, and runtime enforcement. Do NOT use for shortest-route selection (use task-path-optimization), broad artifact-quality standards (use best-practice), scoring results (use evaluation), compact pre-output enforcement (use no-cutting-corners), or post-enumeration compression (use summarization).

1
install
▌
Claude Code · jacob-balslev
Use when deciding whether to run a task in the Claude Code agent harness, when scoping work to its native capabilities (skills, hooks, subagents, MCP, plan mode, 1M-context Opus, background tasks, slash commands), or when choosing Claude Code versus a different harness (Codex, OpenCode, Copilot) for a given piece of work. Covers what the harness is good at, the extensibility stack and when each layer earns its keep, and the decision boundaries against rival harnesses. Do NOT use for writing Anthropic SDK / API code (use `claude-api`), for choosing which Claude MODEL to route a task to versus GPT (use `gpt-5-5`), or for designing a generic autonomous agent loop (use `autonomous-loop-patterns`). Do NOT use for write a Python script that calls the Anthropic Messages API. Do NOT use for is GPT-5.5 or Opus better for this code review? Do NOT use for design a resumable autonomous loop with a supervisor.

1
install
▌
Claude Opus · jacob-balslev
Use when deciding whether to route a task to Anthropic's frontier reasoning tier (Claude Opus) — architecture, multi-file synthesis, hard debugging, security reasoning, long-horizon agentic planning — and when NOT to (mechanical work belongs on a cheaper tier). Covers the Opus capability profile: 1M-token context, the cost/latency premium, adaptive thinking, the Opus-only effort ceiling (xhigh/max), task budgets, prompt-caching minimums, and high-resolution vision. Do NOT use for picking the balanced implementation tier (use claude-sonnet), the fast/cheap tier (use claude-haiku), designing the loop the model runs inside (use autonomous-loop-patterns), or for Claude API request syntax (read the claude-api reference).

1
install
▌
Code Review · jacob-balslev
Use when reviewing a pull request, diff, or proposed code change for correctness, clarity, security, performance, maintainability, test evidence, and project-convention fit, whether the author is a human, an AI agent, or a peer. Covers pre-review fact gathering, verifying AI-written PR summaries against the diff, reading tests before implementation, tracing call sites and blast radius, review size and attention budget, severity grading with Conventional Comments, comment phrasing, reviewer qualification, treating diff content as evidence rather than instructions, refusing rubber-stamp approval for AI-generated diffs, and making an explicit approve/request-changes/close merge decision. Do NOT use for authoring the code (use refactor for behavior-preserving changes or skill-scaffold for new skills), chasing a known bug after merge (use debugging), security-only audits (use owasp-security), or explaining a patch without a merge verdict (use diff-analysis).

1
install
▌
Compression · jacob-balslev
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.

1
install
▌
Doc Updater · jacob-balslev
Enforces the documentation-sync discipline: every code or behavior change ships its documentation in the SAME commit, never after. Provides the five-step workflow — diff the change, route each changed file to the doc that OWNS that behavior (document by ownership, not convenience), update each owning doc, verify the update actually landed, and report what was changed — plus the doc-type-purity and stale-reference gates that keep a docs corpus from drifting as code moves. Use at the pre-commit step of any task that changes code, when a change touches several docs, when renaming or deleting something that is referenced elsewhere, or whenever you are unsure which doc owns a change. Do NOT use for how to WRITE good documentation prose or pick a doc's Diátaxis type (that is a documentation-authoring skill), for choosing clear names (use `naming-conventions`), or for the broad cross-domain quality catalog (use `best-practice`).

1
install
▌
Linguistics · jacob-balslev
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`). Do NOT use for decide kebab-case vs snake_case vs camelCase for new database columns. Do NOT use for restructure this doc into a tutorial format with progressive disclosure. Do NOT use for implement Intl.NumberFormat for DKK vs USD currency formatting.

1
install
▌
Mckinsey 7s · jacob-balslev
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). Do NOT use for Analyze buyer power, supplier power, substitutes, entrants, and rivalry in this industry. Do NOT use for Map the value chain activities that create customer value and drive cost. Do NOT use for Use VRIO to test whether our data, brand, and process are durable advantages.

1
install
▌
Merge Queue · jacob-balslev
Use when serializing merges across multiple agent branches, resolving conflicts between agent outputs, or cleaning stale task branches. Covers atomic locking, idempotency checks, non-fast-forward handling, and worktree cleanup. Do NOT use for ordinary git operations outside an agent merge queue (use `version-control`).

1
install
▌
Methodology · jacob-balslev
Use when planning multi-step implementations, designing quality gates, establishing verification protocols, or building agent checklists calibrated to known failure modes. Covers methodology/method/process distinctions, Cleanroom, PSP/TSP, hypothesis-driven development, DMAIC, checklist design, V&V frameworks, EDDOps, quality gates, and PDCA. Do NOT use for code-review verdicts (use `code-review`), behavior-preserving implementation work (use `refactor`), or test strategy (use `testing-strategy`). Do NOT use for review this PR and decide whether to approve it. Do NOT use for refactor this file while preserving behavior. Do NOT use for decide unit vs integration vs e2e coverage for this feature. Do NOT use for write the eval cases and grader rubric for this router. Do NOT use for block this dangerous git command or secret-bearing tool call.

1
install
▌
Okrs · jacob-balslev
Objectives and Key Results goal-setting methodology for turning strategy, quarterly priorities, product goals, or team focus areas into outcome-oriented Objectives, measurable Key Results, review cadences, and learning loops. Do NOT use for Decide our winning aspiration, where to play, and how to win. Do NOT use for Use constraint-awareness to identify hard constraints before choosing a strategy or goal.

1
install
▌
Vrio · jacob-balslev
Use when evaluating whether a firm's resources or capabilities can create sustained competitive advantage with VRIO: Valuable, Rare, costly to Imitate, and Organized to capture value. Covers resource/capability inventory, sequential VRIO testing, competitive implication classification, inimitability mechanisms, organization gaps, investment/protection priorities, and handoff to broader strategy methods. Do NOT use for external industry profit-pressure diagnosis (use porters-five-forces), generic internal/external factor inventory (use swot-tows), durable moat-source taxonomy (use seven-powers), portfolio allocation (use bcg-matrix), product-market growth paths (use ansoff-matrix), or quantified option valuation (use expected-value). Do NOT use for Analyze buyer power, supplier power, substitutes, entrants, and rivalry for this industry. Do NOT use for Turn strengths, weaknesses, opportunities, and threats into TOWS strategy options.

1
install
▌
Codex · jacob-balslev
Use when deciding whether to run a task in the Codex CLI agent harness (which drives a frontier GPT model), when scoping work to its native capabilities (resumable `codex exec resume` sessions, non-interactive `exec` stdout-piping, in-process dispatch, `/permissions` sandbox modes, MCP, on-demand subagents, the `/review` code-review agent), or when choosing Codex versus the Claude Code harness for a piece of work — and when avoiding its known failure modes (non-autonomous subagents, Full-Access network reach, cold-one-shot context loss). Do NOT use for routing a task to the GPT MODEL versus Claude (use `gpt-5-5`), for the Claude Code harness decision (use `claude-code`), or for designing a generic resumable agent loop (use `autonomous-loop-patterns`). Do NOT use for is GPT-5.5 or Opus the better model for this task? Do NOT use for what is Claude Code good at? Do NOT use for design a resumable supervised loop from scratch.

1
install
▌
Pestel · jacob-balslev
Use when scanning an external macro environment with PESTEL/PESTLE and variants such as STEEPLE, STEEPLED, PESTLIED, STEEP, DESTEP, and LoNGPESTLE: political, economic, social, technological, environmental, and legal forces; evidence quality and recency; geography/jurisdiction and local/national/global level; time horizon; uncertainty; weak signals; impact/probability scoring; factor interactions; bias checks; opportunity/threat implications; assumptions; action conversion; and monitoring triggers. Covers external-environment scanning before strategy choices, market-entry reviews, strategic planning, product/service context, policy-aware planning, and risk/opportunity surfacing. Do NOT use for internal capability diagnosis (use swot-tows), industry profit-pressure diagnosis (use porters-five-forces), value-curve redesign (use blue-ocean-strategy), integrated strategy cascades (use playing-to-win), product positioning (use positioning), or quantified option comparison (use expected-value).

1
install
▌
Gpt 5 5 · jacob-balslev
Use when deciding whether to route a task to OpenAI's GPT-5.5 frontier model versus Claude Opus or Sonnet — picking the model lane for infrastructure scripts, CI pipelines, concrete implementation, analytical code review, security review, or CLI/terminal-heavy work, and weighing GPT-5.5's context window, pricing, and per-benchmark strengths against the Claude tiers for the same task. Covers the decision-useful capability and pricing facts, and the boundary against the Claude routing skills. Do NOT use for running the GPT model through a harness (use `codex`), for choosing among the Claude tiers themselves (use `claude-opus` / `claude-sonnet`), or for routing among local skills at request time (use `skill-router`). Do NOT use for resume my last Codex session and keep going. Do NOT use for is Opus or Sonnet the right Claude tier for this? Do NOT use for which of my skills handles webhook tasks?

1
install
▌
Shopify · jacob-balslev
Use when working with Shopify — Admin API, Storefront API, OAuth scopes, HMAC SHA-256 webhook verification, GraphQL query-cost handling, Online Store 2.0 themes (sections, blocks, Liquid), metafields and metaobjects, and App Proxy. Do NOT use for generic e-commerce design, non-Shopify storefronts, or internal event-contract design. Do NOT use for Design the event payload schema for our internal order-processing pipeline. Do NOT use for Implement Stripe Connect onboarding for a marketplace. Do NOT use for Refactor a generic shopping cart component that isn't Shopify-specific.

1
install
▌
Ideation · jacob-balslev
Use when generating a wide range of solution concepts before converging on a direction, running structured idea-generation sessions, breaking out of solution fixation, or moving from divergent to convergent selection with explicit criteria. Do NOT use for collaborative engineering domain discovery (event-storming), solo deep technical design, or making final go/no-go investment decisions — those require different methods. Do NOT use for Decide whether to invest in this feature for the next quarter. Do NOT use for Model the bounded contexts for the order-fulfillment domain. Do NOT use for Write the production code for the selected concept.

1
install
▌
Keywords · jacob-balslev
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`). Do NOT use for build the SEO landing page, JSON-LD schema, and internal-linking plan from these keywords.

1
install
▌
Opencode · jacob-balslev
Use when deciding whether to run a task on the OpenCode agent runtime, how to invoke it non-interactively, how to pick a provider/model string, or how OpenCode differs from Claude Code and Codex. Covers terminal TUI, opencode run, ACP/IDE bridge, desktop beta, web UI, opencode serve, provider/model routing, OpenCode Zen and OpenCode Go lanes, config precedence, JSONL output, CLI command surface, build/plan agents, LSP code intelligence, permissions, Agent Skills, MCP, references, commands, plugins, local models, and scripting/automation. Do NOT use for choosing which free model fits a task (use opencode-free-models), writing the agent loop itself (use autonomous-loop-patterns), or GitHub Copilot premium-request economics (use github-copilot). Do NOT use for which free model should I use for this classification job? Do NOT use for how do I structure the autonomous agent loop itself? Do NOT use for how many Copilot premium requests will this burn?

1
install
▌
Printify · jacob-balslev
Use when working with Printify — the print-on-demand REST API, catalog model (blueprints, print providers, variants, print areas), product creation and publish lifecycle to connected channels, order routing, shipping cost queries, and HMAC SHA-256 webhook verification. Do NOT use for non-Printify POD vendors, generic Shopify storefront work, or print-file (artwork) generation. Do NOT use for Generate the artwork PNG file that gets uploaded as a print file. Do NOT use for Implement the Shopify side of the Printify-to-Shopify sync. Do NOT use for Design a generic POD-vendor-agnostic product schema.

1
install
▌
Refactor · jacob-balslev
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). Do NOT use for the test is failing after my edit — what did I break? Do NOT use for write an architecture note explaining this pattern for new team members. Do NOT use for reproduce why this function retries three times on transient network errors.

1
install
▌
Debugging · jacob-balslev
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. Do NOT use for plan test coverage for a new feature. Do NOT use for document what this function does for future readers. Do NOT use for refactor this messy code while the test suite is green.

1
install
▌
Diagnosis · jacob-balslev
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. Do NOT use for actually execute scientific-method debugging on this stack trace. Do NOT use for review this AI-generated PR for correctness. Do NOT use for scan this repo for OWASP top 10 vulnerabilities. Do NOT use for design observability instrumentation for this service. Do NOT use for decide which agent should pick up this ticket. Do NOT use for what's the right test pyramid for this feature.

1
install

206 published skills · page 2 of 3