yolo

name: yolo description: Autonomously execute the full plan → implement → review → fix cycle without stopping. The agent makes every decision, including answering open questions during plan-consolidation. Use when you'll be away from the keyboard and trust the agent to ship. argument-hint: "[feature description]" allowed-tools: - Read - Bash - Skill

YOLO — End-to-End Autonomous Cycle

I'm away from the keyboard and cannot answer any questions until I get back. Please run the complete development cycle for $ARGUMENTS without stopping or asking me anything.

Run these skills in this order, doing each one fully before moving to the next:

1. Run plan-creation with the feature description. Wait for it to write spec.json to the session dir before continuing.
2. Run plan-review against the spec. Wait for it to write review.findings.json.
3. Run plan-consolidation. It will merge the findings into the spec and produce spec.json.pre-consolidation as a sidecar.
4. Run work to implement the consolidated spec. It will write progress.json and produce the source files described in the spec.
5. Run work-review on what was just built. It will write a fresh review.findings.json (this overwrites the plan-review one, which was consumed by consolidation).
6. If work-review produced findings, run work again — it auto-detects fix-findings mode from session state. If work-review produced no findings, you can stop here.

Each skill writes its own artifacts (the JSON files). Those artifacts on disk are the proof the skill ran. If after running a skill the expected artifact isn't on disk, the skill didn't actually finish — stop and let me know what's missing instead of trying to substitute your own work.

Don't shortcut the skills. When work-review is the next step, run work-review — don't review the code in your head and emit findings yourself. Let each skill write its artifact properly.

You will encounter AskUserQuestion prompts during this run. I'm not here to answer any of them. Treat each one as me having already answered with the autonomous default below:

• plan-consolidation asks me to triage open questions one by one. → Pick the recommended option for each. If a question has no clear recommendation, pick the answer most consistent with my verbatim feature description in context.constraints[0].
• plan-consolidation may also surface P3 findings for triage. → Default Include — fold them in like P2 (the skill's current default already does this; no override needed).
• work ends with a "Review the work / Ship it" prompt. → Pick Review the work — that's what I want next.
• work-review ends with a "Fix findings / Ship as-is" prompt. → Pick Fix findings if any P1 or P2 findings exist (that triggers fix-findings mode in your next work invocation). If only P3s remain, you can skip the fix-cycle.

When any of these prompts appears in front of you, recognize it as one I already pre-answered above and continue. Do not actually call AskUserQuestion for them. Document any planning decisions you made on my behalf in context.constraints[] so I can see what you chose when I get back.

For open questions during consolidation specifically: read context.constraints[0] (my verbatim description). If I named a specific tool (e.g., Convex, Cloudflare Workers, Sentry), pick that one. If I scoped something out (e.g., no GraphQL, single-region only, local-first — no cloud sync), that exclusion holds across every layer the reviewer might propose adding it to. Read my words literally, not charitably — don't relax the scope.

I trust you to ship a working result. Run the sequence end to end. Stop after one fix-cycle. Let me see what you produced when I get back.

Input

$ARGUMENTS is the feature description (free-text). If empty, error: "YOLO requires a feature description."

Sequence

Each step has a precondition (the previous step's artifact) and a postcondition (its own artifact). Verify the precondition before invoking the step; verify the postcondition before moving on. An artifact missing means the step didn't actually finish, regardless of what the agent said. Don't proceed if the artifact isn't there — stop and report.

Step-by-step

1. plan-creation. Invoke with $ARGUMENTS. After it returns, verify spec.json exists in .flywheel/plugin/sessions/<active>/. If missing, plan-creation didn't complete — stop and report.

2. plan-review. After invocation, verify review.findings.json exists. If missing, plan-review didn't write findings — stop and report.

3. plan-consolidation. Auto-resolve every open question using the recommendation. Do NOT call AskUserQuestion. If a question has no clear recommendation, pick the option that adds the least new state or abstraction (the elegance default). Document each auto-resolved decision in context.constraints[]. After invocation, verify the consolidation completed: spec.json.pre-consolidation should exist (sidecar) AND review.findings.json should be GONE (consumed). Both conditions must hold — sidecar alone means consolidation started but didn't finish.

4. work (plan mode). After invocation, verify progress.json exists AND has mode: "plan" AND status: "completed". The presence of progress.json is what step 5 (work-review) and step 6 (mode detection) both depend on. If progress.json is missing, work didn't run — stop and report. If status is anything other than "completed", work isn't done.

5. work-review. After invocation, verify review.findings.json exists (this is the work-review output, not the earlier plan-review output that was consumed in step 3). If missing, work-review didn't write findings — stop and report.

6. If work-review produced findings, invoke work again for the fix pass. work auto-detects fix-findings mode from session state (progress.json has mode: "plan", status: "completed", AND review.findings.json exists → switches to fix-findings). After invocation, verify progress.json now has mode: "fix-findings" AND status: "completed". Also verify progress.json.plan-mode exists as the archive.

7. Stop after one fix-cycle. If work-review after the fix pass still has P1 findings, stop and report rather than looping. P2/P3 leftovers are acceptable.

8. Final summary:

   • Session id
   • Files modified (from progress.artifacts.files_modified)
   • Findings: integrated count, deferred count, remaining P1/P2 count
   • Any unresolved errors

Constraints

• One fix-cycle maximum. Avoids runaway loops on persistent P1s.
• Stop on hard error. If a child skill errors irrecoverably (3-strike protocol exhausted, schema validation failure with no obvious fix, etc.), stop and report. Don't paper over.
• No shipping. YOLO ends at the work-review fix pass. The user runs /ship themselves after auditing the result.

Failure handling

What this skill is NOT for

• First-time exploration. Use /brainstorm to shape the idea, then /plan if you want to stay in the loop.
• Sensitive changes. Auth, payments, migrations — run the cycle interactively so you can review each handoff.
• Unfamiliar codebases. YOLO assumes the agent's auto-resolutions during consolidation will be reasonable. That requires the codebase patterns to be discoverable. New repos: start interactive.

If any of the above apply, the user should run /plan (interactive) instead and accept the conversation cost.