Claude Skills by williamwue

Apply when context is filling up: large outputs, long files, repeated reads, fan-out planning. Route bulk to subagents; keep summaries in the main thread, not raw payloads.

Apply when refactoring, evaluating diff size, or tempted to add abstractions, layers, or signal threading. Bias toward deletion and the smallest change that solves the problem.

Apply when designing commands, lifecycle steps, or processing loops that run amid crashes, restarts, and retries. Converge to the same end state regardless of partial prior runs.

Apply when introducing a new internal API while old callers still exist. Migrate callers and delete the old API in the same wave instead of preserving compatibility layers.

Apply when reviewing or shaping code that's hard to trace. Count layers between question and answer, and hidden state in the reader's head; collapse one-caller wrappers and shrink mutable scope.

Apply when writing stateful logic, or when code branches a lot or repeats a shape assumption across files. Encode the domain in a structure instead of scattered conditionals.

Apply when tempted to ask 'should I do X?' on reversible work. Proceed, present the result, let the human course-correct after the fact; reserve confirmation for irreversible actions.

Apply during planned rewrites and migrations with explicit phase boundaries. Converge on the target architecture; don't preserve smooth intermediate states with throwaway compatibility code.

Apply after completing a task, before declaring done. Verify against the real artifact (run the feature, read the actual value, inspect the diff), not a proxy, self-report, or 'it compiles.'

Apply when integrating a new requirement into an existing design. Redesign as if the requirement had been a foundational assumption from day one, instead of bolting it on.

Apply when concurrent actors might write to the same file, branch, key, or state object. Eliminate the sharing first; serialize structurally only when one shared writer is a real invariant.

Apply to multi-step work (sweeps, migrations, runs of similar edits) and to how you stack commits and PRs. Break work into small units that each end in a verifiable state, check each before the next, and order delivery so the sequence proves itself to a reviewer.

Apply when sequencing an addition, refactor, or rewrite. Remove dead code, redundant validators, and stub references first, then build on the simpler base.

Apply when you write, change, or keep a test. Call the code the way its users do and assert the result they observe against a literal expected value. If the test would still pass when every imported function returns undefined, rewrite the assertion or delete the test.

Apply when designing types, reviewing a function signature, or writing code in any statically-typed language. Make illegal states unrepresentable, brand semantic primitives, parse external data at boundaries, refuse to lie to the compiler, exhaust variants, derive from authoritative schemas.

Build an isolated throwaway experiment that produces evidence for one explicit design or behavior decision.

Verify that this workflow package can load a Skill and report concrete read-only workspace evidence.

Reconstruct recent work from scoped conversation history, current repository state, and available shared records.

Improve code structure while pinning and proving unchanged externally observable behavior.

Review a scoped conversation for recurring lessons and propose evidence-backed corrections to existing Skills.

Reproduce triaged Slack bugs through a configured app-control adapter, verify existing fixes, and open a bounded draft pull request only after before-and-after proof. Use only from the configured Benny repro automation.

Diagnose a live process from captured runtime evidence and connect the observed mechanism to source.

Resume or take over prior in-flight engineering work from a checkpoint, transcript, or branch without repeating completed work or inheriting stale authority.

Configure Benny and prepare its triage and repro automations. Use when installing Benny or changing its Slack, tracker, repository, routing, control, model, or budget settings.

Preview and configure pstack-style per-workflow models, review panels, and reasoning budget from the current runtime inventory.

Land an explicitly authorized pull request or stack only after independent revision-bound verdicts establish a contiguous safe frontier.

Keep a reviewable, append-only decision trail for long-running, delegated, or unattended work.

Run bounded parallel coverage or races, drain all started workers, verify their evidence, and consolidate outcomes and gaps into one report.

Use only when the user explicitly asks for TDD, a failing test, or a regression test, OR when the bug has an obvious cheap local test target. Skip when the test path is unclear, expensive, integration-heavy, or not requested.

Teach a change or subsystem in plain language by composing verified mechanics and historical rationale, preserving uncertainty and the learner's pace.

Write or review technical documents, README files, RFCs, PR descriptions, or commit messages.

Diagnose an existing trace, profile, heap snapshot, or spindump without recapturing the process.

Triage Slack issue reports with one thread-only verdict, evidence review, cause-aware routing, tracker dedupe, and fail-closed ticket creation. Use only from the configured Benny triage automation.

Review or edit TypeScript types and boundaries when TS or TSX code is in scope.

Edit prose to remove recurring AI writing patterns when writing cleanup is requested.

Migrate a UI while proving agreed visual equivalence against frozen baseline captures.

Investigate design rationale, historical tradeoffs, regressions, and thresholds using cited history and available evidence sources.

Audit and reclaim explicitly scoped Git worktrees and disposable simulator state while preserving active and uncommitted work.

poteto's agent style for concise, detailed responses, deliberate subagents, unslopped prose, simple code, and verified work. Use for poteto, /poteto-mode, or requests to work in this style.

Vet a perf measurement (limiter, tuning, limits, errors, repeatability, relevance, and whether the work happened) before you report or act on it. Use when you run a benchmark or report a speedup or regression you measured.

Eliminate repeated repository mistakes through architecture, types, diagnostic checks, and behavior tests, with proof against real past failures.

Answer Oh My Stack setup and workflow questions with verified sources and one usable prompt; route explicit work requests through poteto-mode.

Vet performance measurements before reporting or acting on them.

Prevent repeated repository mistakes with structural checks and failing proof.

Answer setup and workflow questions with a usable prompt and verified source.

Explain what a measured number means and rule out misleading results.

Vet a perf measurement (limiter, tuning, limits, errors, repeatability, relevance, and whether the work happened) before you report or act on it. Use when you run a benchmark or report a speedup or regression you measured.

Eliminate repeated repository mistakes through architecture, types, diagnostic checks, and behavior tests, with proof against real past failures.

Answer Oh My Stack setup and workflow questions with verified sources and one usable prompt; route explicit work requests through poteto-mode.

Guides users through pstack setup, /poteto-mode, and picking the skill, playbook, or principle for a task. Type /poteto-help with a question.