Skip to content

zeikar/hyperclaude / skills/hyper-auto

hyper-auto

Unverified

Use when plan-harden → implement-harden should chain in one gesture — hyper-plan-loop produces a clean plan, then hyper-implement-loop executes and hardens it. Also when the user invokes /hyperclaude:hyper-auto. For manual control between phases use /hyperclaude:hyper-plan-loop, inspect the plan, then /hyperclaude:hyper-implement-loop.

hyper-auto — chain hyper-plan-loop into hyper-implement-loop

Single-gesture pipeline: hyper-plan-loop converges → hyper-implement-loop runs on the produced plan. Stops cleanly at any terminal state in between. No cron, no merge, no push, no autonomous follow-up rounds — just the two loops, chained.

When to use

  • User has a task description and wants the full plan-harden → implement-harden chain in one go.

When to skip

  • A plan already exists → use /hyperclaude:hyper-implement-loop directly.
  • User wants to inspect / hand-edit the plan before implementing → use /hyperclaude:hyper-plan-loop, then decide.

Procedure

Step 1 — Run hyper-plan-loop

Invoke /hyperclaude:hyper-plan-loop <task> with the user's task description verbatim, minus any seat override. Let it run to terminal state.

Each inner loop seats its own reviewer per ${CLAUDE_PLUGIN_ROOT}/references/reviewer-seat.md; a "review with Claude" / "use Codex" given to hyper-auto decides both loops' seats.

Step 2 — Branch on plan-loop's terminal state

  • Clean exit (no blocking findings — plan-loop converged) → capture the plan path from the loop's report, proceed to Step 3.
  • Cap reached (plan-loop's "revise loop" report — blocking findings still open after the seat's review budget) → STOP. Surface plan-loop's terminal report verbatim. Do NOT proceed.
  • Any other terminal failure (bridge failure, planner-write/format failure, reply-contract failure, unparseable review, etc.) → STOP, surface the underlying report verbatim.

Implementing on a plan with unresolved blocking findings wastes the implement-loop budget on a known-broken input — this is the safety boundary.

Step 3 — Run hyper-implement-loop

Invoke /hyperclaude:hyper-implement-loop <plan-path-from-Step-1> with the canonical plan path captured from plan-loop's report. Let it run to terminal state.

Step 4 — Auto-recap, then compose the report

On a clean composed exit (guard below), FIRST run the terminal recap, THEN emit the composed report so the report can quote the actual written recap path. On any non-clean terminal the recap is skipped entirely.

Clean-exit guard. Auto-recap fires ONLY when ALL of these hold:

  • plan-loop exited clean (Step 2's clean-exit branch — not cap/failure), AND
  • implement-loop reached its Step 7 review-convergence report (not a Step 6 cap/failure STOP), AND
  • that Step 7's fix(review): convergence commit reported SUCCESS (commit SHA + clean tree) OR SKIP (nothing staged, clean tree).

Non-clean terminals NEVER auto-run recap, and NEVER relay the implement-loop's standalone recap-recommendation bullet:

  • (a) plan-loop cap/failure STOPs at Step 2 — no implement phase ran, no recap.
  • (b) implement-loop cap/failure Step 6 STOP surfaces the loop's own Step 6 report (which carries no Step-7 recap bullet) — no recap.
  • (c) a Step 7 whose fix(review): convergence commit FAILED (dirty tree / not-ready-to-push) surfaces the loop's Step 7 report with the recap-recommendation bullet STILL suppressed; hyper-auto REPLACES it with an explicit auto-recap skipped — convergence commit failed, tree not clean; run /hyperclaude:hyper-recap <plan-path> manually after resolving line — never the standalone recommendation.

Terminal recap (clean exit only). Invoke /hyperclaude:hyper-recap <canonical-plan-path> with the SAME plan path captured in Step 2 and passed to Step 3 (the active .hyperclaude/plans/<basename> path). hyper-implement archived that path to plans/done/ on completion, and hyper-recap's path branch relocates the now-missing active path to its done/ sibling — binding the recap to THIS exact cycle. Claude-only: no Codex, no agent dispatch, live context. NEVER invoke it no-arg (no-arg picks newest-by-mtime and can target the wrong cycle). This runs before the composed report.

Composed report. Relay both phases' final-report terminal facts so the user can audit the full chain. Do not paraphrase or invent fields — but apply TWO composed-flow exceptions:

  1. Suppress hyper-plan-loop's "Next step: /hyperclaude:hyper-implement " recommendation. That line fires on a clean plan-loop exit; under hyper-auto, Step 3 has already executed the implement phase, so relaying it verbatim would tell the user to re-implement an already-implemented plan. Drop that bullet from the relayed plan-loop report.
  2. Suppress the implement-loop's /hyperclaude:hyper-recap recommendation bullet. Under hyper-auto the recap is auto-run here (the terminal action above), so the report surfaces the ACTUAL recap path instead of a recommendation (mirrors the plan-loop Next-step suppression).

Plan-loop bullets to relay (Step 8 of hyper-plan-loop, minus the suppressed Next-step):

  • The plan path.
  • Slug-source (research-reused vs freshly-derived).
  • The Reviewer seat: line and review iterations consumed.
  • The final review verdict.
  • Residual non-blocking findings (informational, never gating).
  • Claude seat: the dropped findings (a dropped Blocker leads the composed report) and the not-resumable note.

Implement-loop bullets to relay (Step 7 of hyper-implement-loop, verbatim):

  • All reviewArtifacts[] paths.
  • The Reviewer seat: line and review iterations consumed.
  • The final review verdict.
  • Residual non-blocking findings, with the /simplify recommendation when the implement-loop made one.
  • Claude seat: the dropped findings (a dropped Blocker leads the composed report) and the not-resumable note.
  • Any resume-failed / fallback rounds noted.
  • Branch / working-tree state + the implement-loop's own Next-step (this is the actionable user guidance for the composed flow's exit).

This "ALWAYS" scopes to the two Step-7-reaching exits only — Step 2 and Step 6 STOPs never reach the composed report; they surface the underlying loop report verbatim (Step 2, guard case (b)) and carry no recap-outcome line. For those two exits, the composed report ALWAYS ends with a hyper-auto recap-outcome line — never claiming an unwritten path:

  • Clean exit → consume hyper-recap's terminal outcome: the exact written recap path on success, or its reported failure reason and NO path on any non-success terminal.
  • Step-7 failed-convergence exit → the auto-recap skipped (<reason>) line from guard case (c).

Anti-patterns

  • Proceeding to implement-loop when plan-loop hit cap-reached ("revise loop" report). The plan still has unresolved blocking findings — the implement-loop is not the place to compensate.
  • Calling this skill when a plan already exists. Use hyper-implement-loop directly; running plan-loop on a plan-shaped task description duplicates work.
  • Hiding the intermediate plan-loop failure under a generic "auto failed" message — always surface the underlying terminal state so the user can diagnose.
  • Modifying the plan between Step 1 and Step 3. The implement-loop receives the canonical plan-loop output as-is; out-of-band edits break the audit trail.
  • Auto-running the terminal recap on any non-clean composed exit; relaying the implement-loop's standalone recap-recommendation bullet on a failed-convergence exit instead of the auto-recap skipped (<reason>) line; or invoking hyper-recap no-arg instead of with the captured canonical plan path.
slack-gif-creatoranthropics/skillsKnowledge and utilities for creating animated GIFs optimized for Slack. Provides constraints, validation tools, and animation concepts. Use when users request animated GIFs for Slack like "make me a GIF of X doing Y for Slack."Stars: 196kUpdated Claude CodeCodexVerifiedInstall
ponytailDietrichGebert/ponytailLazy senior dev mode for any coding task: the smallest change that fully solves it, and a reply a busy human understands in one read.Stars: 193kUpdated Claude CodeCodexVerifiedInstall
ponytail-debtDietrichGebert/ponytailHarvest every shortcut: comment into one debt ledger, so deferrals get tracked instead of forgotten. One-shot report.Stars: 193kUpdated Claude CodeCodexVerifiedInstall
ponytail-debtDietrichGebert/ponytailList every `shortcut:` comment (and older `ponytail:` ones) as a debt ledger. One-shot report, changes nothing. Use for "ponytail debt", "what did ponytail defer", "list the shortcuts", /ponytail-debt.Stars: 193kUpdated Claude CodeCodexVerifiedInstall