Skills

Structures on-call work: timeline, blast radius, mitigations, and customer comms—so fixes stay coordinated instead of chaotic thread hopping.

Removes Wikipedia-documented “AI writing” tells—significance inflation, -ing fluff, em-dash stacks, chatbot closers—and runs a final “still obviously AI?” pass before shipping prose.

Finds real bottlenecks using traces, flame graphs, and system metrics before rewriting code—so optimizations target measured latency, not guesses.

Shapes REST or RPC surfaces with predictable errors, pagination, and deprecation rules before implementation locks you into brittle clients.

Frames review requests around risk, test gaps, and rollout impact—so reviewers know where to spend their limited attention.

Executes a written plan in order, stopping at checkpoints to reconcile assumptions—useful for spec-driven builds and multi-step refactors.

Turns frozen requirements into step-by-step implementation plans with clear file touchpoints, checkpoints, and verifiable outcomes before any code lands.

Uses extra worktrees so parallel experiments or long-running tasks do not thrash your main working tree or stash pile.

Uses red–green–refactor loops so behavior is pinned by tests first—ideal for new features, regressions, and refactors where you need a safety net.

Splits embarrassingly parallel work—research chunks, file batches, or independent modules—across agents with crisp handoffs back to a single integrator.

Replaces guesswork with hypotheses, tight reproductions, and evidence—so you fix root causes in production incidents, flaky builds, and confusing regressions.

Coordinates subagents on slices of a larger plan—ideal when one thread would be too slow but you still need a single accountable integration point.

Creates or edits raster artwork for covers, mockups, and rapid visual exploration when the deliverable should be a bitmap rather than code-first SVG.

Closes the loop on a branch: green tests, clean commits, push hygiene, and a deliberate choice between merge, squash, or follow-up tickets.

Bootstraps plugin folders, manifests, and baseline files so new Codex or editor extensions start with a consistent, reviewable structure.

Surfaces goals, constraints, and design options before implementation so you do not paint yourself into a corner on product or UX decisions.

Builds distinctive, production-grade layouts and components—spacing, typography, color, and motion—so interfaces feel intentional rather than generic.

Runs the right checks—tests, builds, or manual steps—before claiming completion so “done” always means verified in the real environment.

Prioritizes official OpenAI docs, model cards, and API references when you need accurate integration guidance rather than stale blog summaries.

Structures responses to review feedback—separating nitpicks from defects and tracking follow-ups—so merges stay focused and respectful.