3metaJun
UserPortable engineering skills and installer for Codex, Claude Code, OpenCode, and pi.
Categories
Indexed Skills (49)
reproduce-and-fix-issues
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.
setup-benny
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.
triage-issue-reports
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.
blast-radius
Find what a change could break beyond its diff, then prove the one or two safety-critical facts by running real code. Use for change-risk analysis, suspicious small diffs, migrations, or requests such as "what could this break?"
codebase-design
Design or review a module's public interface, seam placement, depth, and testability. Use for module boundaries, pass-through abstractions, dependency injection, or alternative interface designs, not routine implementation inside an established design.
create-verification-skill
Generate a durable project-local verification skill that launches and drives the real app, captures evidence, and cleans up safely. Use when the user explicitly asks to create or bootstrap a reusable verification or control workflow, not for a one-time verification pass.
diagnosing-bugs
Diagnose hard, flaky, intermittent, environment-specific, or performance regressions, especially when a prior fix failed. Use a tight reproduction and falsifiable hypotheses; do not invoke for a straightforward bug with an obvious local cause and cheap test.
recall
Reconstruct recent working context from the active harness history, repository state, and shared project records, then return a concise current-state brief. Use for catch-up, resume, handoff, or "where did I leave off?"
show-me-your-work
Keep a reviewable, append-only TSV decision trail for long-running, unattended, multi-agent, or multi-phase work. Use when a human will review important choices and evidence after stepping away.
principle-boundary-discipline
Concentrate validation, narrowing, error translation, and framework adaptation at system boundaries while keeping internal business logic typed, trusted, and pure.
principle-build-the-lever
For repeated, bulk, or mechanically consistent edits, migrations, analyses, and checks, build the smallest rerunnable codemod, script, generator, or shared workflow when its reuse or proof value exceeds its cost.
principle-fix-root-causes
Debug by reproducing the symptom, tracing the causal chain, and fixing the earliest incorrect assumption or state transition. Use for crashes, flaky behavior, restart failures, and recurring workarounds.
principle-make-operations-idempotent
Design commands, lifecycle steps, installers, migrations, and processing loops to converge safely across retries, crashes, and partial prior runs.
principle-model-the-domain
Replace scattered conditionals, synchronized booleans, repeated shape assumptions, and ad hoc mutations with a structure that directly represents the domain.
principle-prove-it-works
Verify completed work against the real artifact before declaring success. Use after implementation, configuration, migration, automation, or delegated work when compilation or self-report is not enough.
principle-separate-before-serializing-shared-state
Apply when concurrent actors may write the same file, branch, key, queue, or state object. Eliminate the shared write target first and serialize structurally only when a single canonical writer is a real invariant.
principle-sequence-verifiable-units
Break migrations, sweeps, multi-step changes, commits, and pull requests into small units that each end in a known, verifiable state before the next begins.
principle-type-system-discipline
Use in statically typed code to make illegal states unrepresentable, distinguish semantic primitives, parse external data at boundaries, exhaust variants, and derive types from authoritative schemas.
tdd
Use when the user explicitly requests TDD or a regression test, or when a bug has an obvious, cheap local test target. Skip when the test path is unclear, integration-heavy, brittle, or disproportionately expensive.
typescript-best-practices
Apply strict, modern TypeScript practices when reading or editing .ts or .tsx files, especially domain modeling, boundary parsing, exhaustive variants, inference, and removal of unsafe casts or any.
architect
Sketch types, signatures, and module structure before code, then stay in the loop while implementation fills in. Use for /architect, 'architect this', 'design this', or non-trivial work where jumping to code would lock in the wrong shape.
arena
Spawn N parallel candidates at the same task, pick a base, graft the strongest parts of the losers into it. Use for /arena, 'arena this', 'throw it in the arena', or when one attempt at a non-trivial artifact would lock in the wrong shape.
automate-me
Use for "automate me", "create/update/refresh my -mode skill", "turn/capture my preferences or working style into a skill", or wanting agents to follow how the user works. Drafts or revises a personal -mode skill via the skill-authoring workflow and unslop, optionally pulling fresh evidence from recent transcripts.
figure-it-out
Design an auditable playbook when no narrower one fits: a large migration, an ambitious multi-part change, or work a human reviews after stepping away. Scales rigor to the task, runs a hypothesis loop, and logs decisions via show-me-your-work. Use for /figure-it-out, 'figure it out', a large migration, or when no narrower playbook applies.
how
Use for "how does X work", code walkthroughs before changing something, and placement / ownership / layering questions ("where should this live", "which package owns this", "is this the right layer"). Explains subsystem architecture, runtime flow, onboarding mental models. Use why for motivation.
interrogate
Use for "interrogate", "adversarial review", "multi-model review", "challenge this", "stress test this code", "find blind spots", or "tear this apart". Multiple LLM reviewers challenge changes from independent angles.
maintain-verification-skill
Periodic pass that keeps a project's verification skill and feature map honest: parallel source readers per feature, one live session driving every feature, at most one PR of proven corrections. Use for /maintain-verification-skill or "audit the verify skill".
make-bot-ui
Use when building a custom UI (page, dashboard, buttons) that should wake a Grok Bot over a webhook, when the user must provide a webhook sender key, or when exposing that UI on Tailscale.
meta-mode
Route a non-trivial engineering task through a verifiable mstack workflow and the capabilities available in the current harness.
no-comments
Delegate comment review, fix accepted findings, and offer encodings for claimed constraints.
principle-test-behavior-not-implementation
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.
reflect
Spawn three parallel review subagents over the active transcript, surface learnings, and route each to a concrete edit on an existing skill. Use when the user says reflect.
setup-mstack
Configure the model used by each mstack role. Use for /setup-mstack, configuring mstack models, or changing model choices.
teach
Explain a body of work plainly so a person actually understands it. Runs the `how` and `why` skills and weaves what they find into one clear explanation. Use for 'teach me this', 'help me really understand X', 'explain this change or subsystem to me'.
technical-writing
Layered technical-writing standard: Diátaxis structure, Google developer style sentences, STE instruction rules, Global English syntax. Use for /technical-writing or when writing or reviewing docs, RFCs, readmes, PR descriptions, or commit messages.
principle-attack-the-premise
Apply when two or more fixes that share one premise have failed the same gate. Take a census of which actors hold the imbalance before the next fix, then question the premise instead of writing another fix that assumes it.
principle-encode-lessons-in-structure
Apply when you catch yourself writing the same instruction a second time, or notice a recurring correction. Encode the rule as a lint, metadata flag, runtime check, or script instead of more text.
principle-exhaust-the-design-space
Apply when facing a novel UI interaction or architectural decision with no precedent in the codebase. Build 2-3 competing prototypes and compare side by side before committing.
principle-experience-first
Apply when product, UX, or feature-scope tradeoffs come up. Choose user delight over implementation convenience; ship fewer polished features over more rough ones.
principle-foundational-thinking
Apply before writing logic: choosing core types and data structures, sequencing scaffold-vs-feature work, asking what concurrent actors share. Get the data structures right so downstream code becomes obvious.
principle-guard-the-context-window
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.
principle-laziness-protocol
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.
principle-migrate-callers-then-delete-legacy-apis
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.
principle-minimize-reader-load
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.
principle-never-block-on-the-human
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.
principle-outcome-oriented-execution
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.
principle-redesign-from-first-principles
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.
principle-subtract-before-you-add
Apply when sequencing an addition, refactor, or rewrite. Remove dead code, redundant validators, and stub references first, then build on the simpler base.
swarm
Fan out N parallel workers, drain them, and return one report. Use for /swarm, 'swarm this', or parallel coverage, races, gauntlets, and exploration.
Bio shown is the top-scored skill's repo description as a fallback — real GitHub bios land in a future update.