Coding standards, frameworks, refactoring, and code review (16.2K skills)
Plan relational database improvements for slow queries, indexes, and large table migrations. Document locks, which can block other database operations, alongside rollback steps and verification checks, using the database engine, version, size, and observed query plans.
Clarify inconsistent project terms using repository evidence and reviewed definitions. Answer straightforward questions, organize unresolved terminology decisions by their dependencies, and prepare a shared understanding before implementation planning or handoff.
Prepare a coding brief for an external agent already chosen by the user. Build instructions around that agent’s installed skills, covering goals, constraints, tests, and reporting requirements, while distinguishing handoff preparation from actual execution.
Prepare a reviewable plan for a risky technical change before implementation. Compare alternatives using repository facts and source evidence, document tradeoffs, and define testable acceptance criteria, verification commands, and an implementation handoff after approval.
Organize unlabeled issues and pull requests using an existing label list. Sweep the backlog or target one item by number, review the proposed changes first, and apply them when ready to make work easier to browse by area.
Extract recurring lessons from skills, prompts, work logs, reviews, and failures into proposed agent rules. Identify overlaps and conflicts with existing guidance, and prepare candidates for human review before any approved implementation.
Prepare and supervise terminal commands with an explicit working directory, environment, timeout, and stopping conditions. Organize confirmation for consequential actions and summarize results from observed output, keeping execution plans separate from evidence that commands actually ran.
Review open pull requests whose latest commit has not been checked, or select one by number. Apply repository review rules, inspect surrounding code, and preview findings before optionally posting inline comments on GitHub.
Organize an accepted implementation plan into separate work units with owners, acceptance criteria, and verification commands. Coordinate parallel or ordered execution, prevent overlapping file edits, and check the integrated result before reporting completion.
Turn an agreed code restructuring into a phased plan. Map affected files and dependencies, order the changes, and define checks and rollback points for each phase, producing a reviewable plan before implementation begins.
Investigate software slowness, memory leaks, and rising costs through measurement. Identify expensive processing paths, coordinate small reversible fixes, and compare results against a baseline with an explicit limit on acceptable performance regression.
Prepare Rust changes by clarifying ownership, borrowing, error types, and public APIs. Produce an implementation plan and verification checklist, with additional checks for undefined behavior when unsafe code or foreign function interfaces are involved.
Turn accumulated code maintenance problems into a prioritized ledger. Findings cite files and lines, include severity and estimated effort, and distinguish quick wins from larger fixes. Repeat audits track resolved, new, and continuing issues against the previous ledger.
View coding activity in a board showing each work unit, execution environment, model, elapsed time, and recorded token usage. Missing information is marked unknown, helping you understand observed activity across multiple coding sessions.
Prepare a debugging plan for native program crashes and memory corruption. Organize competing explanations, identify observations that could disprove each one, and specify debugger steps for an executor to collect evidence.
Turn a public chat report into a GitHub issue package. Classify the problem, ask focused questions, check for duplicates, and confirm scope before handing one issue creation request to an authorized connector, then verify the result.
Turn a feature request or bug fix into a structured implementation plan with goals, exclusions, risks, acceptance criteria, and verification steps. Break work into checkable actions and prepare a handoff after the user accepts the plan.
Plan repairs for Git conflicts, broken commits, and branch history. Identify which changes are already shared, define recovery points before rewriting history, and specify checks for finding the commit that introduced a bug.
Organize agent sessions, MCP connection settings, and Git worktrees into a shared inventory. Compare metadata across tools, distinguish observed information from missing or stale entries, and identify configuration differences before assigning more work.
Turn an app idea into a staged delivery plan, from product decisions to implementation handoff, verification, release, and monitoring. Define acceptance conditions and track which steps are prepared, observed, blocked, or still missing.
Ask Jev to assess a failed run using its command, error excerpt, and retry history. Get a suggested next step—retry, fix dependencies, request access, or change approach—alongside the rule behind that decision.
Plan server, API, and data changes before implementation. Define who can access each operation, consistent response formats, error handling, and database migration steps, with compatibility plans for existing consumers and rollback points for storage changes.
Review pull requests, code changes, or documented claims for bugs using concrete evidence. Receive prioritized findings, a separate assessment of whether requirements are met, and clear lists of checked areas, unanswered questions, and testing gaps.
Draft commit messages and pull request descriptions using the repository’s existing conventions. Explain why the change matters and separate commands with observed execution records from planned or skipped checks, so validation claims match the available evidence.