dev-skills

Injected at session start. States one rule — do not start building a task silently — and names the entries that exist.

Use when a change has to be seen working in the real thing — opening the app, clicking through a flow, filling a form, reading console errors or failed requests, recording WebSocket frames, or taking a screenshot. Drives a web app or an Electron build over CDP; replaces one-off Playwright scripts and browser MCP servers for every interactive check.

Reproduce a bug, find its root cause, and leave behind a failing test that pins it. Use for any bug, test failure, or unexpected behaviour, before proposing a fix.

Create high-quality git commits: review/stage intended changes, split into logical commits, and write clear commit messages (including Conventional Commits). Use when the user asks to commit, craft a commit message, stage changes, or split work into multiple commits.

Build and sharpen a project's domain model — the glossary, and an ADR when one is earned. Invoke it directly to pin down vocabulary or record a decision; dev-skills:grill-with-docs also reaches for it as terms settle.

Use when the work is too big for one plan and needs splitting first — "this is a whole epic", "write the epic", "break this into plans", "one plan won't cover it". Writes the epic that holds the shared decisions, the vocabulary, and the list of plans the work breaks into.

Close out a run — squash it into one commit, put exactly that commit in front of the human for the run's one acceptance, and integrate it. Invoke once both gates are green.

Use when a task is still fuzzy and needs talking through before anything is planned — "let's grill this", "think this through with me", "I'm not sure what we're actually building", "help me work out what I want". Interviews the idea into a shared understanding, and ends in alignment and a stop — no document, no code.

Set up Claude Code hooks to block dangerous git commands (push, reset --hard, clean, branch -D, etc.) before they execute. Use when user wants to prevent destructive git operations, add git safety hooks, or block git push/reset in Claude Code.

Pack this session into a document a fresh agent continues from — the work, or the thinking. Type it when you are about to move to a new chat.

Execute an approved plan — create the workspace, run preflight, write the tests, dispatch the phases, join the parallel groups, drive both gates, and hand the run to the human. Invoke once the plan and its test cases are approved.

Use when the ask is open-ended improvement rather than a named change — "what could be better here", "find opportunities to improve this", "where is this codebase weak". Scans for deepening opportunities, presents them as a visual HTML report, then brainstorms through whichever one you pick.

Use when you need to resolve an in-progress git merge/rebase conflict.

Write the implementation plan — the contract a cold, cheap implementer builds from. Use when the human moves from working out what to build to writing it down ("write the plan", "переходим к плану"), when a grilling has ended in alignment, or when they name an entry from an existing epic's plan list.

Set up Husky pre-commit hooks with lint-staged (Prettier), type checking, and tests in the current repo. Use when user wants to add pre-commit hooks, set up Husky, configure lint-staged, or add commit-time formatting/typechecking/testing.

Build a throwaway prototype to answer a design question. Use when the user wants to sanity-check whether a state model or logic feels right, or explore what a UI should look like.

Investigate a question against high-trust primary sources and capture the findings as a Markdown file in the repo. Use when the user wants a topic researched, docs or API facts gathered, or reading legwork delegated to a background agent.

Review code the human points at — a PR, a branch, a file, a tree — against the same criteria the pipeline's gates use. Outside a run, and it never fixes anything. Invoke to have code judged rather than built.

The shared standard for what counts as a review finding. Not a workflow — a reference the two gates and the standalone review all read, so the standard has nowhere to drift.

Use when the question is how existing code actually works — "explain how this works", "where does this happen", "walk me through this flow", "I don't know this part of the codebase". Maps unfamiliar territory and answers the specific question; read-only, so it produces an explanation and never an edit.

Generates this plugin's five Codex roles under ~/.codex/agents from agents/*.md, so a Codex session can dispatch dev-skills-gate-a, dev-skills-gate-b, dev-skills-implementer, dev-skills-prototyper and dev-skills-test-writer as separate agents. Run once after installing the plugin in Codex, and again whenever agents/*.md or skills/tdd/SKILL.md changes.

Use when writing tests — the red-green-refactor cycle and the discipline around it: one test at a time, verify red before green, the simplest code that passes. Read by the implementer when its phases have tests.

Use when a skill must behave predictably — designing a new skill, auditing or editing an existing one, or diagnosing a skill whose agent varies from run to run.