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

inline-execution

Use when a written implementation plan is to be executed by the current agent itself rather than by subagents: the user chose the cheaper mode, the harness cannot dispatch subagents, or the plan is short and fully specified.

NoobyGains · 已有静态检查记录

安装与使用

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

npx skills add NoobyGains/godmode --skill inline-execution

技能说明


name: inline-execution description: "Use when a written implementation plan is to be executed by the current agent itself rather than by subagents: the user chose the cheaper mode, the harness cannot dispatch subagents, or the plan is short and fully specified."

Inline Execution

Execute the plan yourself, task by task, in this context. There is no implementer or reviewer per task; there is one fresh review of the whole branch at the end. This is the cheapest execution mode: one context plus one reviewer.

Core principle: the plan already did the thinking, so execute it exactly, prove every step with a test you watched fail and pass, and leave a ledger that survives your own forgetting. Inline mode gives up a fresh context and a second pair of eyes per task. It buys them back by other means: the brief is the spec, the ledger is the memory, test-first is the per-task gate, and the final reviewer is the second pair of eyes.

The Prime Directive

NO TASK IS DONE WITHOUT A TEST RUN YOU READ AND A LEDGER LINE THAT RECORDS IT

No exceptions. No workarounds. No shortcuts.

When to Use

Required:

  • A plan from godmode:task-planning exists and the user chose inline execution.
  • Or the harness has no way to dispatch subagents. Never pretend to dispatch one; run the plan here.
  • Or the plan is short and fully specified (it contains the code to write), so execution is transcription plus testing.

Skip:

  • The user wants a review gate on every task: use godmode:delegated-execution.
  • The plan is long enough that its last tasks would run on a heavily compacted context: prefer godmode:delegated-execution. Inline still works over a long plan because the ledger makes it recoverable, but the last tasks get the least of you.
  • Several independent problems with no shared plan: use godmode:parallel-execution.

Cost note for the user. A fully specified plan runs well on a mid-tier session model. The one seat that earns the top tier is the final review, which this skill dispatches separately (see godmode:model-routing). Say so when the user picks this mode.

Operating Rules

Run continuously. Do not stop between tasks to ask "should I continue?". The user chose this mode to spend less, not to answer prompts.

Optional checkpoints. If the user asked for them ("check in every 3 tasks"), stop after every N completed tasks with a five-line status: tasks done, rulings made, deferred minors, next task, anything that needs their eyes. Record Checkpoint: after Task <N> in the ledger. Without that request, there are no checkpoints.

Rulings, not stalls. Conflicts, ambiguities and plan defects are yours to decide. The spec is the binding authority, the plan is its argument. Record each decision as Ruling: <what> / <why> / <cost if wrong> and continue. Deviating from the plan without a ledgered ruling is a decision made in secret.

Four things stop you: an irreversible or destructive action; a security-sensitive action; an outward side effect norms say you ask about first (merge, push to a shared branch, publish); a plan so broken that every path forward is a guess.

Keep your context lean. Every tool output stays resident and is re-read on every later turn. Redirect long test output to a file in the plan workspace and read its tail. Read one brief, never the whole plan again.

The Protocol

  1. Isolate. Invoke godmode:workspace-isolation. Never implement on the trunk branch without the user's explicit consent.

  2. Open the plan workspace and ledger. Same directory and format as godmode:delegated-execution: .godmode/runs/<plan-slug>/progress.md, with the commands and line formats in that skill's references/ledger-and-workspace.md. Write Mode: inline on the second line. If a ledger for this plan exists, resume at the first task without a complete line; tasks marked complete are never redone, because their commits exist even when your memory of them does not.

  3. Read the plan once, and the spec it names. Note the global constraints. Create one task-tracker item per plan task.

  4. Load godmode:test-first now, before Task 1. It governs every step below; a plan whose steps already say "write the failing test" does not exempt you from it.

  5. Pre-flight scan. For every task that consumes what an earlier task produces, write one ledger row: the two tasks, what is produced against what is consumed, what you found. If no tasks share anything, write Pre-flight: no shared interfaces. Rule on every conflict before Task 1.

  6. Run the task loop below for each task in order.

  7. Final review (section below), then finish: report rulings and deferred minors, then invoke godmode:merge-protocol.

The Task Loop

a. Take the task. Record BASE with git rev-parse HEAD. Extract the task's brief to task-<N>-brief.md and read it, even for a task you remember from setup: memory is a summary, the brief has the exact values. Mark the tracker item in progress.

b. Work the steps in order. The plan's steps are already in red-green order. Write the test, run it, and watch it fail for the reason the plan expects. A test that passes before the implementation exists is a finding about the test. Every step that runs a command has an expected result; compare the real output against it. Three outcomes:

  • Matches: next step.
  • The code is wrong: invoke godmode:fault-diagnosis. Find the cause; never patch the symptom so the output matches.
  • The plan is wrong (a step contradicts the spec, an interface from an earlier task does not match, a command that cannot work): rule on the smallest change that satisfies the spec, ledger it as Task <N>: Ruling: ..., and continue. Later tasks read the ruling from the ledger.

c. Commit as the plan's commit steps say. Several commits per task are fine; the review range is cut from BASE, never HEAD~1.

d. Completion contract. All of these are true, with

阅读完整来源 ↗