From blueprint
Fully autonomous SDLC pipeline — zero user intervention. Opus 4.6 runs the entire workflow from plan through PR, handles review feedback loops, and stops only when the PR is ready for human merge. Use this skill whenever the user says "/flow-auto", "auto flow", "autonomous flow", "just do everything", "full auto", "hands off", "run it all", or any request to run the complete pipeline without checkpoints or user decisions. Also triggers on "no intervention", "auto pipeline", "unattended flow", "fire and forget flow", "do everything and leave me a PR", or "I'm going to sleep just build it". This is the zero-touch version of /flow — same pipeline, no pauses. IMPORTANT: never use AskUserQuestion in this skill — all decisions are made autonomously.
npx claudepluginhub skaisser/blueprint-pluginThis skill uses the workspace's default tool permissions.
Run the entire SDLC pipeline with zero user intervention. Opus 4.6 makes all decisions autonomously — planning, reviewing, executing, creating the PR, addressing review feedback, and looping until the PR is clean. Stops only when done, leaving a final recommendation comment on the PR.
Provides UI/UX resources: 50+ styles, color palettes, font pairings, guidelines, charts for web/mobile across React, Next.js, Vue, Svelte, Tailwind, React Native, Flutter. Aids planning, building, reviewing interfaces.
Fetches up-to-date documentation from Context7 for libraries and frameworks like React, Next.js, Prisma. Use for setup questions, API references, and code examples.
Analyzes competition with Porter's Five Forces, Blue Ocean Strategy, and positioning maps to identify differentiation opportunities and market positioning for startups and pitches.
Share bugs, ideas, or general feedback.
Run the entire SDLC pipeline with zero user intervention. Opus 4.6 makes all decisions autonomously — planning, reviewing, executing, creating the PR, addressing review feedback, and looping until the PR is clean. Stops only when done, leaving a final recommendation comment on the PR.
Read blueprint/.config.yml → language. If auto, detect from the user's messages. All generated content MUST be in the detected language. Skill instructions stay in English — only output changes.
/flow-auto <description>
→ plan → review → execute → check → PR → review → fix loop → DONE
Zero AskUserQuestion calls. Zero pauses. One command → PR ready for merge.
The normal /flow has 2 mandatory checkpoints where it asks the user what to do. With 1M context and Opus 4.6's reasoning, those decisions are predictable 95% of the time:
/flow-auto makes those decisions itself, saving 5-10 minutes of human wait time per feature.
/plan-approved — the coordinator never writes code. Dispatch subagents.echo "🤖 [flow-auto:N] description" — this is how the audit hook tracks progress. Skipping a step is a pipeline violation.echo "🤖 [flow-auto:1] initializing autonomous pipeline"
~/.blueprint/bin/blueprint meta 2>/dev/null
If active plan exists (blueprint meta returns plan_file):
awaiting-approval or approved → Skip to Step 4 (execute)in-progress → Skip to Step 4 (resume from last [ ])completed → Skip to Step 6 (PR)If no active plan: Continue to Step 2.
Parse $ARGUMENTS for:
#42) → store for PR body--from <stage> → jump to that stageecho "🤖 [flow-auto:2] creating plan"
${CLAUDE_PLUGIN_ROOT}/skills/plan/references/plan-template.md (plugin install) or ~/.claude/skills/plan/references/plan-template.md (traditional install) for the plan formatmcp__sequential-thinking__sequentialthinking to analyze the task:
BRANCH="feat/$(echo "$DESCRIPTION" | tr ' ' '-' | tr '[:upper:]' '[:lower:]' | head -c 50)"
git checkout -b "$BRANCH"
blueprint/live/NNNN-feat-description.md using the template format
${CLAUDE_SESSION_ID} in YAML session: and Work Sessions block (see plan-template.md)git add blueprint/ && git commit -m "📋 plan: create NNNN-description"
Autonomous decision: Always proceed to Step 3. No pause needed.
echo "🤖 [flow-auto:3] reviewing plan"
${CLAUDE_PLUGIN_ROOT}/skills/plan-review/references/team-execution.md (plugin install) or ~/.claude/skills/plan-review/references/team-execution.md (traditional install) for execution strategymcp__sequential-thinking__sequentialthinking to validate:
[H]/[S]/[O] complexity## Execution Strategy section to planApproved, set progress countersgit add blueprint/ && git commit -m "📋 plan: review NNNN-description"
Autonomous decision: Check context usage.
echo "🤖 [flow-auto:4] executing plan"
Read the full plan file. Identify completed/pending phases.
Read references/team-execution.md for delegation strategy
Update status to In Progress
Commit baseline:
git add blueprint/ && git commit -m "📋 plan: start execution NNNN"
Execute rounds following the Execution Strategy:
/ship to commit their codeOn worker failures: Apply Immediate Dispatch Rule — categorize in ONE pass, dispatch N fix agents in parallel. Max 2 fix rounds per phase before moving on and noting the issue.
6b. Post-phase data validation — After any phase that imports, seeds, or creates data, run a validation check:
# Verify record counts match plan expectations using the project's test command or REPL
git add blueprint/ && git commit -m "✨ feat: complete NNNN-description"
Autonomous decision: Always proceed to Step 5. No pause.
echo "🤖 [flow-auto:5] auditing implementation, quality sweep, and verifying tests"
~/.blueprint/bin/blueprint context --diffs to get all changes[x]/[ ] marks are accurateBefore any external review, the coordinator reviews its own diff to catch issues proactively — this is what makes the PR merge-ready on first attempt:
git diff $(git merge-base HEAD "${BASE_BRANCH:-main}") HEADThis sweep catches 80%+ of what an external reviewer would flag, eliminating most review loop iterations.
Run ALL test files created or modified during execution as a single batch to catch cross-phase regressions:
# Collect all test files touched by this branch
TEST_FILES=$(git diff --name-only "$(git merge-base HEAD "${BASE_BRANCH:-main}")" HEAD | grep -iE '(Test|test|spec)\.' | tr '\n' ' ')
if [ -n "$TEST_FILES" ]; then
# Run using the project's test command
$TEST_FILES
fi
If tests fail: Dispatch fix agents targeting the failures. Re-run. Max 2 fix rounds. If tests still fail after 2 rounds: Dispatch one final comprehensive fix agent with ALL failure output and full file context. Re-run tests (round 3 — hard ceiling). If tests still fail after 3 rounds: Mark specific failures in the plan as blockers. The PR will be created but marked BLOCKED in the final report. If all tests pass: The PR is certified merge-ready. This is the target outcome.
MERGE_READY flag based on:
git add blueprint/ && git commit -m "🧹 chore: plan check NNNN"
Autonomous decision: Proceed to Step 6 only after Green Gate + Quality Sweep complete. If MERGE_READY is false, the PR will be created but explicitly marked as BLOCKED — this is a last resort, not the normal path. The pipeline targets MERGE_READY = true before PR creation.
echo "🤖 [flow-auto:6] creating pull request"
STAGING_BRANCH=$(grep 'staging_branch:' blueprint/.config.yml | awk '{print $2}')
STAGING_BRANCH=${STAGING_BRANCH:-staging}
git rev-parse --verify "$STAGING_BRANCH" 2>/dev/null && echo "$STAGING_BRANCH" || echo "main"
git push -u origin "$BRANCH"
~/.blueprint/bin/blueprint contextgh pr create:
When the PR is created to the staging branch, execute the full merge chain automatically:
# Step 1: Merge feat → staging
PR_NUM=$(gh pr view --json number -q '.number')
gh pr merge "$PR_NUM" --merge -m "🔀 merge: $BRANCH into $STAGING_BRANCH"
# Step 2: Create staging → main PR
git checkout "$STAGING_BRANCH" && git pull origin "$STAGING_BRANCH"
MAIN_PR_URL=$(gh pr create --base main --head "$STAGING_BRANCH" \
--title "🔀 merge: $STAGING_BRANCH into main" \
--body "Auto-merge from flow-auto pipeline. Source branch: $BRANCH")
# Step 3: Merge staging → main
MAIN_PR_NUM=$(gh pr view --json number -q '.number')
gh pr merge "$MAIN_PR_NUM" --merge -m "🔀 merge: $STAGING_BRANCH into main"
# Step 4: Return to feature branch for review loop
git checkout "$BRANCH"
Error handling:
gh pr list --base $STAGING_BRANCH --head $BRANCH and merge itAfter the merge chain completes successfully, the pipeline must clean up plan and backlog state. Without this, the plan stays in blueprint/live/ and the backlog item stays active — forcing the user to manually run /finish, which defeats the purpose of a zero-touch pipeline.
echo "🤖 [flow-auto:6b] running post-merge cleanup"
Mark plan as completed:
PLAN_FILE=$(ls blueprint/live/[0-9]*-*.md 2>/dev/null | head -1)
Update the plan's YAML frontmatter:
status: completedcompleted_at: DD/MM/YYYY HH:MM (current timestamp)Archive backlog item (if the plan has a backlog: field):
BACKLOG_ID=$(grep '^backlog:' "$PLAN_FILE" | awk '{print $2}' | tr -d '"')
if [ -n "$BACKLOG_ID" ] && [ "$BACKLOG_ID" != "null" ]; then
BACKLOG_FILE=$(ls blueprint/backlog/${BACKLOG_ID}-*.md 2>/dev/null | head -1)
if [ -n "$BACKLOG_FILE" ]; then
# Update status to archived in frontmatter, then move
mkdir -p blueprint/expired
git mv "$BACKLOG_FILE" "blueprint/expired/$(basename "$BACKLOG_FILE")"
fi
fi
Move plan to upstream:
PLAN_BASENAME=$(basename "$PLAN_FILE")
DONE_FILE="blueprint/upstream/${PLAN_BASENAME%.md}-complete.md"
mkdir -p blueprint/upstream
git mv "$PLAN_FILE" "$DONE_FILE"
Commit and push the cleanup:
git add blueprint/
git commit -m "🧹 chore: finish $(basename "$PLAN_FILE" .md)"
git push
Sync cleanup to main (if merge chain already landed on main, the cleanup commit needs to follow):
# If we merged to staging→main, the cleanup commit is on the feature branch.
# Push it to staging so it flows to main on next merge, or cherry-pick if already merged.
git checkout "$STAGING_BRANCH" && git pull
git cherry-pick HEAD~1 --no-edit 2>/dev/null || true # cherry-pick cleanup commit
git push origin "$STAGING_BRANCH"
git checkout "$BRANCH"
If the merge chain failed or was skipped (PR goes directly to main), still run steps 1-4 — the cleanup is valid regardless of merge target.
Autonomous decision: Always proceed to Step 7.
echo "🤖 [flow-auto:7] starting review loop"
This is the autonomous review→fix cycle. Max 3 iterations.
Do NOT rationalize skipping this step. Even for small fixes, single-file changes, or plans you're confident about — the review loop catches things self-review misses. The pre-check below is the ONLY valid reason to skip, and it must actually run (not be reasoned away).
The only two valid skip paths are:
--no-review is explicitly present in $ARGUMENTS — the user opted outIf neither condition is true, you MUST run at least 1 review cycle. "The fix is small" or "tests already pass" are NOT valid skip reasons.
# Check 1: Explicit user opt-out
if echo "$ARGUMENTS" | grep -q '\-\-no-review'; then
echo "🤖 [flow-auto:7] skipping review loop — --no-review flag set"
# Jump directly to Step 8
fi
# Check 2: GitHub Action must exist (this check MUST execute, not be skipped by reasoning)
CLAUDE_ACTION=$(gh api repos/{owner}/{repo}/actions/workflows --jq '.workflows[] | select(.name | test("claude|Claude|CLAUDE")) | .id' 2>/dev/null)
if [ -z "$CLAUDE_ACTION" ]; then
echo "🤖 [flow-auto:7] skipping review loop — no @claude GitHub Action detected"
# Jump directly to Step 8
fi
If the @claude workflow exists, proceed with at least 1 review cycle — even for trivial changes. External review catches blind spots that are invisible to the agent that wrote the code.
Trigger review:
PR_NUM=$(gh pr view --json number -q '.number')
gh pr comment "$PR_NUM" --body "@claude review this PR and check if we are able to merge. Analyze the code changes for any issues, security concerns, or improvements needed."
Wait for review (poll every 5 minutes, max 20 minutes — reviews can take 10-15 min):
# Check for new review comments — poll every 5 minutes (300s), max 4 checks
for i in $(seq 1 4); do
sleep 300
gh api repos/{owner}/{repo}/pulls/$PR_NUM/reviews --jq '.[].state' | grep -q "CHANGES_REQUESTED" && break
# Also check if bot commented (approval or info)
BOT_COMMENTS=$(gh api repos/{owner}/{repo}/issues/$PR_NUM/comments --jq '[.[] | select(.user.login == "claude[bot]")] | length')
[ "$BOT_COMMENTS" -gt 0 ] && break
echo "Waiting for review... ($i/4, next check in 5 min)"
done
If no review comments after 20 min: The @claude GitHub Action may not be set up or is slow. Skip the review loop and go to Step 8.
If review comments exist:
~/.blueprint/bin/blueprint pr-review $PR_NUMgit pushCheck if issues remain:
echo "🤖 [flow-auto:7] review loop complete after N iterations"
echo "🤖 [flow-auto:8] pipeline complete — posting final report"
Before posting the final report, trigger a context scan to update CLAUDE.md with the new project structure:
# Only if significant code was added (more than just config changes)
STAGING_BRANCH=$(grep 'staging_branch:' blueprint/.config.yml | awk '{print $2}')
STAGING_BRANCH=${STAGING_BRANCH:-staging}
FILE_COUNT=$(git diff --name-only "$(git merge-base HEAD "$STAGING_BRANCH" 2>/dev/null || echo HEAD~5)" HEAD | wc -l)
if [ "$FILE_COUNT" -gt 10 ]; then
echo "🤖 [flow-auto:8] updating project context (CLAUDE.md)"
# Dispatch a lightweight agent to run /context scan
fi
This ensures new sessions know what was built. Skip if fewer than 10 files changed (trivial changes don't need context updates).
Post a comment on the PR with the final Opus 4.6 recommendation:
gh pr comment "$PR_NUM" --body "$(cat <<'EOF'
## 🤖 Autonomous Pipeline Complete — Opus 4.6 Final Report
### Summary
- **Plan:** NNNN-description
- **Phases:** N phases, M tasks — all completed
- **Review cycles:** N iterations
- **Commits:** X commits on this branch
### What was built
- [bullet summary of each phase's deliverables]
### Test status
- [targeted test results from execution]
- ⚠️ Run full test suite before merging
### Recommendations
- [any concerns, edge cases, or things to verify]
- [if review issues remain after 3 cycles, list them here]
- [if Green Gate failed, list specific test failures as blockers]
### Merge Readiness: ✅ READY / ❌ BLOCKED
- **Green Gate:** [PASSED — all targeted tests green / FAILED — N test failures remain]
- **Review:** [clean / N issues remain after 3 cycles]
- If BLOCKED: do NOT merge until listed blockers are resolved.
- If READY: human review recommended, then merge.
---
*Generated by /flow-auto — Blueprint SDLC*
EOF
)"
Then output to the user:
🤖 Flow Auto Complete!
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
Plan: NNNN-description
PR: #NNN — <title>
URL: <pr-url>
Review cycles: N
Green Gate: ✅ PASSED / ❌ FAILED (N tests)
Status: ✅ Merge-ready / ❌ Blocked — see PR comment
Run full test suite to verify before merging.
--from <stage>: Start from specific stage (plan, review, execute, check, pr, review-loop)--no-review: Skip the review loop entirely (just create the PR and stop)--max-cycles N: Override the max review cycle count (default: 3)--batch N-M: Execute plans N through M sequentially (see /batch-flow for full batch orchestration)Use $ARGUMENTS as the task description, GitHub issue number, or flags.