跳至正文
OpenAgentSkill
浏览已开放 · 目录记录日期 2026-11-21 · 自动更新和账户服务暂时关闭。
开发与测试

implement

Use this skill when writing code, building features, fixing bugs, refactoring, or performing multi-step implementation work. Activates on mentions of implement, build this, code this, start coding, fix this bug, refactor, make changes, develop this feature, coding task, write the code, or start building.

hyperb1iss · 已有静态检查记录

安装与使用

运行命令前先阅读来源与依赖说明。复制命令不会自动安装或执行。

npx skills add hyperb1iss/hyperskills --skill implement

技能说明


name: implement description: Use this skill when writing code, building features, fixing bugs, refactoring, or performing multi-step implementation work. Activates on mentions of implement, build this, code this, start coding, fix this bug, refactor, make changes, develop this feature, coding task, write the code, or start building.

Implementation

Deliver the requested behavior with evidence from the code path and the place where its output is consumed. Choose the smallest useful feedback loop for the change; increase verification when uncertainty, integration, or consequences increase.

The user's instructions take precedence over this skill's guidelines. Carry existing authorization forward and finish the work within scope. Resolve routine reversible choices with stated assumptions when useful. Ask only when missing information materially changes the result or an applicable boundary requires it; a skill workflow does not itself create a new approval gate.

Orient to the Change

Inspect repository status before edits and read existing diffs on touched files. Treat the checkout as shared space. Preserve work you did not create and respect claimed ownership.

Trace the behavior through its actual callers and consumers. Locate the nearest relevant pattern, tests, and real gate commands. Search by syntax when the question concerns code structure; use text search for names and prose. Read enough to understand the change, without a minimum file-read count or a broad context dump.

Recall non-obvious prior decisions through the configured memory workflow. Recheck volatile API, dependency, and deployment claims against current primary evidence or the installed version. Load specialized tool guidance when the task needs it, rather than guessing unfamiliar flags.

Distinguish diagnosis from implementation. "Why does this happen?" calls for a confirmed cause first. Once fixing is authorized, define a check that can distinguish the broken and intended behaviors.

Select a Verifiable Slice

SituationNext move
Clear, low-impact editMake the edit and use the relevant structural or behavioral check
Bug with an observable failureReproduce it, isolate the cause, then verify the correction
New behavior across boundariesImplement a representative end-to-end slice with its tests
Shared interface or schema changeTrace consumers and compatibility before changing the contract
Large uncertain changeUse plan for dependencies and acceptance criteria
Independent work with a useful integration pathUse authorized delegation and explicit ownership

Keep implementation and its verification together. Do not defer all tests until the feature is complete when an earlier test can guide the design. Equally, do not create tests for a reversible text edit merely to satisfy ceremony.

Break work at coherent behavior or contract boundaries. File count and number of edits are not useful universal cadence rules. Run the cheapest check that can expose the next likely failure before building more work on a potentially false premise.

Keep the Design Accountable

Follow local patterns unless a concrete problem justifies departing from them. Explain the reason, not a generic preference for a different style.

PressureDecision
New modes or configuration appearTie each to a requested behavior or demonstrated variation
The same decision repeats across callersGive that decision one appropriate owner
A wrapper only forwards callsInspect whether it enforces an API, policy, or test boundary before removing it
A cast conceals incompatible dataFix or validate the contract at its actual boundary
A fallback hides an errorPreserve the failure cause and handle the intended recovery explicitly
Compatibility code growsCheck shipped consumers and rollout requirements before keeping or deleting it
Complexity keeps increasingRe-examine ownership and data flow before adding another special case

An abstraction can be valuable before a second caller when it enforces a real boundary. A shorter implementation can be worse when it obscures error behavior or compatibility. Judge the concepts and contracts, not line count alone.

Keep edits within the requested scope. Remove imports, stale labels, and dead branches your own change creates. Route unrelated findings to the project's sidequest or issue workflow when required; do not absorb them silently into the implementation.

When a scale problem appears, identify the contended resource. Fix isolation, indexing, batching, ownership, or capacity at the cause. A temporary concurrency reduction may help a controlled diagnosis or an authorized incident mitigation; it must not quietly become the permanent solution.

Verify the Claim You Intend to Make

Choose checks from the actual repository and affected behavior:

CheckWhat it can establishCommon limit
Type/static analysisSelected type and structural p
阅读完整来源 ↗