Autonomy layerv0.1.1

autonomous-pipeline

Runs the complete engineering lifecycle once, behind one plan approval, with durable phase gates and a verified findings register.

WORKFLOW / 05/autonomous-pipeline <feature request to take from idea to shipped> (or 'resume' to continue a run)
  1. 01

    Capture the request, phase selection, branch, budget, mode, and checkpoint.

  2. 02

    Define and plan, then pause for the single plan approval.

  3. 03

    Run build, simplify, test, review, performance, ship preparation, learn, and map once.

  4. 04

    Carry blocked phase evidence forward without fabricating a green handoff.

  5. 05

    Verify the open register and return next-move choices instead of auto-recursing.

operating envelope

Use it deliberately.

The shortest useful definition of where this skill helps—and where it should stay out of the way.

Use when

  • A substantial request should move from idea through ship preparation in one autonomous run.
  • The user wants one plan approval rather than manually invoking every phase.
  • A long multi-phase run needs exact resume and honest downstream accounting.

Do not use when

  • Only one phase or a quick edit is needed.
  • The user has not explicitly requested a broad autonomous run.
  • You intend to recursively fix the pipeline’s own final findings without a new user decision.

output contract

What must be true when it stops.

Produces

  • Per-phase gate and specialist-routing register
  • Integrated validation result and ship-preparation artifacts
  • Verified open-findings register with user-owned next moves
  • .ulpi/runs/<id>.json pipeline checkpoint and status command

Guarantees

  • Plan approval is the only blanket approval; surprises and irreversibles still stop.
  • The lifecycle makes one forward pass and never recursively fixes itself.
  • Every phase gate records met, blocked, or skipped.
  • A blocked phase cannot be represented as done to keep downstream work moving.
  • Pipeline- and phase-level budgets bound the whole run.
  • A durable checkpoint resumes at the exact unfinished phase and unit.

Honest failure states

  • blocked — a phase missed its gate and remains resumable
  • skipped — the configured run intentionally omitted a phase
  • needs_attention — findings or irreversible work require the user
  • budget_exhausted — the whole-run ceiling fired before completion

enforcement

Know which claims are executable.

Scripts are linked when this skill owns deterministic machinery. The remaining rules are explicit operating contracts and must not be marketed as hooks.

install and invoke

One skill, three honest surfaces.

skills.sh

Available

Universal skill installation, including Claude Code and Codex.

npx skills add https://github.com/ulpi-io/skills-autonomous-engineering --skill autonomous-pipeline

Claude Code plugin

Available

Install the full plugin, then invoke /autonomous-pipeline or let routing select it from context.

Claude installation →

Codex plugin

Work in progress

A work in progress on the codex-native-plugin branch — build it, start a new session, then invoke $autonomous-engineering:autonomous-pipeline.

Codex installation →

run the whole lifecycle

One invocation. One plan approval. One bounded pass.

CClaude Code
/autonomous-pipeline "<feature>"

Run after installing the marketplace plugin. The plan is the one broad approval; surprises still stop.

XCodex plugin
$autonomous-engineering:autonomous-pipeline "<feature>"

Work in progress on the codex-native-plugin branch: build it from source, start a new session, then run. Missing capability and verification failures stay explicit.