Skip to content

opsmill/infrahub / .agents/skills/speckit-opsmill-auto

speckit-opsmill-auto

Verified

Run the full speckit workflow end-to-end — specify, plan, critique, tasks, implement, review — making all decisions autonomously. Stops before extract; run that manually.

FileKindSize
SKILL.mdskill md6.1 KB
---
name: speckit-opsmill-auto
description: Run the full speckit workflow end-to-end — specify, plan, critique, tasks, implement, review — making all decisions autonomously. Stops before extract; run that manually.
compatibility: Requires spec-kit project structure with .specify/ directory
metadata:
  author: opsmill
  source: opsmill:commands/auto.md
---

## User Input

```text
$ARGUMENTS
```

You **MUST** consider the user input before proceeding (if not empty).

## Outline

You are running the **full speckit pipeline** end-to-end. The user's input (above) is the feature description that will seed the specification phase.

This skill is a thin orchestrator over two sibling skills:

- `speckit-opsmill-prep` — Specify → Plan → Critique → Tasks (+ spec/ask alignment check)
- `speckit-opsmill-implement` — Implement → Review → Final report

Run them back-to-back, making all decisions autonomously. Do not stop to ask the user for input between phases — if a sub-phase requires choices (clarification questions in specify, research decisions in plan, drift remediation in alignment), use your best judgment and proceed. The user expects a hands-off, one-shot execution. Extraction (`speckit-opsmill-extract`) is **not** run by this command — the user invokes it manually after reviewing the implementation report.

> Each phase below is executed by invoking the named skill (e.g. via the agent's Skill tool). Skills are agent-agnostic, so this workflow runs identically across any harness that supports skill discovery — not only those exposing speckit slash commands.

### Phase A — Preparation (delegated to `speckit-opsmill-prep`)

Invoke the `speckit-opsmill-prep` skill with the user's feature description (`$ARGUMENTS`) verbatim.

- This covers Specify → Plan → Critique → Tasks **and** the trailing spec/ask alignment check.
- The sub-skill commits its own artifacts after each phase via `speckit-checkpoint-commit`.
- If the alignment check inside prep loops (re-running plan/critique/tasks to fix spec drift), let it run to completion. Do not interfere.

**Read prep's status line.** `speckit-opsmill-prep` ends its output with a literal final line:

`STATUS: <READY|BLOCKED> | SPEC_DIR: <absolute spec-dir path> | CRITIQUE: <extension|fallback|none|n/a> | REASON: <...>`

Parse that line — do **not** infer success from the prose summary:

- Take **`SPEC_DIR`** from this line as the spec directory to pass to Phase B. This is the deterministic hand-off; do not scrape the path out of free text.
- If **`STATUS: BLOCKED`** (e.g., alignment never converged within its retry budget, or a phase could not complete), surface the reason to the user and **stop**. Do **not** proceed to implementation on a misaligned or incomplete spec.
- Take **`CRITIQUE`** as the critique coverage of the run. Anything other than `extension` or `n/a` means the critique extension was unavailable and prep either ran a reduced fallback critique or none at all. `n/a` is not a coverage claim — it means prep aborted before Phase 3 ever resolved a provider, so read it together with `STATUS`. This does **not** block Phase B — carry it into the final summary.
- Only proceed to Phase B when `STATUS: READY`.

### Phase B — Implementation tail (delegated to `speckit-opsmill-implement`)

Invoke the `speckit-opsmill-implement` skill with the `SPEC_DIR` path from Phase A as its argument. Because you pass an explicit spec-dir path, the sub-skill runs in **autonomous-parent** mode: its Phase 0 stop-conditions abort with a `STATUS: BLOCKED` line instead of pausing for a user.

- This covers Phase 0 (Preflight) → Phase 5 (Implement loop in clean-context subagents) → Phase 6 (Review) → Phase 7 (Final report).
- The sub-skill writes `<spec-dir>/opsmill-implement-report.md` and commits it.

**Read implement's status line.** `speckit-opsmill-implement` ends its output with a literal final line:

`STATUS: <DONE|INCOMPLETE|BLOCKED> | SPEC_DIR: <...> | REVIEW: <plugin|command|fallback|none|n/a> | REASON: <...>`

- `STATUS: BLOCKED` — a Phase 0 stop-condition aborted before any implementation (no report written). Surface the reason in the final summary; do not retry from this orchestrator.
- `STATUS: INCOMPLETE` — blocked tasks, missing local-pass evidence, or `REVIEW: none`; capture that for the final summary. The user decides whether to re-run.
- `STATUS: DONE` — all chunks completed with evidence.
- Take **`REVIEW`** as the review coverage of the run. A missing reviewer does not stop the implement phase: `REVIEW: plugin` and `REVIEW: command` are full reviews, `REVIEW: fallback` means the sub-skill ran a reduced built-in review, `REVIEW: none` means no review happened at all and forces `STATUS: INCOMPLETE`. `REVIEW: n/a` is not a coverage claim either — it means implement aborted before Phase 0 resolved a provider, and it pairs with `STATUS: BLOCKED`. Never treat a completed implement phase as a reviewed change set without checking this field.

In every case, do **not** retry from this orchestrator.

## Completion

After both phases are complete, provide a brief summary:

- Feature name and spec directory
- Whether the alignment check inside auto-prep required retries (and how many)
- Number of tasks completed (from the auto-implement report)
- Any review findings that were fixed inline vs. deferred
- **Coverage of the quality gates (REQUIRED).** State the `CRITIQUE` value from Phase A and the `REVIEW` value from Phase B explicitly. If `CRITIQUE` is not `extension`, or `REVIEW` is not `plugin` or `command`, lead the summary with it, name what is missing, and give the install command (`specify extension add critique` / `/plugin install pr-review-toolkit@claude-plugins-official`). An autonomous run that quietly skipped a quality gate is the one outcome the user must never have to discover by opening a report file
- Any notable decisions you or the sub-skills made autonomously

Do **not** open a PR, push, run extraction, or start a new feature. The user takes it from there — extraction (`/speckit.opsmill.extract`) is intentionally left as a manual follow-up so the user can review the implementation report first.
planning-and-task-breakdownaddyosmani/agent-skillsBreaks work into ordered tasks. Use when you have a spec or clear requirements and need to break work into implementable tasks. Use when a task feels too large to start, when you need to estimate scope, or when parallel work is possible.Stars: 119kUpdated Claude CodeCodexVerifiedInstall
screenpipethedotmack/claude-memSearch screen and audio history recorded by Screenpipe and optionally save selected context into claude-mem. Use when the user asks to recall desktop activity, a meeting, or something seen in another app through Screenpipe.Stars: 118kUpdated Claude CodeCodexVerifiedInstall
contact-widgetnexu-io/open-designSelf-contained floating chat widget with welcome screen, social links, meeting button, and message input. Single HTML file, zero dependencies.Stars: 108kUpdated Claude CodeCodexVerifiedInstall
meeting-notesnexu-io/open-designMeeting notes page — title bar with attendees, agenda checklist, decisions block, action items table with owners + dates, and a "next meeting" footer. Use when the brief mentions "meeting notes", "minutes", "1:1 notes", "all-hands recap", or "会议纪要".Stars: 108kUpdated Claude CodeCodexVerifiedInstall