> ## Documentation Index
> Fetch the complete documentation index at: https://docs.commanderplugin.com/llms.txt
> Use this file to discover all available pages before exploring further.

# Night Mode: Autonomous Overnight Builds with YOLO

> Set up Night/YOLO Mode for autonomous overnight builds: the 10-question setup flow, default Opus configuration, stop file mechanism, and best practices.

Night Mode — also called YOLO Mode — lets CC Commander run an autonomous build session while you sleep. You answer 10 setup questions before you go, and CC Commander dispatches Claude with Opus at maximum reasoning, a hard budget cap, and a self-testing loop. The goal is to wake up to shipped code.

<Warning>
  YOLO Mode uses `--dangerously-skip-permissions` to allow Claude to act without confirmation prompts. Review all commits and generated code before deploying to production. Hooks such as auto-checkpoint and careful-guard act as safety nets but will not catch every mistake.
</Warning>

## How to launch

<Tabs>
  <Tab title="Slash command">
    Inside any Claude Code session:

    ```text theme={null}
    /ccc:night
    ```
  </Tab>

  <Tab title="Main menu">
    Run `ccc` in your terminal, then select **Night Mode** (`n`) from the main menu.
  </Tab>

  <Tab title="Direct routing">
    ```text theme={null}
    /ccc night
    ```

    or

    ```text theme={null}
    /ccc yolo
    ```

    Both route directly to the Night Mode sub-menu, skipping the main menu.
  </Tab>
</Tabs>

## The 10-question setup flow

Before starting the autonomous build, CC Commander walks you through 10 questions to produce a precise specification:

1. What are we building?
2. Who is this for?
3. What does success look like?
4. What is the tech stack?
5. Are there any constraints?
6. What are the must-have features?
7. What are the nice-to-have features?
8. Is there a deadline?
9. What is the budget cap?
10. Anything else Claude should know?

Your answers become the task specification that Claude works from throughout the session.

## Default configuration

Once you confirm the setup, CC Commander shows you the full configuration before starting:

```text theme={null}
YOLO Mode — Autonomous Overnight Build

What are we building tonight?
> "Full e-commerce checkout with Stripe integration"

Configuration:
├─ Model:       Opus (max reasoning)
├─ Budget:      $10 (hard cap)
├─ Max turns:   100
├─ Self-test:   Enabled (tests after each phase)
├─ Checkpoint:  Every 10 edits
└─ Stop file:   ~/.claude/commander/yolo-stop

Ready to run for up to 8 hours unattended.

❯ Start YOLO build
  Adjust settings
  Cancel
```

| Setting    | Default                         | What it means                                                    |
| ---------- | ------------------------------- | ---------------------------------------------------------------- |
| Model      | Opus (max reasoning)            | The most capable model, tuned for complex, multi-step tasks      |
| Budget     | \$10 hard cap                   | Claude stops when the session reaches this cost                  |
| Max turns  | 100                             | Maximum back-and-forth steps in a single session                 |
| Self-test  | Enabled                         | Claude runs tests after each phase and iterates on failures      |
| Checkpoint | Every 10 edits                  | Commits are saved at regular intervals so progress is never lost |
| Stop file  | `~/.claude/commander/yolo-stop` | Create this file to halt the loop gracefully                     |

## Stopping a running build

To stop the YOLO loop before it reaches the budget cap or the max-turns limit, create the stop file:

```bash theme={null}
touch ~/.claude/commander/yolo-stop
```

CC Commander checks for this file between cycles. The build halts at the next checkpoint, preserving all work completed so far. Delete the file before starting a new YOLO run.

<Note>
  You can also switch to the Claude tab in split mode (`Ctrl+A n`) and press `Ctrl+C` for an immediate stop, but this skips the graceful checkpoint. The stop file is the safer option for overnight runs.
</Note>

## Best practices

<Steps>
  <Step title="Write a clear task description">
    The more specific your answer to "What are we building?", the better Claude can stay on track. Include the feature name, user-facing behavior, and any API or data contract constraints.
  </Step>

  <Step title="Define acceptance criteria">
    Answer the success criteria question with concrete, testable conditions — for example, "The checkout flow completes without errors and the Stripe test webhook fires." Claude uses these criteria to decide when a phase is done.
  </Step>

  <Step title="Set a realistic budget">
    The default $10 budget handles most feature-sized builds. For a full SaaS scaffold or a complex integration, consider raising it to $15–\$20 in the settings.
  </Step>

  <Step title="Review commits before deploying">
    Night Mode commits at every checkpoint. When you wake up, review the git log and diff before merging or deploying. `git log --oneline` gives a quick summary of what was built.
  </Step>
</Steps>

<Tip>
  Run `/ccc:xray` on your project before starting a Night Mode build. The health score tells you which dimensions are weakest, and you can include "improve test coverage" or "add CI pipeline" in your task description so Night Mode addresses them automatically.
</Tip>