Writing tests after code creates fragile systems that break on refactors. This skill guides you through test-driven development where tests define behavior before implementation, resulting in cleaner code and reliable refactoring.

Setting up pre-commit hooks manually involves multiple configuration files and package installations. This skill automates the entire process, giving you Husky, lint-staged, and Prettier working in minutes.

This skill configures your repository with the issue tracker, triage labels, and domain docs settings that Matt Pocock's engineering skills need to work correctly. Run once before using any of the related engineering skills.

Creating exercise directory structures for courses is repetitive and error-prone. This skill automates scaffolding sections, problems, solutions, and explainers that pass linting on the first try.

Reviewing a branch by eye misses half the picture — code can pass the style guide and still implement the wrong thing. This skill runs Standards and Spec reviews in parallel sub-agents and reports them side by side so neither axis can mask the other.

Refactors often fail because they are too large and poorly scoped. This skill drives a structured interview to produce a clear, incremental refactor plan filed as a GitHub issue.

Bug reports get lost or lack context when filed manually. This skill turns conversational QA sessions into durable, well-structured GitHub issues using your project's domain language.

Design decisions made on paper often fail when implemented. This skill helps you build quick throwaway prototypes that answer specific questions about logic or UI before committing to code.

Managing a large Obsidian vault with hundreds of notes becomes hard without consistent structure. This skill teaches Claude and Codex the naming, linking, and search conventions to keep your vault organized and discoverable.

TypeScript tests often use unsafe `as` assertions to fake large objects. This skill migrates them to type-safe shoehorn helpers, keeping autocomplete and type checking working.

Codebases accumulate shallow modules that are hard to test and navigate. This skill finds deepening opportunities by analyzing module depth and seams, then guides you through refactoring decisions to make your architecture more maintainable.

Developers lose valuable context every time they start a new AI coding session. This skill generates a compact handoff document that summarizes the current conversation, key artifacts, and next steps so a fresh agent can pick up the work immediately.

Planning discussions drift into ambiguity. This skill runs structured grilling sessions that force clarity on domain terminology, then updates CONTEXT.md and ADRs inline as understanding crystallizes.

Plans often fail because hidden assumptions go unchallenged. This skill makes the AI relentlessly interview you about every aspect of your design, surfacing gaps and resolving dependencies one question at a time.

Uncritical planning leads to overlooked flaws and failed implementations. This skill rigorously interviews your designs, exposing hidden dependencies and weak points before they become costly mistakes.

Claude can accidentally run destructive git operations like force push or hard reset. This skill installs hooks that block these commands before they execute, protecting your work from accidental data loss.

Editing an article draft can feel overwhelming when sections, flow, and clarity all need attention. This skill provides a clear, section-by-section revision process that tightens prose and improves coherence.

Software projects suffer when teams use inconsistent terminology or lose track of why decisions were made. This skill helps you actively build and sharpen your domain model by challenging terms, inventing edge cases, and capturing decisions in CONTEXT.md and ADRs.

Debugging complex bugs often leads to wasted time with unstructured trial and error. This skill provides a systematic phased methodology to build feedback loops, reproduce issues, and fix problems efficiently.

Designers often settle on the first interface idea without exploring alternatives. This skill applies the 'Design It Twice' methodology, using parallel sub-agents to generate radically different interface designs for comparison and synthesis.