Teams need consistent skill files that agents can discover and use correctly. This skill guides authors through structure, descriptions, examples, scripts, and review checks.

Manual setup and migration procedures are easy to miss or repeat incorrectly. This skill creates interactive Bash wizards with guided stages, confirmations, and value handling.

Large efforts lose context when they exceed one agent session. Wayfinder organizes decisions as a shared issue map that agents resolve incrementally.

Teams lose clarity when one concept has several names or one term has several meanings. This skill creates a canonical DDD glossary from your conversation.

Issue queues become difficult to manage when reports lack clear categories, evidence, or next steps. This skill verifies requests and moves them into actionable states.

Large engineering plans often become vague task lists with unclear dependencies. This skill turns plans into vertical-slice tickets with blockers, acceptance criteria, and tracker-ready wording.

Planning work from a long conversation can lose decisions, constraints, and testing intent. This skill turns existing context into a structured spec and publishes it to the issue tracker.

Important decisions can stall when one person lacks key context. This skill creates a focused questionnaire that helps the informed recipient provide the needed facts.

Important product decisions often remain scattered across conversations and code context. This skill synthesizes them into a structured PRD and publishes it to your issue tracker.

Large plans are difficult to divide into independent engineering work. This skill creates approved vertical-slice issues with dependencies, acceptance criteria, labels, and tracker links.

Long-term learning loses context across separate AI sessions. This skill organizes goals, trusted resources, short HTML lessons, references, and progress records inside one workspace.

Test-first work often becomes brittle when teams test internals or write too many tests upfront. This skill guides Codex, Claude, and Claude Code through behavior-focused red-green-refactor cycles.

Deep imports expose internal TypeScript package code and weaken architecture. This skill installs dependency-cruiser rules, validates failures, and documents stable entry-point boundaries.

Manual formatting and validation allow avoidable issues into commits. This skill configures Husky, lint-staged, Prettier, type checks, and tests for consistent local checks.

Engineering skills need consistent repository conventions before they can manage work reliably. This skill gathers user choices and creates the required agent guidance files.

Course exercise setup can be slow and inconsistent across sections. This skill helps Claude, Codex, and Claude Code create lint-ready exercise folders with clear variants and readme stubs.

Merge and rebase conflicts often hide competing design intentions. This skill guides Claude, Codex, and Claude Code through research, resolution, validation, and completion.

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.