devskills

Design a target architecture for a new system — module boundaries, dependency rules, seams, and build order — from its requirements. Reports a blueprint; changes nothing.

Analyze an existing codebase's architecture and produce a sequenced refactoring plan — assess module boundaries, dependency structure, and layering, then lay out ordered, risk-tagged steps. Language-agnostic. Reports a plan; changes nothing.

Turn a goal or another command's output into an ordered task roadmap.

Find the root cause of a failure with the scientific method — reproduce, isolate, fix, then prove it.

Interview the user relentlessly about a plan or design until reaching shared understanding.

Run an extremely strict maintainability + single-source-of-truth review of code changes — abstraction quality, file sprawl, spaghetti-condition growth, and duplicate/competing implementations. Reports findings by default; `--fix` applies the mechanical, unambiguous ones — structural/code-judo restructurings rest on judgment and stay reported.

Drive implementation with tests, one vertical slice at a time.

Activate pragmatic testing mode for this session.

Run a strict review of test quality — whether the code that matters is well tested, and whether the tests are good ones. Reports a findings list by default; `--fix` applies the mechanical, unambiguous fixes (writing or redesigning tests stays reported).

Compact the current conversation into a handoff document so a fresh agent can continue the work.

Sweep the session for durable context and route each piece to its owning file, so the session can be cleared or ended safely.

Activate git mode for this session.

Activate senior-engineer mode for this session.

The devskills router — names every skill by phase (orient → spec → plan → build → clean → review → verify → ship) and when to reach for it.

Analyze code for optimization opportunities and produce a graded performance plan — a ranked set of moves, each tagged by the architectural cost it incurs (L1/L2/L3). Language-agnostic. Reports a plan; changes nothing.

Run a strict correctness review of code changes — hunt real bugs, not style or structure. Reports a findings list by default; `--fix` applies the mechanical, unambiguous fixes (logic-changing or uncertain ones stay reported).

Run a strict review of code comments — flag the comments that don't earn their place and tighten the rest to the discipline. Language-agnostic. Reports a findings list by default; `--fix` applies the edits in place.

Run a strict data review of code changes — find data-correctness, integrity, and migration-safety defects. Store-agnostic (relational or NoSQL). Reports a findings list by default; `--fix` applies the mechanical, unambiguous fixes (logic-changing or uncertain ones stay reported).

Run a strict review of documentation quality — accuracy against the code, broken links and stale counts, coverage gaps, and bloat. Reports a findings list by default; `--fix` applies the mechanical, unambiguous fixes.

Review Go code with Tiger Style constraints and Go idioms.

Review Java code with Tiger Style constraints and Java idioms.

Run a strict review of Jupyter notebooks — find notebook-state, output-hygiene, reproducibility, and data-science correctness defects a line-by-line code review can't see. Reports a findings list by default; `--fix` applies the mechanical, unambiguous fixes (logic-changing or uncertain ones stay reported).

Review Python code with Tiger Style constraints and Python idioms.

Review Rust code for safety metrics, error handling, and idiomatic Rust.

Run a strict security review of code changes — find exploitable weaknesses. Language-agnostic. Reports a findings list by default; `--fix` applies the mechanical, unambiguous fixes (logic-changing or uncertain ones stay reported).

Review TypeScript code with Tiger Style constraints and TypeScript/Workers idioms.

Run a strict review of UI quality — whether the interface is soundly engineered, crafted, accessible, and fast. Reports a findings list by default; `--fix` applies the mechanical, unambiguous fixes (design-judgment ones stay reported).

Review Zig code with Tiger Style constraints and Zig idioms.

Configure project preferences in `.project/config.md` — currently the modes auto-applied on resume.

Restore working context from `.project/PLAN.md` (and a fresh handoff, if any), and apply any configured modes.

Summarize the provided content using extractive techniques.

Run the review pipeline against the current branch or feature as a finite quality gate — a sequenced set of strict review passes.

Convert a description into a structured specification.

Activate Tiger Style enforcement for this session.

Activate data mode for this session.

Remove AI-generated code slop introduced on the current branch and align it with the surrounding codebase.

Suggest candidate approaches to a problem — research and lay out options, but never decide.

Scan project dependencies for known vulnerabilities using OSV Scanner.

Compact the .project/ memory files — archive spent decisions and finished roadmap sections, keep the live files to what still governs. Loss-free and approval-gated.

Map the current repository into a durable project description at `.project/PROJECT.md`.