38 skills (repositories by vinvcn) · sorted by popularity
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.
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.
Summarize the current conversation into a handoff document so another agent can continue the work. Reference existing artifacts, suggest skills for the next session, remove sensitive information, and save the document in the operating system’s temporary directory.
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.
Translate English skill documentation into Simplified Chinese while preserving commands, code, paths, and identifiers. Follow a shared glossary, refresh changed content, and review document structure and public indexes to keep the localized edition consistent.
Refine a plan or design through an ongoing interview while creating documentation. The skill combines grilling and domain-modeling to produce architectural decision records, which capture design decisions, and a glossary of relevant terms.
Examine a plan, decision, or idea through rounds of questions with recommended answers. Each response reveals the next decisions to discuss, helping clarify assumptions and build a shared understanding before taking action.
Turn recurring activities into workflow specifications through a focused interview. The skill clarifies triggers, human review points, and working terminology, recording enough detail for an implementing agent to build the workflow without further questions.
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.
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.
Write and revise documents that guide AI agents, including skills and AGENTS.md files. Organize steps, define checkable completion criteria, and clarify when to load references so agents can follow a consistent process across different tasks.
Ask an agent to restate an unclear message with more background, using the conversation's language and the project's glossary. It applies simplified technical writing guidance to help explain how the discussion reached its current point.
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.
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 checks that run before each commit using Husky, lint-staged, and Prettier. Format staged files, run existing type-check and test scripts, then verify and commit the configuration.
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.
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.
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.
Implement work described in a specification or set of tickets, using test-first development where agreed. Run type checks and tests throughout, review the completed changes, and commit the work to the current branch.
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.
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.