Claude Skills by avmnu-sng

Use when structuring or auditing a repo's agent-facing documentation -- entry docs, a shared rulebook, routing and handoff tables, skill ordering, and a source-of-truth designation -- so agents and humans navigate it reliably.

Use when deciding whether to delegate work to subagents and how to prompt, verify, and integrate their output; covers what agents do well and what they systematically miss.

Use when reviewing a backend or service architecture for scalability, resource fit, and cost -- trace requests, stress each component, model 2x/5x/10x load, and produce ROI-quantified recommendations.

Use when auditing an existing codebase and sequencing fixes -- produce a structured audit doc, prioritize findings across three lenses, and split remediation work so humans and agents can proceed in parallel; not for greenfield planning.

Use when writing or revising a git commit message, splitting work into commits, or structuring a branch so a future engineer running git blame understands the change.

Use when changing a live schema or moving data in a running system -- apply expand/contract (parallel change) so old and new shapes coexist, backfill in resumable batches, verify integrity, and switch reads only after the new shape is proven.

Use when isolating a defect or root-causing a failure -- contain a live incident first, then reproduce, instrument, form one falsifiable hypothesis at a time, bisect, and prove the mechanism before calling it fixed.

Use when deciding how much energy -- tokens, agent fan-out, verification passes, independent attempts, artifacts -- a task is worth, so spend tracks complexity times blast radius without ever trading away the correctness floor.

Use when authoring a Claude Code hook -- writing a PreToolUse/PostToolUse/SessionStart/UserPromptSubmit checker -- to get the fail-open guard skeleton and advisory-vs-blocking recipes so a hook reports without ever breaking the user's flow.

Use when planning or running a large build that spans many sessions or agents, to add gates that keep the assembled, deployed system honest -- not just each component -- and to prove "done" instead of assuming it.

Use when running multiple agents or sessions concurrently against shared state, to pick an isolation regime and coordination protocol that stops two writers from corrupting the same file, branch, or working tree.

Use when optimizing runtime performance -- establish a baseline, profile the actual hot path, validate the win on a macro scenario, and lock it in with a regression guard.

Use at the end of a work session, or whenever recording a durable lesson -- run a probe-backed retro, reconcile outside critique, and capture only the lessons that survive.

Scaffold a repeatable execution-plan structure and wire in the build-orchestrator workflow when starting a large, multi-session build that must survive across many sessions.

Use before open-sourcing or otherwise publishing your own code or docs -- remove secrets, credentials, and internal identifiers, and verify the scrub with a repeated search, so nothing private ships.

Use when adding or upgrading a dependency, reviewing a lockfile diff, handling a security advisory, provisioning tokens or secrets, or vetting supply-chain risk -- the standing-liability angles that a diff-level vuln scan does not cover.

Audit a code or documentation change against the house style -- why-not-what comments, current-state docs, symbol-based references, theme-safe diagrams, and (when the project's style calls for it) ASCII-only files -- when reviewing or finishing a diff.

Use when writing, strengthening, or debugging tests -- enforces read-before-assert discipline, real assertions, and never weakening a failing test to go green.

Use when finishing a verification, cleanup, or find-and-fix sweep across a codebase and a single missed instance would be costly -- enumerate every match, fix each individually, and re-search until empty instead of summarizing and applying once.