Skip to content

Explore skills

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

Showing 47221–47250 of 63456 skills

context-graphjacob-balslev/skillsUse 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`).Stars: 2Updated Claude CodeCodexUnverifiedInstall
context-managementjacob-balslev/skillsUse 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`).Stars: 2Updated Claude CodeCodexUnverifiedInstall
context-windowjacob-balslev/skillsUse 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.Stars: 2Updated Claude CodeCodexUnverifiedInstall
gemini-projacob-balslev/skillsUse 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`).Stars: 2Updated Claude CodeCodexUnverifiedInstall
github-copilotjacob-balslev/skillsUse 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`).Stars: 2Updated Claude CodeCodexUnverifiedInstall
gpt-5-5jacob-balslev/skillsUse 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`).Stars: 2Updated Claude CodeCodexUnverifiedInstall
opencodejacob-balslev/skillsUse when deciding whether to run a task on the OpenCode agent runtime (the open-source, provider-agnostic coding agent — usable as a terminal TUI, a non-interactive `opencode run` CLI, an IDE bridge via ACP, a desktop app (beta), a web UI, or a headless `opencode serve` server), how to invoke it non-interactively, how to pick a `provider/model` string, or how OpenCode differs from Claude Code and Codex. Covers its 75+-provider model routing, the OpenCode Zen curated/free model service and the separate OpenCode Go subscription lane, model-selection and config-source (8-layer) precedence, the `--format json` JSONL event stream, the full CLI command surface (serve/web/attach/acp/session/stats/export/import/github/pr/plugin/mcp/db/debug), built-in build/plan agents and LSP code intelligence, permissions vs provider policies, native Agent Skills / MCP / references / commands extension layers, local models, and scripting/automation. Do NOT use when choosing WHICH free model to route specific work to (use `opencode-free-models`), when the runtime is already chosen and you only need to write the agent loop (use `autonomous-loop-patterns`), or for GitHub Copilot's premium-request economics (use `github-copilot`).Stars: 2Updated Claude CodeCodexUnverifiedInstall
opencode-free-modelsjacob-balslev/skillsUse 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`).Stars: 2Updated Claude CodeCodexUnverifiedInstall
skill-infrastructurejacob-balslev/skillsUse 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`).Stars: 2Updated Claude CodeCodexUnverifiedInstall
skill-routerjacob-balslev/skillsUse 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`).Stars: 2Updated Claude CodeCodexUnverifiedInstall
skill-scaffoldjacob-balslev/skillsUse 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`).Stars: 2Updated Claude CodeCodexUnverifiedInstall
eval-driven-developmentjacob-balslev/skillsUse when reasoning about building language-model-integrated systems by writing evaluations before and alongside the system: the statistical (not binary) nature of LLM evals, the five primitives (dataset, evaluation function, aggregation, iteration loop, regression budget), the judgment-mechanism taxonomy (programmatic, model-graded, human-graded, preference comparison, trace/hybrid), the eval-surface stack (final response, trajectory/tool-use, retrieval/RAG, safety, side effects, cost/latency), continuous evals and model-upgrade gates, the statistical-significance discipline (paired tests, McNemar's test, bootstrap CI on the delta, minimum-detectable-effect, clustered standard errors), trajectory-vs-final-output evaluation for multi-step agents, judge calibration and bias, Goodhart's Law and suite saturation, benchmark contamination and eval-awareness, cost-aware regression budgets, the difference between system-specific evals and canonical benchmarks (MMLU, HumanEval, BIG-bench, GAIA), and the offline-eval-vs-production-telemetry distinction with its graded rollout spectrum. Do NOT use for deterministic unit testing (use testing-strategy), production monitoring (use evaluation or error-tracking), general-software TDD (use testing-strategy), or the construction of individual eval rubrics and task sets (outside this skill; construction belongs in task-specific eval artifacts, while this skill owns the iteration discipline).Stars: 2Updated Claude CodeCodexUnverifiedInstall
evaluationjacob-balslev/skillsUse 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).Stars: 2Updated Claude CodeCodexUnverifiedInstall
guardrailsjacob-balslev/skillsUse 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`).Stars: 2Updated Claude CodeCodexUnverifiedInstall
intent-recognitionjacob-balslev/skillsUse 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.Stars: 2Updated Claude CodeCodexUnverifiedInstall
prompt-craftjacob-balslev/skillsUse 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).Stars: 2Updated Claude CodeCodexUnverifiedInstall
prompt-injection-defensejacob-balslev/skillsUse when reasoning about systems that pass untrusted content to a language model: the data-vs-instruction collapse that makes this attack class a structural property of LLMs rather than a fixable bug, the direct/indirect/exfiltration/action-trigger taxonomy, the role of every untrusted surface (RAG retrievals, tool results, attachments, web content, document parsing, user-provided text), why content filters and improved system prompts do not solve it, and the defense-in-depth measures that do (capability constraint, content origin tracking, separate planning and execution stages, human-in-the-loop gates, principle-of-least-authority for tools). Do NOT use for model refusal policy or jailbreak evals (use `guardrails` or `eval-driven-development`), for general application security (use `owasp-security` or `security-fundamentals`), for runtime input validation patterns (use `type-safety` + `api-design`), or for the protocol cycle of tool calls (use `tool-call-flow`).Stars: 2Updated Claude CodeCodexUnverifiedInstall
summarizationjacob-balslev/skillsUse 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`).Stars: 2Updated Claude CodeCodexUnverifiedInstall
tool-call-flowjacob-balslev/skillsUse 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).Stars: 2Updated Claude CodeCodexUnverifiedInstall
tool-call-strategyjacob-balslev/skillsUse 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`).Stars: 2Updated Claude CodeCodexUnverifiedInstall
api-designjacob-balslev/skillsUse 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`).Stars: 2Updated Claude CodeCodexUnverifiedInstall
background-jobsjacob-balslev/skillsUse 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`).Stars: 2Updated Claude CodeCodexUnverifiedInstall
caching-strategiesjacob-balslev/skillsDeciding 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/Memcached, CDNs, browser cache, and framework data caches.Stars: 2Updated Claude CodeCodexUnverifiedInstall
compressionjacob-balslev/skillsThis 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.Stars: 2Updated Claude CodeCodexUnverifiedInstall
connection-poolingjacob-balslev/skillsUse 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).Stars: 2Updated Claude CodeCodexUnverifiedInstall
cron-schedulingjacob-balslev/skillsUse 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.Stars: 2Updated Claude CodeCodexUnverifiedInstall
http-semanticsjacob-balslev/skillsUse 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).Stars: 2Updated Claude CodeCodexUnverifiedInstall
real-time-updatesjacob-balslev/skillsUse 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`).Stars: 2Updated Claude CodeCodexUnverifiedInstall
route-handler-designjacob-balslev/skillsUse when designing or reviewing Next.js Route Handlers (the `route.ts`/`route.js` file convention in App Router): when a Route Handler is the right public HTTP endpoint surface vs Server Actions or Server Components, the HTTP-method-as-export contract (GET/POST/PUT/PATCH/DELETE/HEAD/OPTIONS), the Web-standard Request/Response interface (no Node `req`/`res`), the body-parsing primitives (`request.json`/`formData`/`text`/`blob`/`arrayBuffer`) and one-shot body consumption, the default caching behavior of GET responses (NOT cached by default since Next 15; opt IN via `dynamic = 'force-static'`) and the Cache Components `use cache` model, async `params`/`cookies`/`headers` and `RouteContext` typed params, dynamic segments and search params, the rule that every Route Handler is a PUBLIC surface that must authenticate/authorize/validate inside the handler, manual CORS, runtime/deployment selection (Node default and recommended after Vercel folded standalone Edge Functions onto Vercel Functions; the Edge runtime still selectable; `maxDuration`/`preferredRegion`/static-export limits), streaming via `ReadableStream` including `pull()` backpressure, status-code and header discipline, error responses, webhook-style handlers (signature verify before parse, ACK fast, `after()` for short post-response work), and the design rule that a Route Handler is the right surface when the caller is not your own Next.js UI. Do NOT use for internal mutations triggered from your own UI (use server-actions-design), for render-time reads from your own Server Components (call the data source directly), for the broader REST/contract/versioning discipline (use api-design), for HTTP method/status semantics in the abstract (use http-semantics), for request preprocessing across all routes — now `proxy.ts`/`middleware.ts` (use middleware-patterns), or for the broader webhook reliability story — HMAC verification, idempotency, retries, queue handoff (use webhook-integration).Stars: 2Updated Claude CodeCodexUnverifiedInstall
streaming-architecturejacob-balslev/skillsUse when reasoning about systems that emit a sequence of values over time and consume them incrementally: the producer/stream/consumer/backpressure/termination primitives, the difference between streaming and request-response, the difference between streaming and pub-sub messaging, how WHATWG Streams, Server-Sent Events, HTTP chunked transfer, WebSockets, gRPC streaming, and React Server Component streaming compose, push vs pull backpressure, and the failure modes (slow consumer, abandoned consumer, partial-result correctness). Do NOT use for the message-history protocol between a model and a tool runtime (use tool-call-flow), browser freshness or live dashboard UX transport choice (use real-time-updates), single-response API design (use api-design), durable worker execution and retry semantics (use background-jobs), or event payload/domain-event contracts (use event-contract-design).Stars: 2Updated Claude CodeCodexUnverifiedInstall