Review changes from a chosen Git reference against both project coding standards and issue or specification requirements. Separate parallel reviews report rule violations, possible design problems, missing requirements, and changes beyond the intended scope.
Turn existing Markdown material into an article by choosing among suggested next passages. Establish what readers already know, introduce concepts before relying on them, and build the article one selected passage at a time.
Turn plans, specifications, or conversations into small implementation tickets that each deliver verifiable behavior. Define acceptance criteria and dependencies, review the breakdown together, then publish approved tickets to the configured tracker or local Markdown files.
Find the right skill and sequence for your current development task, from shaping an idea to implementation, debugging, and review. The guide also explains when to prototype, prepare specifications, or move work into a fresh session.
Design modules that expose simple interfaces while hiding substantial behavior. Use shared terms and principles to assess interface complexity, decide where behavior can be swapped, and organize code so callers and tests use the same interface.
Diagnose difficult bugs and performance regressions by first building a repeatable check for the exact symptom. Minimize the reproduction, test ranked hypotheses, apply a fix, and verify the original scenario with regression tests where suitable.
Clarify project terminology and the relationships between business concepts. Check definitions against concrete scenarios and code, update GLOSSARY.md as terms are agreed, and record significant design decisions with their trade-offs when the stated criteria are met.
Turn a specification and its linked tickets into code. Multiple agents work on available tasks in separate worktrees, combine changes on one integration branch, and complete a code review before preparing the result for review or closing tickets.
Review a codebase for design friction and compare refactoring candidates in an HTML report with before-and-after diagrams. Then explore a chosen candidate through questions about constraints, module design, and testing.
Draft or revise pull request descriptions that show the change, evidence of its behavior, and merge risks. Use concise diagrams, trees, or diffs alongside before-and-after results to help reviewers assess impact and how easily changes can be reversed.
Build a disposable prototype to answer a specific design question. Use a shareable HTML demo to explore logic and state changes, or compare distinct UI variations on one route, then record the decision and retain the prototype separately.
Research a question using original sources such as official documentation, source code, and specifications. A background agent records findings with sources for each claim and saves a Markdown note following the repository’s existing conventions.
Review a coding session to identify improvements to the agent’s working environment. Get prioritized suggestions for finding files, strengthening automated checks, clarifying guidance, reducing costly tool calls, and accessing missing information.
Set up the repository settings that engineering skills read: where work is tracked, which triage labels to use, and where domain documents belong. Review existing files and confirm drafts before writing configuration documents.
Build features or fix bugs by writing one failing test, then the minimum code needed to pass it. Test agreed public interfaces, the boundaries callers use, to check behavior without depending on internal implementation details.
Turn an existing conversation and codebase context into a feature specification. Organize user needs, implementation decisions, testing plans, and scope, then publish the specification to the project’s issue tracker with a label marking it ready for agent work.
Review issues and external pull requests, classify them, verify their claims, and assign a handling state. The skill checks existing implementations and past rejections, requests missing details, and prepares briefs that agents or human maintainers can act on.
Turn a large, unclear idea into a shared map of decisions in an issue tracker. Record answers, dependencies, and unresolved questions across sessions until the route to a defined goal is clear enough to hand off.
Summarize the current conversation and launch a fresh background agent to continue the work. The handoff includes references to existing artifacts and suggested skills, removes sensitive information, and can emphasize the next session’s intended focus.
Set up dependency-cruiser in a TypeScript repository to enforce package boundaries: outside code uses public entry files while implementation stays in subfolders. Add checks, a starter package, and documentation, then verify that forbidden imports fail.
Explore a writing topic through ongoing questions and collect sentences, experiences, metaphors, and unfinished thoughts in one Markdown file. Build a pool of usable material without committing to an outline or article structure.
Shape Markdown notes, fragments, or transcripts into a separate article through a collaborative drafting session. Choose an opening, establish what readers already know, and develop each paragraph or block in an order that introduces concepts before relying on them.
Set up Claude Code hooks that block specified Git commands before they run, including push and destructive cleanup operations. Choose project or global installation, adjust the blocked commands, and test that the hook rejects a sample command.
Migrate TypeScript test data from type assertions to @total-typescript/shoehorn helpers. Use partial objects for focused tests and deliberately invalid data for error cases, then check that the migrated tests pass type checking.
Is this your account? Link GitHub to bring it onto your creator page (Japanese)