fable-skills

Load when doing nontrivial git work — rewriting/cleaning history (interactive rebase, fixup, splitting commits), recovering "lost" work (botched rebase, bad reset, force-push), choosing rebase vs merge, running git bisect, setting up worktrees, taming a monorepo (sparse-checkout, partial clone, maintenance), deciding submodule vs subtree, or splitting a big branch into stacked PRs.

Defensive AI safety engineering — layered guardrails (input/output classification, action permissions, escalation), prompt-injection defense in agentic systems, jailbreak detection taxonomy, red-teaming your own deployment, agentic risks (tool authorization, exfiltration channels), and incident response. Load when hardening an LLM app or agent against attacks, designing guardrail stacks, building red-team/regression suites, or reviewing AI-security posture.

Load when building or reviewing code that consumes or exposes APIs — HTTP clients, retries/timeouts/circuit breakers, rate-limit handling, webhooks (sending or receiving), pagination, API versioning, SDK-vs-raw-HTTP choices, or debugging flaky third-party integrations.

Load when working with molecular data — SMILES/InChI/mol files, RDKit code, molecular fingerprints and similarity search, SMARTS substructure queries, property filters (Lipinski/QED), reaction SMILES, chirality handling, or preparing chemical datasets for machine learning (deduplication, salt stripping, splits).

Load when making code or systems faster — diagnosing slowness, profiling, reducing latency or memory, writing or reviewing benchmarks, capacity/latency budgeting, or evaluating optimization proposals. Also load when someone claims "X is slow" or "Y made it faster" and the claim needs to be verified or quantified.

Load when designing or reviewing any API surface — REST/HTTP endpoints, RPC or GraphQL schemas, library/public function signatures, SDKs, webhooks, or when evolving an existing API (versioning, deprecation, backwards compatibility). Also load when choosing between REST, RPC, and GraphQL, or designing error payloads, pagination, or idempotency.

Load when designing how code reports, propagates, or recovers from failures — choosing exceptions vs result types vs error codes, designing retry/idempotency semantics, structuring error chains and messages, deciding what to catch where, or reviewing error-handling code.

Load when writing or reviewing concurrent/parallel/async code — threads, locks, atomics, async/await, channels/actors, thread pools — or diagnosing races, deadlocks, and event-loop stalls. Also load for questions about Python's GIL, memory models, pool sizing, or choosing between shared memory and message passing.

Load when working in a large or unfamiliar codebase — locating where behavior lives, understanding undocumented code before changing it, recovering the intent behind odd code via git history, detecting dead code, untangling dependencies, or making safe changes without full understanding of the system.

Load when reviewing a diff, pull request, or patch — or when asked to find bugs in proposed changes before merge. Covers incident-causing bug patterns, reviewing for absent code (missing invalidation/rollback/timeout), severity calibration, and avoiding nitpick noise.

Load when restructuring existing code without changing behavior — renames, extractions, module reorganization, migrating legacy code, replacing a dependency, or evolving an API/schema in place. Covers characterization tests, seams, strangler-fig, parallel-change (expand/migrate/contract), and keeping diffs reviewable.

Load when decomposing a system into modules or services, deciding monolith vs microservices, drawing module/team boundaries, evaluating or writing architecture decision records, choosing dependency directions, or judging whether an abstraction/layer is worth its cost. Also load for "should we split this service" and "how do we structure this codebase" questions.

Load when diagnosing a bug, test failure, crash, regression, flaky behavior, or "works on my machine" report — any time the task is finding WHY software misbehaves rather than writing new features. Covers reproduction discipline, bisection, hypothesis ranking, stack traces/core dumps, and Heisenbug tactics.

Load when designing tests, writing a test suite, deciding what/how to test, choosing between unit/integration/e2e, diagnosing flaky tests, or evaluating test quality. Covers property-based testing, boundary selection, mocking pitfalls, mutation-testing mindset, and what not to test.

Token economics and cost optimization for LLM applications — pricing mechanics (input/output asymmetry, caching discounts, batch APIs across Anthropic/OpenAI/Google), the optimization ladder in ROI order, prompt-cache engineering, cheap-model-first routing, output control, RAG-vs-long-context arithmetic, fine-tune break-even math, and cost monitoring with kill-switches. Load when analyzing, forecasting, or reducing LLM API spend, or designing cost-aware architecture.

Load when designing internal developer platforms, golden paths, or self-service infrastructure; evaluating IDP tooling (Backstage, Port, etc.); structuring platform vs product teams; measuring platform adoption/success; or advising whether an org should build a platform team at all.

Load when designing, writing, or debugging CI/CD pipelines — GitHub Actions workflows, build/test/deploy stages, caching, flaky builds, pipeline security (secrets, untrusted PRs, action pinning), deployment gating, monorepo CI, or self-hosted runner decisions.

Selecting, sizing, licensing, running, and fine-tuning open-weight LLMs on local or self-hosted hardware — VRAM arithmetic (params × quant + KV cache), MoE offload, GGUF quant levels, llama.cpp/Ollama/LM Studio/vLLM selection, license reading (Apache-2.0 vs community licenses), local-vs-API decisions, and hybrid routing. Load when someone asks "can I run X on Y GPU", "which open model", "is Q4 good enough", or wants to replace an API model with a self-hosted one.

Designing conversation as a product surface — dialogue state and memory architecture, grounding/honesty and trust UX, misunderstanding repair, personalization boundaries, voice-specific constraints, multi-turn prompt architecture and history truncation, and conversational metrics. Load when building or fixing a chat/voice assistant product, designing its memory or state handling, or evaluating multi-turn quality.

Load when writing or reviewing Terraform/OpenTofu (or Pulumi/CDK), designing module or state architecture, debugging state drift or plan surprises, choosing between IaC tools, handling secrets in IaC, or setting up environments and policy checks for infrastructure changes.

Load when deciding whether/how to pay down technical debt — prioritizing refactoring vs features, evaluating a rewrite vs incremental migration, building a debt registry or business case for debt work, interpreting code-quality/DORA metrics as debt evidence, or managing debt accumulation from AI-generated code. Also when a user says "the codebase is a mess", "should we rewrite", or "how do I get time for refactoring".

Load when building anything that processes a language — parsers, interpreters, compilers, linters, formatters, config formats, template engines, query languages, or DSLs. Covers the lexing/parsing decision ladder, expression precedence, AST and visitor design, scoping and type checking, IR optimization, interpreter performance, error reporting, and embedded-vs-external DSL choice.

Load when building or debugging numerical simulations and scientific computation — ODE/PDE solving, Monte Carlo methods, stochastic models, scipy/NumPy/JAX numerical code, solver selection and tolerances, reproducibility with random seeds, unit handling, or validating simulation correctness and performance.

Engineering with AI coding agents — writing specs that work first-try, curating CLAUDE.md/AGENTS.md context, decomposing tasks for delegation, choosing delegate-vs-write-myself, reviewing AI-generated diffs, and agentic workflow patterns (subagents, worktrees, headless fan-out, CI agents). Load when planning how to use a coding agent on a task, setting up a repo for agents, reviewing AI-written code, or diagnosing why agent output keeps missing the mark.

Load when writing or reviewing Dockerfiles, debugging slow or bloated image builds, choosing base images, containerizing an app for production, setting up docker-compose for local dev, or handling container security (secrets, non-root, signal handling, registries, multi-arch).

Load when adding, evaluating, upgrading, pinning, vendoring, or auditing third-party dependencies — package.json/pyproject/Cargo.toml changes, lockfile conflicts, Renovate/Dependabot setup, npm/PyPI supply-chain concerns, "should we use library X", CVE-driven upgrades, or monorepo internal versioning. Covers dependency risk economics, semver reality, install-script attacks, provenance, and upgrade cadence.

Load when designing, costing, or debugging production model inference infrastructure — choosing managed API vs serverless GPU vs dedicated cluster, GPU utilization economics and break-even math, autoscaling and cold starts, token streaming/SSE and retry semantics, multi-model and LoRA serving, model rollout, or serving observability (TTFT, queue depth, KV cache).

Engineering with vision, audio, document, and video models — image token/cost arithmetic, preprocessing (crop/tile/zoom), PDF and document-AI pipeline choices, structured extraction with grounding, voice-agent latency architecture (STT/LLM/TTS vs speech-to-speech), video frame sampling, and evaluating multimodal outputs. Load when building anything that feeds images/PDFs/audio/video to a model or generates images/speech.

Load when building realtime or collaborative web features — choosing transports (SSE vs WebSocket vs WebRTC vs polling), reconnection/resume logic, live sync architectures (CRDT/OT/server-authoritative), presence, message ordering and idempotency, fan-out scaling, or offline-first sync engines.

Architecting agentic LLM systems — tool design, context management over long horizons, single-agent vs multi-agent vs code-orchestrated workflows, error recovery and stopping criteria, verification after mutations, human-in-the-loop placement, and agent evaluation. Load when designing or debugging an agent, an agent's tool set, a multi-step LLM workflow, or an agent that loops/stalls/claims false success.

Load when curating, cleaning, labeling, or formatting datasets for training or fine-tuning AI models — deduplication, decontamination, synthetic data generation, LLM-assisted labeling, chat-format preparation, data versioning, or auditing a dataset before a training run.

Load when designing an algorithm from scratch — competitive-programming problems, interview questions, or production code where the naive approach is too slow. Covers problem classification, invariant-first design, greedy proof obligations, reductions to known problems, two-pointer/sliding-window/monotonic-stack triggers, randomization, and systematic boundary handling.

Load when building or reviewing the analytics/warehouse layer — dbt projects, dimensional models, marts, metrics/semantic layers, warehouse cost or platform choices (Snowflake/BigQuery/Databricks/DuckDB), analytical SQL correctness (window functions, fan-out joins, null handling), or BI-layer architecture.

Load when writing or reviewing code that encrypts, hashes, signs, stores passwords, generates tokens, configures TLS, or handles JWTs/keys — or when choosing crypto primitives, libraries, or parameters. Also load when auditing code for timing side channels, nonce reuse, or key-management flaws.

Load when designing or reviewing login, sessions, tokens, OAuth/OIDC/SAML flows, passkeys/WebAuthn, MFA, multi-tenant identity, or B2B SSO/SCIM — or when auditing auth code for holes like missing state, open redirects, JWT misuse, or token-storage mistakes.

Engineering agents that write code — harness design (Claude Agent SDK and similar), tool sets for file/search/execution, context engineering over long tasks, sandboxing and permission models, verification loops, multi-agent fan-out, and evaluating coding agents. Load when building or debugging a coding agent, designing its tools/permissions, or diagnosing failures like premature completion, error loops, or scope drift.

Load when adding or reviewing any cache — Redis/Memcached, CDN, HTTP caching, in-process memoization, or materialized views — or when debugging stale data, cache stampedes, low hit ratios, or invalidation bugs. Also load when someone proposes "just cache it" as a performance fix.

Load when designing or reviewing a command-line tool — argument/subcommand structure, flags vs positionals, exit codes, stdout/stderr separation, --json and color/TTY output handling, config precedence, error message wording, destructive-action safety, help text, choosing a CLI framework (clap, click/typer, cobra, commander/oclif/citty), or picking a distribution strategy per language.

Load when designing, reviewing, or debugging architectures on AWS — choosing compute (Lambda/Fargate/ECS/EC2), storage (S3/EBS/EFS/DynamoDB/RDS), VPC networking, IAM policies, multi-AZ/multi-region decisions, or diagnosing AWS bill shock and outage patterns. Also load when someone asks "which AWS service should I use for X".

Load when designing, reviewing, or debugging architectures on Microsoft Azure — choosing compute (Functions/Container Apps/AKS/App Service), Entra ID and managed identities, storage/database selection (Blob, Cosmos DB, Azure SQL, PostgreSQL), VNets and private endpoints, Bicep vs Terraform, landing zones, or Azure OpenAI/Foundry integration. Also load for AWS-to-Azure translation questions.