Coding standards, frameworks, refactoring, and code review (16.7K skills)
Turn repeated corrections into enforceable project rules, such as a lint check, metadata flag, runtime check, or script. When a lesson requires human judgment, make the instruction more visible and include an example of the failure it addresses.
Organize validation and error handling at system boundaries such as command inputs, configuration, networks, and external APIs. Keep internal business logic focused on typed data and pure functions, making it easier to test without framework wiring.
Apply consistent TypeScript practices when reading or editing .ts and .tsx files. Model valid states with precise types, validate external data at boundaries, handle every variant, and prefer real tests and structured diagnostics where practical.
Use this skill to review comments in specified files or a code diff. It delegates a fresh review, evaluates findings, fixes accepted issues, and proposes ways to encode claimed constraints in types, runtime checks, tests, or CI lint.
Use this skill to make hard-to-trace code easier to understand. It examines indirection and hidden mutable state, then suggests collapsing unnecessary wrappers and narrowing state scope so readers can find where values come from and what can change them.
Use this skill to address mistakes agents repeatedly make in a repository. It groups recurring errors and guides fixes through architecture, types, lint checks, and tests, with evidence that each check catches a real past mistake; documentation is reserved for judgment calls.
Use this skill when multiple fixes based on the same assumption fail the same check. It guides the agent to write down and test that assumption, then use the evidence to decide whether to investigate another cause or address the root cause.
Assess what a code change could break beyond the visible diff. Trace less obvious effects, identify the key assumption that makes the change safe, and test that assumption by running real code before presenting risks and cleared concerns.
Guide planned rewrites and migrations toward a defined target architecture. Set explicit phase boundaries, allow scoped and reversible breakage where planned, and verify the result at each boundary and when the work is complete.
Audit a project’s verification skill by checking each feature against source code and exercising it in a live session. The result is an honest feature map and, when proven corrections are needed, one focused pull request.
Sequence additions, refactors, and rewrites by simplifying the existing system first. Remove dead code, redundant checks, and empty stubs, then build on the smaller base while avoiding speculative safeguards and prompt clutter.
Shape code around the real concepts and rules of a domain. Use state machines, typed models, registries, reducers, or other fitting structures to reduce scattered branches, repeated assumptions, and invalid states while avoiding abstractions that add needless indirection.
Use this principle when replacing an internal API and coordinating changes across its callers. It recommends moving callers to the new contract and removing the old API in the same change, with tests focused on the new behavior rather than refactoring details.
For nontrivial edits, migrations, analyses, or checks, build a small repeatable tool such as a script, codemod, or generator. The tool becomes a reviewable artifact others can rerun to verify the work consistently.
Build a local page with buttons or a dashboard that sends JSON to a webhook and wakes a Grok Bot. Keep the sender key on the server, request it through a secret prompt, and expose the page to Tailscale peers when needed.
Generate several parallel candidates for the same task, compare them against concrete criteria, and choose a base to improve with selected strengths from the other candidates. The skill then verifies the synthesized result and records how it was assembled.
Break migrations, broad edits, and other multi-step work into small changes, checking each one before moving on. Arrange commits and pull requests so reviewers can follow the evidence and verify how the work progresses.
Use this skill to shape non-trivial code before implementation. It grounds the design in the surrounding system, compares structurally distinct options, and creates a type and module sketch that guides coding. If implementation repeatedly conflicts with the sketch, it revisits the architecture.
Designs a reviewable workflow for complex work that does not fit an existing playbook, such as a large migration or multi-part change. It breaks work into testable steps, scales checks to risk, and records decisions so a reviewer can understand the result later.
Design commands and processing steps that can safely run again after retries or crashes. The skill guides agents to compare current state with the goal, apply only needed changes, and make leftover files or records recognizable as stale.
Use this skill to check whether a measured speedup, regression, throughput, latency, or evaluation result reflects the work you intended to measure. Identify the limiting resource, rule out other explanations with evidence, and keep run counts and variation with the result.
Use this skill during refactoring or diff review to favor deletion and the smallest change that solves the problem. It encourages one source of truth for repeated decisions and helps avoid unnecessary abstractions, layers, and boilerplate.
Integrate a new requirement by reconsidering the existing design as if the requirement had been there from the start. The skill guides updates across affected types, documentation, examples, and rationale, delivered incrementally.
Use this skill when designing types or reviewing function signatures in statically typed code. It helps distinguish values that share a primitive representation, parse untrusted input at system boundaries, handle every variant, and derive types from the schema that defines the data.