Coding standards, frameworks, refactoring, and code review (18.6K skills)
Prepare a focused request for an independent code review by defining the change scope, requirements, existing behavior, evidence, and compatibility concerns. The workflow helps reviewers find concrete issues and guides follow-up, while keeping review advice separate from completion verification.
Use this advisory review when a high-risk design or fix has competing constraints, unclear ownership, growing fallbacks, or uncertain architecture direction. It identifies the essential goal, constraints, assumptions to drop, and the least complex sufficient path before planning or implementation proceeds.
Use a written plan to coordinate independent implementation tasks in one session. Delegate each task to a fresh subagent, review specification compliance and code quality in sequence, then verify and track progress before moving on.
Use this skill to shape ambiguous or complex feature and architecture decisions through focused questions and compared options. It can also pressure-test a plan or design, helping clarify scope, trade-offs, risks, and acceptance criteria before implementation planning.
Use this skill when retiring old logic, removing fallbacks, consolidating duplicate owners, or changing schema and persistence boundaries. It classifies what is being removed, favors retiring obsolete internal paths, and requires scoped confirmation for irreversible data or risky external boundaries, with checks that the new owner still works.
Use this skill to decide whether an architecture decision deserves a durable record, then create, amend, supersede, or skip an ADR. It also checks whether the project's current architecture baseline needs updating so later contributors can see both why a decision was made and what state it established.
Use this workflow to review and carry out a written implementation plan across sessions or with review checkpoints. It tracks tasks, verifies each planned step, records progress and drift, and reports completion with supporting evidence.
Use this skill to evaluate code review feedback before changing code. It helps clarify unclear requests, check suggestions against the codebase and existing behavior, explain technical concerns, and apply accepted fixes one at a time.
Use this skill to investigate bugs, failing tests, and unexpected behavior before editing code. It guides reproduction, evidence gathering, tracing to the responsible owner, and risk-matched verification so fixes address the underlying bug class rather than adding speculative patches.
Turn approved requirements for a substantial, multi-step workstream into a bounded implementation plan. Map owners and files, define compatibility and verification, break the work into executable tasks, and select an appropriate execution route before code changes begin.
Use this skill to decide whether a Git worktree is needed when another branch must stay checked out, unrelated changes block switching, or repository rules require isolation. It guides safe setup, ownership, handoff, and cleanup.
Guide Codex through coding, debugging, reviews, and other codebase work with practical reliability rules. It helps keep changes within scope, investigate root causes, choose maintainable fixes, preserve user work, and report only checks that were actually completed.
Review Greptile feedback on a pull request, merge request, or shelved changelist, then make scoped fixes and request fresh reviews within a set cycle limit. Track actionable findings and report the current score, checks, and any work left unresolved.
Capture two web pages or image files for a visual comparison. Choose a page element with a CSS selector, set a mobile, tablet, or custom viewport, and create a Markdown comparison for PRs when needed.
Run the existing `greploop` workflow with the `@greptile-apps` trigger when the usual trigger cannot handle a large pull request. This entrypoint depends on the separate `greploop` skill and adds no workflow of its own.
Use this guide to decide when repeated operational code should become a shared service, while keeping product rules in the workflow actions that own them. It provides practical design principles and a gradual migration checklist to preserve existing boundaries and behavior.
Prepare an isolated Git worktree and branch for each feature, fix, or documentation task. Check for an existing assignment and overlapping pull requests first, so edits stay scoped to the right work and do not build on another task’s changes.
Find source files that exceed a token budget, split them along conceptual boundaries, and configure a pre-commit check that prevents further growth. It helps keep files manageable for agents and explains how to audit, exclude generated code, and document the repository’s limit.
Use this skill when changing a TypeGPU/WebGPU renderer, including render passes, shaders, resources, culling, terrain, or shadows. It guides consistent ownership and bounded work, and requires GPU image evidence when validating optimizations.
Review a coding session and suggest ways to improve the agent’s working environment. It examines navigation, automated checks, coding standards, tool use, and information access, then presents improvement candidates in order of severity.
Use the local Codex CLI as an independent reviewer after substantial changes, and as an implementation delegate only when explicitly requested. The skill explains how to scope prompts, verify findings, and take responsibility for delegated work.
Review changed code for unclear names, outdated references, unnecessary complexity, and comments that do not explain why. The skill groups findings by category, cites file and line numbers, and ends with a clear verdict on whether the changes are ready.
Turn a shipped feature spec into a durable record of why it exists, the principles and invariants it must preserve, and where to find the implementation. Archive it under `specs/done/`, retain useful visual references, and remove build-plan details.
Use the harness’s goal feature to carry out a provided specification through completion. This skill follows the companion implement-spec workflow, so it is suited to handing an implementation goal to an agent and tracking the work to its finish.