开发技能

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.

中文简介正在准备中。当前显示英语简介。

• Replacing repeated review comments with a lint rule
• Adding a runtime check for a recurring mistake
• Making a necessary judgment call more visible

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.

中文简介正在准备中。当前显示英语简介。

• Deciding where input validation belongs
• Separating business logic from framework code
• Reviewing how external data becomes typed state

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.

中文简介正在准备中。当前显示英语简介。

• Reviewing TypeScript code
• Editing .ts or .tsx files
• Validating data from external sources

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.

中文简介正在准备中。当前显示英语简介。

• Reviewing comments in a code diff
• Removing comments that describe changeable code
• Finding ways to enforce a claimed constraint with tests or 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.

中文简介正在准备中。当前显示英语简介。

• Reviewing a code path with too many layers
• Simplifying wrappers with only one caller
• Reducing shared mutable state in a module

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.

中文简介正在准备中。当前显示英语简介。

• Preventing repeated agent mistakes in a codebase
• Turning past errors into enforced checks
• Reviewing repository rules and their enforcement

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.

中文简介正在准备中。当前显示英语简介。

• Investigating repeated failures at the same check
• Testing an assumption shared by earlier fixes
• Choosing the next step from failure patterns

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.

中文简介正在准备中。当前显示英语简介。

• Assessing the blast radius of a proposed code change
• Reviewing a small diff whose safety is uncertain
• Checking downstream effects beyond direct callers

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.

中文简介正在准备中。当前显示英语简介。

• Plan a phased architecture rewrite
• Migrate a system toward a target design
• Decide where temporary breakage is acceptable

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.

中文简介正在准备中。当前显示英语简介。

• Reviewing whether a feature map still matches the application
• Checking documented features through live use
• Correcting verification instructions with evidence

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.

中文简介正在准备中。当前显示英语简介。

• Simplify a codebase before adding a feature
• Remove redundant checks during a refactor
• Trim prompts or delete empty reference stubs

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.

中文简介正在准备中。当前显示英语简介。

• Replace growing conditional chains with a domain model
• Represent lifecycle states clearly
• Remove repeated data shape assumptions across files

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.

中文简介正在准备中。当前显示英语简介。

• Replacing an internal API
• Coordinating a breaking refactor
• Updating tests for a new API contract

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.

中文简介正在准备中。当前显示英语简介。

• Automate a repetitive code change
• Create a script to verify a migration
• Generate recurring files 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.

中文简介正在准备中。当前显示英语简介。

• Building a button-based bot control page
• Sending form data to a Grok Bot webhook
• Keeping a webhook key out of browser code

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.

中文简介正在准备中。当前显示英语简介。

• Comparing several designs for one task
• Exploring options before making a substantial change
• Combining the strongest parts of parallel drafts

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.

中文简介正在准备中。当前显示英语简介。

• Making a large set of similar edits
• Running a migration in checkable steps
• Stacking commits to show the reasoning

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.

中文简介正在准备中。当前显示英语简介。

• Planning module boundaries before a feature implementation
• Comparing design options for a non-trivial change
• Revisiting a sketch when implementation needs repeated workarounds

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.

中文简介正在准备中。当前显示英语简介。

• Plan a large migration with reviewable steps
• Break a multi-part change into experiments
• Create an auditable workflow for work done over time

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.

中文简介正在准备中。当前显示英语简介。

• Making a command safe to run repeatedly
• Handling a process that may stop halfway
• Reviewing cleanup of stale files or records

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.

中文简介正在准备中。当前显示英语简介。

• Checking a benchmark before reporting its speedup
• Investigating a surprising latency or throughput result
• Reviewing whether an evaluation gap holds across trials

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.

中文简介正在准备中。当前显示英语简介。

• Reducing an oversized code diff
• Reviewing whether a new abstraction is needed
• Consolidating repeated decisions into one source of truth

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.

中文简介正在准备中。当前显示英语简介。

• Adding a requirement to an existing design
• Reworking related types and documentation together
• Planning a redesign before implementing it 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.

中文简介正在准备中。当前显示英语简介。

• Distinguishing IDs or values that share the same primitive type
• Parsing JSON, configuration, or database input into typed models
• Checking that every variant is handled