Workflow

Autonomous end-to-end development pipeline. Runs the full nm skill chain with minimal interruption:

brainstorm → plan → ts-api | go-api → tdd → code-review → commit

Two gates only: start (task + stack) and commit (final confirmation). Everything between is autonomous.

Recommended model: Sonnet (orchestration) / delegate heavy phases to sub-agents

Gate 1 — Task Intake (REQUIRED STOP)

Present this intake form and wait for answers before proceeding:

WORKFLOW START
──────────────
Task: [restate task in one sentence]

Clarify:
Q1. Stack?
  1. TypeScript (Node.js / Hono / Express)
  2. Go (net/http / Chi / Gin)

Q2. Scope?
  1. New feature (green field)
  2. Change existing feature
  3. Bug fix

Q3. Tests required?
  1. Yes — full TDD (red → green → refactor)
  2. Yes — write tests after implementation
  3. No tests needed

Reply with three numbers (e.g. "1 1 1") or describe changes.

Do not proceed until user replies.

Autonomous Pipeline

After Gate 1, run each phase in sequence. Do not pause between phases unless a phase signals ambiguity or failure.

Phase 1 — Brainstorm (auto-condensed)

Run brainstorm rules from /nm:brainstorm but condensed:

• State understood task + assumptions (one block)
• Identify the simplest approach
• List top 2 risks
• Do NOT ask clarifying questions — use Gate 1 answers as context
• Do NOT stop for "ready to plan?" — auto-proceed to Phase 2

Output format:

[BRAINSTORM]
Task: ...
Assumptions: ...
Simplest approach: ...
Risks: ...
→ Proceeding to plan...

Phase 2 — Plan

Run plan rules from /nm:plan:

• Build numbered steps with verify checks
• Estimate complexity
• Do NOT stop for approval — present plan and immediately continue

Output format:

[PLAN]
1. ... → verify: ...
2. ... → verify: ...
Complexity: Low | Medium | High
→ Proceeding to implementation...

Phase 3 — Implementation

Based on Gate 1 stack choice:

• TypeScript → apply /nm:ts-api patterns
• Go → apply /nm:go-api patterns

Execute plan steps one by one:

• Run verify check after each step
• If verify fails: fix before moving to next step
• Do NOT ask "continue to next step?" — auto-proceed on success

Output format per step:

[IMPL] Step N/total: ...
  ✓ verify passed

If a step fails 2 attempts: surface to user with exact error before continuing.

Phase 4 — TDD

If Gate 1 Q3 = option 1 (full TDD):

• Apply /nm:tdd Phase 1 (RED) and Phase 2 (GREEN)
• Auto-select test cases based on implemented endpoints/functions
• Run tests — show pass/fail output
• If tests RED after implementation: fix implementation, re-run
• Auto-skip refactor phase (user can run /nm:tdd separately if needed)

If Gate 1 Q3 = option 2 (tests after):

• Write tests after implementation
• Run once — show results
• Fix failures

If Gate 1 Q3 = option 3: skip Phase 4.

Output format:

[TDD] Writing tests for: ...
  ✓ N tests passing

Phase 5 — Code Review

Apply /nm:code-review rules autonomously:

• Review all files changed in this workflow
• Fix any CRITICAL or HIGH issues found
• List MEDIUM issues but do not fix (surface to user in Gate 2)
• Do NOT stop for approval — auto-fix criticals and proceed

Output format:

[REVIEW]
  ✓ Fixed: [critical/high issues]
  ⚠ Noted: [medium issues for user awareness]
→ Proceeding to commit...

Gate 2 — Commit Confirmation (REQUIRED STOP)

Present full summary and wait before committing:

WORKFLOW COMPLETE — REVIEW BEFORE COMMIT
─────────────────────────────────────────
Files changed:
  [list all modified/created files]

Test results:
  [pass count / skip info]

Issues fixed:
  [list from code review]

Issues noted (not fixed):
  [list medium issues]

Commit message:
  [proposed conventional commit message]

Proceed with commit? [y / n / edit message]

Only commit after explicit y or message edit + confirmation.

Error Escalation Rules

Always surface to user (break autonomous flow) when:

• A verify step fails twice
• Tests fail after 2 fix attempts
• Ambiguity requires a design decision (e.g., conflicting patterns found in codebase)
• File conflicts or merge issues detected
• Security concern flagged during review

Format escalation as:

[BLOCKED] Phase N — <reason>
Options:
  1. [suggested fix]
  2. [alternative]
  3. Skip this step and continue
Reply to unblock.

What NOT to do

• Do not ask questions between Gate 1 and Gate 2 unless escalation rules trigger
• Do not run git commit without Gate 2 confirmation
• Do not skip TDD if Gate 1 Q3 = option 1
• Do not fix MEDIUM code review issues autonomously (note them, don't touch)
• Do not refactor code not related to the current task