Execute Approved Specs in Isolated Codex Forks

Where this fits

You have a planning task with an approved SPEC READY and a backlog of product decisions. You want implementation to happen in a disposable Codex fork without dragging planning context into code edits, and you need a receipt proving the work actually completed. This skill automates that handoff: it creates the execution task, routes decisions back to the planner, and archives the finished child.

Why agents benefit

• Creates and names a same-directory execution task so the fork works with the exact repo state the planning task already validated.
• Delegates implementation by asking the child task to run spec-executor, keeping the agent's core workflow explicit and auditable.
• Routes product decisions through Codex Task Messenger, so the fork never blocks on an ambiguous spec and the planning task stays the source of truth.
• Validates the returned receipt before archiving, giving the agent evidence that the execution task completed its contract.
• Resumes and recovers forks it launched by handling Messenger replies, resume events, and failure states without losing context.

Practical scenarios

Executing an approved spec without contaminating planning context

A planning task contains the latest SPEC READY and several open product decisions. Instead of reusing that task for implementation, the skill spins up a fresh fork, runs spec-executor, and keeps all implementation logs in the child while the planning task keeps the decisions.

Resuming a fork after a Messenger decision

The execution fork encounters a question that only the planner can answer. The skill routes it through Codex Task Messenger, waits for the reply, then resumes the same fork with the decision incorporated, so the implementation thread stays intact.

Recovering from a failed execution fork

An execution task fails halfway through. The skill recognizes the event as belonging to a fork it launched, re-evaluates the approved spec, and either relaunches the execution task or reports a clear reason why the spec needs a new SPEC READY cycle.

Add it to your agent workflow

Install the skill with:

npx skills add tt-a1i/matt-skills-with-to-goal --skill execute-spec-in-fork

Then, inside a Codex App task that contains an approved SPEC READY, simply ask:

Execute the latest approved spec in a fork.

The skill creates and names the execution task, asks it to run spec-executor, routes decisions through Codex Task Messenger, validates the returned receipt, and archives the completed child. It requires Codex App native task tools and codex-task-messenger; use the manual fork plus spec-executor route elsewhere.

Compare before adopting

• Quality signals: Check whether the skill validates receipts, handles recovery, and keeps decision routing explicit rather than just spawning a task.
• Maintenance freshness: Look at recent commits and issue responses to confirm it stays compatible with Codex App task tooling.
• Alternatives: Compare with manual fork plus spec-executor, direct execution in the planning task, or a custom orchestrator script.
• Workflow fit: Evaluate whether the planning/execution split matches how your team reviews specs and tracks implementation evidence.

Why it is worth tracking

This skill is useful the moment your agent work starts producing SPEC READY artifacts that need implementation without manual handoffs. With 137 stars and an active GitHub repository from tt-a1i, it is a concrete signal that fork-based spec execution is becoming a repeatable agent pattern rather than a one-off workflow. For a live view of quality signals and updates, see https://www.openagentskill.com/skills/tt-a1i-execute-spec-in-fork and re-evaluate whenever your planning tasks begin to accumulate approved specs waiting on execution.