autonomous-engineering

Implement a whole DAG plan autonomously — one approved pass, one clean rollback point per task, never building on a broken base. It requires an approved plan (specced upstream) and a clean git baseline, takes a SINGLE human approval of the plan, then walks the DAG layer by layer: for each task it implements on an isolated worktree branch test-first (RED → GREEN), integrates the slice onto the working branch, reviews the integrated change, runs a bounded fix loop until the task passes, and commits it individually — so any point is a clean rollback. It follows the dependency graph strictly (a task builds only once its deps integrate), checkpoints every task so it resumes exactly where it stopped, and STOPS-and-asks on unfixable failures, ambiguity, or irreversible steps rather than pushing through. This is the BUILD phase. Composes fan-out-work (per layer), converge-loop (per-task fix), adversarial-verify (per-task review), checkpoint-resume, and budget-guard.

Turn a spec into a self-reviewed DAG of atomic build tasks: each task gets acceptance criteria, a disjoint write scope (≤3 files), and a slice-scoped validate; dependencies are wired and layered topologically so nothing builds on a missing base. Adversarial critics then attack the graph (cycles, phantom paths, coverage vs spec, task independence) until it is clean. Writes .ulpi/plans/<name>.json. Use when a spec needs an implementable, ordered breakdown before building.

Turn a raw feature request into a grounded, TESTABLE spec — autonomously. It recons the real repo and domain to ground every claim, drafts a spec (objectives, user-visible behavior, acceptance criteria, explicit non-goals, constraints, interfaces, risks), then runs a completeness-critic loop that adversarially hunts for gaps, ambiguity, and untestable criteria and fixes them until the spec is stable. Every acceptance criterion it emits is measurable (you could write a test for it); every requirement is grounded in the repo or flagged as an assumption — no invented requirements, no phantom paths. It writes `.ulpi/spec/<name>.md` and is the DEFINE phase that feeds auto-plan. Composes fan-out-work (recon), adversarial-verify (the critic), converge-loop (until-stable), and checkpoint-resume.

Run the whole engineering lifecycle end-to-end from one request — spec → plan → build → simplify → test → review → performance → ship — as a single autonomous pass with ONE human approval (the plan) and hard-gated escalation for anything irreversible. It chains the auto-* phase skills, carries a durable pipeline checkpoint so a stop/crash resumes at the exact phase and task it left off, watches the signal between phases (a phase that misses its gate is recorded blocked and surfaces in the register — fail closed, no false-green downstream), and returns a verified findings register at the end. Autonomous: it AUTO-FIXES the confirmed findings in a bounded converge-loop (never asking permission to fix), returning only the residual it can't converge within budget or a fix needing an irreversible/ambiguous decision. This is the top-level "maximise autonomous agents" entry point. Composes every auto-* phase plus checkpoint-resume, budget-guard, watch-and-act, and adversarial-verify.

Make long autonomous work durable and resumable: a live .ulpi/runs/<id>.json status file (per-unit + per-phase state, atomic locked writes via the bundled scripts/checkpoint.mjs CLI) that a resume reads to SKIP everything already done — session-independent. Status writes are non-fatal observability. Use for any multi-unit run worth resuming after a stop or crash.

Review a change across every dimension at once, then keep only the findings that survive an adversarial check — autonomously. It fans out independent reviewers over the diff (correctness, security, performance, maintainability/readability, test adequacy, API/contract & compatibility), dedups their findings, and puts each through a majority-refute verification so false positives never reach you or drive a fix. Survivors come back severity-labeled and actionable (file:line, why, suggested fix), and — if you ask — a bounded fix loop resolves the confirmed blockers. It fails closed: a dimension that didn't actually run is reported as a gap, never as "clean". This is the REVIEW phase. Composes fan-out-work (dimensions), adversarial-verify (confirm findings), converge-loop (optional fix), and checkpoint-resume.

Cover a large work-list in parallel without losing correctness or honesty — scout the items inline, then run each through its stages concurrently (map, optionally reduce) via the Workflow tool, with concurrency caps, per-item isolation where items mutate files, and an explicit account of anything dropped. Use when the task is "do the same thing to N independent things" — audit every module, migrate every call site, write tests for every gap, review every changed file — and N is big enough that serial is wasteful. It keeps the coordinator in control of the decision to continue while the per-item work runs in agents; it never silently truncates (a top-N/sampling cap is logged), and it aggregates results faithfully (a failed item becomes a reported null, not a hidden success). Composes with converge-loop (per-item loops) and adversarial-verify (gate each item's result).

Take verified work to shippable — autonomously, with fail-closed gates and a human sign-off on anything irreversible. It runs the pre-launch gate (final validate green, review clean, security/observability/ rollback checks), and a gate that DIDN'T actually run is treated as a blocker, never as clean. Then it prepares the release: atomic commits, a changelog/release notes grounded in the actual changes, version bump, docs for user-visible/API changes — and opens the PR (or stages the rollout: feature flag + rollback path + monitoring). The deploy itself is gated on explicit human approval. It fails closed and never fabricates a green gate to ship. This is the SHIP phase. Composes adversarial-verify (confirm the "ready" claim), checkpoint-resume, and budget-guard.

Stand up a recurring scheduled agent for standing work (triage, monitoring, audits, digests): a self-contained IDEMPOTENT brief (each run wakes memory-less and must dedup prior work), a cadence matched to how often work actually arrives, a per-run BOUND, escalation rules, and a teardown condition. For durable unattended work that runs while you're offline, use claude.ai Routines (the /schedule skill / RemoteTrigger); an in-session CronCreate is the lighter, session-scoped alternative. Use for scheduled repeat work — not one-off waits (watch-and-act).

Wait on an EXTERNAL signal the harness can't notify you about — CI, a deploy, a queue, an endpoint — polling on a cache-aware cadence (≤270s active, ≥1200s idle, never ~300s), bounded by a deadline, acting on the transition. Prefers a NATIVE wait/monitor capability when present; when polling must cross a turn it persists a durable, atomic, resumable watch state (`scripts/watch-state.mjs`) so the ORIGINAL bound survives a fresh process and a missing wake capability degrades to a resumable PENDING report instead of blocking. Never polls harness-tracked background work (that re-invokes you automatically). Use to bridge a run to something happening elsewhere.

Close every autonomous run with a learning pass so the machine never repeats a mistake it already paid for: harvest the run's STRUCTURED artifacts (checkpoint register, blocked-task reasons, guard blocks, fix-loop counts, degradations), verify each candidate lesson adversarially, dedupe against what is already known, then WRITE each learning to the Claude Code memory that LOADS AUTOMATICALLY next session — a convention or plan-shape rule into CLAUDE.md, an area-specific lesson into a path-scoped .claude/rules file, an environment quirk into auto memory. Machine defects are surfaced to the user, never self-patched. Because those are native context files Claude Code already loads, the next run picks the lessons up with no extra step. Use as the closing phase of every run, or standalone.

Generate and refresh the project's CONTEXT ARCHITECTURE — a disclosure-tiered map so the agent starts every session knowing the repo without paying for what it doesn't need. Platform-aware by explicit contract (claude|codex|dual): for Claude a lean root CLAUDE.md (loads always), path-scoped .claude/rules/*.md (load only when touching matching files), nested CLAUDE.md throughout the tree (loaded on demand — zero cost until then); for Codex the root + nested AGENTS.md tree instead — never inventing a memory location the platform lacks, never touching private agent memory. Deep references are LINKED, never imported. Every claim is VERIFIED against the real repo before it ships (commands actually run; paths actually exist) — the map cannot lie. Use to initialize project context, refresh it after meaningful changes, or as the pipeline's final phase so the map reflects what just shipped.

Raise test health to a green, MEANINGFUL suite: find untested behaviors, write real tests, loop-until-green — with every added test MUTATION-CHECKED (break the code, the test must fail; tautologies rejected). Fails closed: never games the suite green (a skill-scoped hook mechanically blocks .skip/.only/suppressions in test files). Checkpointed and resumable. Use after a build, on a risky module, for a bug repro, or to de-flake (auto-test flaky).

Make code measurably faster without breaking it: metric + reproducible baseline FIRST, profile to the real hotspots, then per hotspot apply a change and re-benchmark — kept ONLY if the win is real beyond variance AND correctness holds; otherwise reverted. Stops at the target or diminishing returns. Never accepts an unmeasured "should be faster".

Reduce a change's complexity WITHOUT changing behavior, provably: find duplication/dead code/over-abstraction in the diff, apply the smallest clarifying edit, then prove behavior preserved (tests green + adversarial semantic check) or REVERT — looping until dry. Respects Chesterton's Fence: never removes code whose purpose isn't established. Use when code works but reads worse than it should.

Prove a claim before acting on it: spawn N independent skeptics prompted to REFUTE it (optionally through distinct lenses — correctness, reproduction, security, regression, measurement) and keep it only if a majority fails. Fails closed on ties. Use to gate findings before fixing, fixes before committing, and any "clean/safe" verdict before trusting it.

Run a bounded, self-correcting loop that drives code toward a target state and STOPS honestly — until-green (validate → diagnose → minimal fix → re-run) or until-dry (find → act → re-find until N dry rounds). Every loop declares a termination set (done-condition, max iterations, budget, no-progress stop) and compiles onto native /goal + /loop. Use for any "repeat until a measurable condition holds" work instead of hand-rolling a keep-going loop.

The discipline that keeps an autonomous run from becoming a runaway: before any unattended loop or workflow, declare the five stop conditions — done-condition, hard cap, token/time budget, no-progress rule, escalation triggers — then hold the run to them and stop the instant one fires. Fails closed: a capped run reports an honest partial, never fabricated success. Load at the start of ANY unattended run.