/research-implement-feature

name: research-implement-feature
description: "Build a working artifact from a plain \"implement X for me\" request: a running end-to-end spine first, then one feature per rung, with every under-determined decision written to an assumption ledger BEFORE the code that depends on it and a cross-model sweep for the ones that slipped through undeclared. Use when user says \"给我实现\", \"implement X\", \"帮我做一个能跑的\", \"先搭个原型再加功能\", \"build this feature\", \"prototype then extend\", or hands over a capability description rather than an experiment plan."
argument-hint: "[what-to-build] [— effort: lite|balanced|max|beast] [— ask: never|semantic] [— base repo: <url>]"
allowed-tools: Bash(*), Read, Write, Edit, Grep, Glob, Skill, AskUserQuestion, mcp__codex__codex, mcp__codex__codex-reply

Research Implement: Feature

Build: **$ARGUMENTS**

This skill exists for one request shape — *"just implement X for me"* — where the user has a capability in mind, not an experiment plan, and does not want to be interviewed about it first.

It resolves that request the only honest way: **stay autonomous, stop being silent.** The skill never blocks to ask permission; it *declares* every decision the request left open, in a ledger, at the moment it makes it, and then a different model family goes looking for the ones it forgot to declare.

Two invariants

1. **Declare before you act.** The instant a decision is under-determined by the request *and* changes an interface or a meaning, it gets a ledger row — *before* the code that depends on it exists. A ledger reconstructed at the end of the run is not a ledger, it is a changelog, and it systematically omits exactly the assumptions the author stopped noticing.

Under `ASK=semantic`, this invariant strengthens to **ask before you act** for the `semantic` class: the ledger row is the unit of ambiguity, so a row that would have been written silently is a question that gets asked first. 2. **Spine before features.** Rung F0 is a walking skeleton: the thinnest path from real entry point to real artifact, with stubs inside. It must run before any feature is added. Features are then added one rung at a time, each with its own acceptance check, each leaving every earlier rung green.

Scope boundary

| The ask | Route | |---|---| | "implement X" / "build me something that does X" / "prototype then extend" | **this skill** | | "find me a research direction and take it to a paper" | `/research-pipeline` | | "I have `EXPERIMENT_PLAN.md` — run the campaign, deploy to GPU" | `/experiment-bridge` | | "sweep these parameters / find the best config" | `/dse-loop` | | "launch what is already written" | `/run-experiment` | | "do these results support the claim?" | `/result-to-claim` |

Relationship to `/research-pipeline`

`/research-pipeline` answers *"what should we research?"* and decides the question for you. This skill answers *"build the thing I already decided on"* and decides **nothing** of consequence without writing it down. Different input contracts, so they are different entry points rather than a mode flag — but they compose: a pipeline run may delegate its build stage here instead of inlining implementation, and inherits the ledger as a result.

If the target decomposes into more than the rung budget below, the scope is too large for one run. Cut to the MUST rungs and record the rest under *Deferred* in the build note — do not quietly grow this skill into a system build.

Constants

• **EFFORT = `balanced`** — Work intensity per [`shared-references/effort-contract.md`](../shared-references/effort-contract.md). Override: `— effort: max`.

| | lite | balanced | max | beast | |---|---|---|---|---| | Rung budget (Phase 1) | 3 | 5 | 8 | 12 | | Fix attempts per rung (Phase 3) | 3 | 5 | 8 | 12 | | Silent-assumption sweep rounds (Phase 4) | 1 | 2 | 2 | 3 | | Reuse survey depth (Phase 0) | local grep | local + ecosystem | + reference impl | + fetch & diff reference impl |

`EFFORT` never lowers the reviewer tier — a hard invariant of the effort contract.

• **ASK = `never`** — Interaction mode: which ambiguities are put to the author

*before* they are acted on.

| `— ask:` | Asks about | Blocking? | For | |---|---|---|---| | `never` *(default)* | nothing — declare and proceed | no | unattended runs, overnight, `/loop`, a request you want executed not discussed | | `semantic` | `semantic` rows only | at batch points | you trust the small calls, you want a say in what the results will mean |

`ASK` never changes what lands in the ledger — only who decided each row. Every row records its `Source`, so the record is complete in both modes.

• **ASSURANCE** — derived from `EFFORT` per the effort contract (`lite`/`balanced` → `draft`, `max`/`beast` → `submission`). Governs whether Phase 4 blocks. Override: `— assurance: submission`.
• **BASE_REPO = false** — Repo URL to build on top of. When set, clone first and implement inside it, matching its conventions. When `false`, extend the current project or create files in it.
• **Output language** — follow [`shared-references/output-language.md`](../shared-references/output-language.md). Code, paths, config keys and ledger IDs stay English regardless.

Interaction rule (HARD CONSTRAINT)

Resolve `ASK` once from `$ARGUMENTS` before Phase 0 and hold it for the run.

`ASK=never` — non-blocking

Runs end-to-end with zero external approval: no `AskUserQuestion`, no "should I…", no "please confirm", no waiting. Framework choice, file layout, whether to overwrite, whether to install a dependency, which default to pick — all decided here, and the consequential ones logged. The author reviews the ledger and the diff *after* the run.

Autonomy is not permission to be vague. Every decision you make instead of asking that changes an interface or a meaning is a decision you owe the author a row for.

`ASK=semantic` — blocking at batch points

The run **stops and ends