dev-auto-first

name

dev-auto-first

description

Autonomous orchestrator of the per-block go-fast cycle. Takes over after arch-first/audit-first when "autopilot" mode is chosen. Runs every block: flow-first → library-first → plan-first → execute without manual approvals. Validates each skill's artifact against built-in rules. On blockers — escalates to a chat bot and waits for a reply. Use when: arch-first or audit-first asks "how do we work?" and the user chooses autopilot mode; "/dev-auto-first", "autopilot", "run automatically"

Dev-Auto-First Protocol

Autonomous orchestrator of the per-block cycle. Runs instead of manual approval at each step: flow-first → library-first → plan-first → execute.

Key principle: dev-auto-first does not wait for the user's "ok" — it reads the artifact itself, validates it against the rules, and on success continues the chain. On blockers — it escalates to a chat bot and waits for a reply.

How it differs from manual mode:

	Manual	dev-auto-first
flow-first waits for "ok"	User writes "go"	Skill validates artifact → auto-approve
library-first waits for "ok"	User writes "go"	Skill validates table → auto-approve
plan-first asks for mode	User picks 1/2/3	Skill answers "1 — Autopilot"
Blocker in a skill	User decides	Escalation to chat bot

Important: dev-auto-first is a SKILL, not an agent. Works in the same context, manages sub-skills via Skill() calls.

Input

Task context ({slug}, {log_dir}) plus a list of blocks with status open or pending in the tracking database.

Output

Per-block auto-approve log lines to chat, artifacts from each sub-skill (flow-first / library-first / plan-first / report / user-note), and a final summary table with block statuses + escalation counts.

Hands off to

— (terminal). Final task closure is a separate step (ship-first invoked manually or from a future auto-closer).

---

Step 0 — Check task context

Check: are {slug} and {log_dir} known in the current session?

If yes — continue to Step 0.5.

If no — list latest task folders under {tasks_root}/log/, request user selection, set {slug} and {log_dir}.

Cannot skip. Without {log_dir} sub-skill artifacts cannot be read.

---

Step 0.5 — Load the block list

sqlite3 {tasks_root}/routing.db \
  "SELECT block_num, title, status FROM task_blocks
   WHERE task_id='{slug}' AND status IN ('open','pending')
   ORDER BY sort_order;"

Save as {pending_blocks}. If empty — output "No blocks with status open/pending" and finish.

Otherwise show the run plan and start with the first block.

---

Step 1 — Per-block cycle

For each block from {pending_blocks}:

1. Skill(flow-first)     → read artifact → validate (4 rules)
2. Skill(library-first)  → read artifact → validate (6 rules)
3. Skill(plan-first)     → read artifact → validate (5 rules) → answer "1"
4. plan-first executes the block in Autopilot mode
5. Mark the block done → move to the next

Auto-approve principle

When a sub-skill outputs "waiting for ok" — do not wait for the user. Instead:

1. Find the skill's artifact in {log_dir} (latest by filename)
2. Read via Read tool
3. Run the corresponding validation rules
4. All 🛑-checks pass → immediately call the next Skill()
5. Any 🛑-violation → invoke chat-bot escalation (Step 2)

plan-first mode selection

When plan-first shows the plan table and asks about the mode — immediately answer "1" (Autopilot) without waiting for the user.

Logging

After each auto-approve output one line:

✅ auto-approve: {skill} block {N} — {X}/{total} checks passed

---

flow-first validation rules

Read {log_dir}/flow-first-{N}.*.md (latest by sort).

#	Check	Criticality
1	All 4 sections present: ## Landscape, ## Problem, ## Solution, ## Result	🛑 blocker
2	No empty table cells — only explicit "not affected" allowed	🛑 blocker
3	## Solution contains at least one specific action verb (create/add/change/delete/rework)	🛑 blocker
4	In ## Solution at least one cell ≠ "not affected"	🛑 blocker

All 4 pass → auto-approve → Skill('library-first').

---

library-first validation rules

Read {log_dir}/library-first-{N}.*.md.

#	Check	Criticality
1	All 5 columns filled: What we do / Source / What we use / LOC / Type	🛑 blocker
2	Type only from set: ui / backend / integration / infra / ai-skill / manual	🛑 blocker
3	LOC — integer or with ~ (not text)	🛑 blocker
4	Source = "From scratch ⚠️" → "What we use" contains "no ready-made"	⚠️ warning
5	## Summary section with "Total new LOC: ~N"	⚠️ warning
6	## Watchpoints and ## Out of scope sections present	⚠️ warning

All 🛑 pass → auto-approve → Skill('plan-first').

---

plan-first validation rules

Read {log_dir}/plan-first-{N}.*.md.

#	Check	Criticality
1	Plan table contains 7 to 15 rows	🛑 blocker
2	Right column "Brief summary" — specific text, not empty or "not filled"	🛑 blocker
3	## Risks block present and filled (or explicit "—")	⚠️ warning
4	## Out of scope block present and filled (or explicit "—")	⚠️ warning
5	No research steps in table ("read X", "check if", "figure out how")	⚠️ warning

All 🛑 pass → answer "1" (Autopilot) → plan-first executes.

---

Step 2 — Chat-bot escalation

Real integration via 3 endpoints on {ops_host}. The skill lives in the agent, hits the API via Bash + curl.

2.1 — Send question

SESSION_ID="${slug}-block-${N}-$(date +%s)"
curl -s -X POST "{ops_host}/api/dev-bot/ask" \
  -H "Content-Type: application/json" \
  -d "{\"text\":\"${QUESTION}\",\"session_id\":\"${SESSION_ID}\"}"

2.2 — Poll for reply

Poll every 4 seconds up to 75 iterations (5 min timeout).

2.3 — Parse intent

curl -s -X POST "{ops_host}/api/dev-bot/parse-intent" \
  -H "Content-Type: application/json" \
  -d "{\"text\":\"${IN_TEXT}\"}"
# response: {"intent":"approve|reject|skip|retry|select|other",...}

2.4 — Intent → action mapping

Parser intent	Action	What to do
approve	approve_anyway	Ignore violations → continue chain
reject	stop	Stop → output final report
skip	skip	Skip block → mark skipped → next block
retry	retry	Repeat Skill() for problematic skill
other	escalate_v2	Send clarifying question

2.5 — Fallback on no reply

If no reply within 5 min → default action = stop, log fallback note, output interrupted-status final report.

---

Step 3 — Final report

After finishing all blocks — output summary:

✅ dev-auto-first finished.
Task: {slug}

| # | Block | Status | Escalations | Commit |
|---|---|---|---|---|
| 1 | {title} | ✅ Done | 0 | {hash} |
| 2 | {title} | ⚠️ Skipped | 2 | — |

Total: executed {X} of {N} blocks. Escalations: {M}.

After the report — do not call ship-first. dev-auto-first stops here. Final task closure is a separate step.

---

Anti-patterns

❌ Waiting for user "ok" like a regular skill

flow-first wrote "waiting for ok" — dev-auto-first stopped and waits for a human.

Rule: dev-auto-first reads the artifact immediately without pausing.

❌ Skipping validation on auto-approve

dev-auto-first answered "ok" without reading the artifact — "probably fine".

Rule: every artifact goes through all validation rules. No exceptions.

❌ Calling sub-skills inline instead of via Skill()

dev-auto-first executed flow-first logic from memory instead of Skill('flow-first').

Rule: always Skill('flow-first'), Skill('library-first'), Skill('plan-first'). Never inline.

❌ Closing the task itself

dev-auto-first after the final report called ship-first itself.

Rule: dev-auto-first stops after Step 3. ship-first is a separate step.

❌ Ignoring ⚠️-warnings entirely

dev-auto-first silently continued without logging warnings.

Rule: ⚠️-warnings are logged and appear in the final report.

---

Related skills

• flow-first / library-first / plan-first — sub-skills that dev-auto-first orchestrates
• arch-first / audit-first — parent skills that invoke dev-auto-first when user selects autopilot mode
• ship-first — separate closure step, NOT called by dev-auto-first

---

Step 99 — Log invocation

sqlite3 {tasks_root}/routing.db \
  "INSERT INTO skill_invocations (task_id, block_num, skill_name, invoked_at)
   VALUES ('{slug}', NULL, 'dev-auto-first', datetime('now'))" 2>/dev/null || true