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.