Stoica-Mihai

opsx-exttask-queue

Use when the user wants new code written or new behavior added that naturally splits into multiple independent changes — "add X and Y and Z", "build the whole auth system", "migrate the service", or "do this task" when the scope clearly spans several discrete pieces. Orchestrates structured codebase exploration, change queue planning, isolated worktree execution per change, and spec verification. Prefer `opsx-ext:task` for single-change requests that don't need a queue or isolated worktrees. Skip for questions, explanations, bug fixes, single-line patches, console.log debugging, version bumps, and /opsx command runs.

opsx-exttask

Use when the user wants new code written or new behavior added — "add X", "build X", "implement X", "create X", "migrate X", or "do this task". Drives a single OpenSpec change end-to-end in the current working tree — explore, plan, self-review, implement, test, verify, then hand back for review and commit. Prefer `opsx-ext:task-queue` when the request clearly splits into multiple independent changes that benefit from isolated worktrees. Skip for questions, explanations, bug fixes, single-line patches, console.log debugging, version bumps, and /opsx command runs.

tdd

Test-Driven Development workflow. Use when the user asks to work test-first, says "tdd", "/tdd", "write tests first", "red green refactor", "test-driven", or explicitly wants failing tests before implementation. Also trigger when the user says "add tests for X then implement" or "start with a test". Do NOT trigger on general coding requests that don't mention test-first intent.

Code & Development Listed

commit

Handles git commits with concise, list-style messages and no co-author trailers. Use this skill whenever the user asks to commit, says "commit", "/commit", "commit this", "save my changes", or any variation of requesting a git commit. This skill MUST be used for every commit operation — it overrides the default commit behavior.

code-audit-deep

Line-level code audit skill. Surfaces concrete, actionable findings — perf hotspots, error-handling correctness bugs, durability / ordering bugs, memory-shape problems, function-level complexity, semantic coupling, and concurrency-primitive scope mistakes — that file-level architectural analysis cannot see. Language-agnostic. **This skill owns the word "hotspots" when the user wants line-level findings inside files** — phrasings like "what are the hotspots", "where are the hotspots in X", "find hotspots in this file", "show me the hotspots", "any hotspots in commit.rs?" all trigger this skill; prefer this over `architectural-hotspots` whenever the user is pointing at code and asking what's wrong with it, rather than asking which files in the repo are structurally suspect. Also trigger on "audit this", "review this code", "audit X", "review X", "find bugs in X", "what's wrong with X", "deep review", "perf review", "look for correctness issues", "what can go wrong here", "where is this slow", "any sketchy code

architectural-hotspots

Surfaces architectural hotspots in a codebase — high-coupling hub files, tangled high-fan-out modules, oversized god modules, and dependency cycles. Use this skill when the user asks where to refactor, which files are architecturally problematic, which modules are most tightly coupled, where the tech debt is concentrated, what should be split up, or how the dependency structure of a project looks. Also trigger on phrases like "find hotspots in this repo", "coupling problems", "god classes", "circular dependencies", "refactor candidates", or "which files do too much" — even if the user does not say the word "architecture". This skill is **scope: whole repository**. If the user is pointing at a specific file or asking what is wrong *inside* a file ("hotspots in commit.rs", "audit this file", "what's wrong with X"), defer to the companion `code-audit-deep` skill — that one produces line-level findings, this one produces file rankings. When the user asks the broad "what are the hotspots?" without naming a file, r

dry-principle

Enforces DRY (Don't Repeat Yourself) thinking across all programming tasks — writing new code, reviewing code, fixing bugs, refactoring, editing config, schemas, tests, and documentation. Use this skill for ANY coding or programming-related task: feature implementation, bug fixes, code review, refactoring, writing tests, editing configuration, database schema changes, build system modifications, or documentation updates. This skill should trigger whenever Claude is about to write, modify, or review code or code-adjacent files. Even if the user doesn't mention "DRY" or "duplication", this skill applies to all software engineering work.

fact-check

Enforces evidence-based reasoning for any task that involves making factual claims about a codebase — debugging, bug fixing, code investigation, code modification, AND explaining what code does, answering "where is X" / "what does Y do" / "is this safe", or summarizing behavior. Use this skill whenever the user asks to fix a bug, investigate an issue, modify existing code, trace a problem, debug behavior, refactor, change, update code, or explain/locate/audit any part of the codebase. This skill ensures Claude gathers real evidence from source code, docs, git history, and runtime behavior before making any claim — never guessing, never paraphrasing comments as fact, never relying on training memory. Even if the task seems straightforward, use this skill to guarantee that every claim and recommendation is grounded in verified facts.

smoke-test

Designs and scaffolds smoke-test suites (build-verification tests) for web services, APIs, and software systems. Use this skill whenever the user asks to "add smoke tests", "set up build verification", "write a fast test that proves the deploy isn't broken", "what should my smoke tests cover", "wire smoke tests into CI", or anything else about catching catastrophic failures before downstream testing. Also trigger on "BVT / BAT", "intake testing", "sanity vs smoke", "build acceptance". The skill detects the project's stack (Python/FastAPI, Node/Express, Go net/http, Rust/axum, etc.), proposes a focused 5-10 check suite following the API-first, <2-minute, idempotent discipline, and emits a runnable scaffold in the right framework — with `TODO` markers for environment-specific values like base URL and auth tokens. Even if the user has not explicitly said "smoke", trigger when they ask for a "fast CI gate", "deploy-readiness check", "is-the-build-up test", "happy-path coverage", or describe symptoms like "we keep

skill-builder

Create new skills, modify and improve existing skills, and measure skill performance with **unbiased blind evaluations**. Drop-in replacement for `skill-creator` that fixes its central design flaw — the same agent writing the skill also writing the tests, which lets implementation knowledge contaminate prompt selection. `skill-builder` delegates eval authoring to a blind subagent that sees only the skill's name + description, never the SKILL.md body, scripts, or fixtures. Use whenever the user wants to create, modify, or benchmark a skill, or optimize a skill's description for triggering accuracy.