Technical research consumes time and often relies on unsupported secondary summaries. This skill delegates source review and saves cited findings in a repository Markdown file.

Large refactors often fail because scope, testing, and sequencing remain unclear. This skill inspects the repository and creates an incremental plan for a GitHub issue.

Bug reports often lack reproducible details and clear scope. This skill clarifies each report, applies project terminology, and files structured GitHub issues.

Design decisions are difficult to evaluate before users can interact with them. This skill builds disposable prototypes that expose state behavior or compare interface variants.

Finding and connecting notes in a flat Obsidian vault can be slow. This skill searches notes, creates consistent files, and maintains wikilinks and indexes.

Type assertions can hide incomplete or invalid test fixtures. This skill converts common assertions to Shoehorn helpers while preserving test intent and type feedback.

Vague recurring tasks are difficult to delegate or automate. This skill asks focused questions and produces implementation-ready workflow specifications in your workspace.

Architecture reviews often miss shallow modules, scattered decisions, and weak test surfaces. This skill guides AI agents to find practical refactoring opportunities using project language.

Detailed requirements can still produce inconsistent implementation and verification. This skill executes PRD or issue work with regular checks, final testing, review, and commit.

Long conversations make session changes difficult and can expose sensitive details. This skill creates a concise, redacted handoff that references existing artifacts.

Unresolved assumptions weaken plans and technical designs. This skill conducts a focused interview and uses domain modeling to produce ADRs and a glossary.

Plans and designs often fail because weak assumptions are found too late. This skill starts a focused grilling session that challenges gaps before execution begins.

Unresolved decisions can make a plan expensive to change during implementation. This skill interviews you systematically and recommends an answer for each decision.

AI coding sessions can accidentally run destructive git commands. This skill installs a Claude Code hook that stops high-risk git operations before execution.

Article drafts often bury key ideas or present them before essential context. This skill reorganizes sections, confirms the plan, and rewrites concise paragraphs for clearer reading.

Inconsistent domain terms create unclear requirements and fragile boundaries. This skill builds a shared glossary, maps contexts, and records consequential decisions.

Hard bugs waste time when investigation starts without a reliable reproduction. This skill builds a tight feedback loop, tests hypotheses, and verifies durable fixes.

Hard bugs waste time when teams guess before reproducing the failure. This skill guides Claude, Codex, or Claude Code from reproduction to regression test.

A first interface idea can hide weak assumptions and unnecessary complexity. This skill generates distinct options, compares trade-offs, and helps select or synthesize a stronger design.

Complex planning work often stalls when open decisions mix with implementation tasks. This skill turns uncertainty into compact tickets and guides each session to resolution.