Coding standards, frameworks, refactoring, and code review (16.7K skills)
Create a Technical Design Document from tickets, research, or other product context through guided questions. It settles system architecture first, then code structure, recording agreed decisions with diagrams, signatures, and sketches in a coherent design document.
Revise an existing implementation plan using feedback and related project documents. Check file paths and code examples, adjust phases, and clarify success criteria with runnable automated checks and specific manual verification steps where needed.
Expand a structure outline into a detailed implementation plan grounded in research, design decisions, and source code. Specify changes, code examples, independently testable phases, runnable checks, and concrete criteria for automated and manual verification.
Refine an existing technical design document through focused feedback and one question at a time. Compare design options, resolve decisions, and update diagrams and explanations covering both component interactions and code structure.
Prepare Git worktrees, separate working directories for task branches, using shared settings and local overrides. Copy configured files, run setup commands, and coordinate multiple repositories so implementation can begin in the prepared workspace.
Tighten React component props, the inputs passed to components, to match real application usage. Remove unsupported states and unnecessary fallback logic, then adapt tests and Storybook examples to the stricter types.
Prepare Riptide workspace settings by inspecting a project and proposing configuration files. Define Git worktrees, separate working directories for tasks, along with setup commands, copied files, and shared or machine-specific settings, then save approved configurations.
Review an existing design discussion without waiting for feedback. Check unstated assumptions against the codebase, examine implementation patterns, and add missing options or questions while preserving the agreed scope and resolved decisions.
Revise an existing implementation outline using feedback, supporting documents, and codebase findings. Reorganize phases, adjust scope, incorporate answered questions, and define checks so each phase can be verified independently.
Research how an existing codebase works by coordinating parallel research agents and combining their findings into a technical document. Explain component relationships and testing practices with diagrams, file paths, and line references that support the findings.
Write and review React components by replacing direct useEffect calls with five purpose-specific patterns. It guides state calculations, data fetching, event handling, and component resets, with useMountEffect for external setup when a component first appears.
Create or update a pull request for the current task with a concise explanation of its purpose and implementation structure. Review the diff and relevant context, highlight important considerations, and publish the description using GitHub CLI.
Bring default branch changes into a working branch and examine merge conflicts. It explains both sides of each conflict, recommends a resolution based on task context, and applies changes after the user confirms the approach.
Automate browser tasks from the terminal using the chrome-devtools-mcp CLI. Inspect page elements, click and fill forms, navigate tabs, capture screenshots, and investigate network requests, console messages, performance, and memory through shell commands.
Turn completed research and design decisions into a phased implementation outline. Each phase connects the relevant parts of the system, shows key changes visually, and defines checks that can verify the work independently.
Review a codebase for modules whose interfaces expose too much complexity, then compare refactoring options in a visual HTML report. Explore a selected option through questions about constraints, dependencies, module design, and testing.
Refine an existing technical design document through focused discussion. Compare design options with diagrams and code sketches, resolve one decision at a time, and update the relevant sections so the document consistently reflects agreed choices.
Design, implement, review, and test Effect v4 applications with explicit dependencies and typed errors. Covers external service connections, data decoding, resource cleanup, concurrency, logging, and tests that replace dependencies at meaningful system boundaries.
Turn existing product context into a technical design document through guided discussion. Settle system interactions first, then code structure, using diagrams and signatures to make decisions and tradeoffs clear for review.
Repair conflicting Drizzle migrations after a rebase by inspecting migration history, SQL files, and schema snapshots. The skill guides cleanup, regeneration of database change scripts, local application, and verification against the upstream branch.
Carry out a technical implementation plan in phases using a dedicated implementation agent. Review completed work, run automated checks, report manual verification steps, and coordinate approval and commits before moving to the next phase.
Revise an existing codebase research question document using user feedback or ticket comments. It preserves the document format and context references while keeping questions focused on how the current implementation works, rather than proposed changes.
Address bugs, adjustments, or follow-up features after implementation. Review the plan, code changes, and commit history to establish the current state, apply verified fixes, run tests and lint checks, and provide steps for further verification.
Design modules that hide complex behavior behind a small, clear interface. Use shared terms and practical checks to review module responsibilities, dependency handling, and where behavior can be replaced for testing.