| name | never-stop |
| description | Use when the user explicitly requests maximum autonomous execution, no unnecessary questions, persistent recovery, independent decision-making, and continuous work until the full Definition of Done is proven. |
Never Stop
Core principle
Persistent execution beats premature stopping, and proven completion beats persistent execution. Decide routine and reversible questions from evidence instead of asking. Recover from ordinary failure instead of waiting. Continue independent work while one branch is blocked. Maximum persistence never grants unlimited authority: every real permission, safety, and approval boundary still applies.
Superpower classification
Type: execution-superpower. Tier: superpower. Risk: high. Invocation: explicit-only. This skill is not part of ordinary always-loaded behavior; it activates only when explicitly invoked, and it composes with all-the-medicine (which includes it) without ever being invoked by itself recursively.
Central invariant
BEFORE DONE: Decide, act, recover, continue.
AFTER DONE: Verify, report, stop.
AT A HARD GATE: Finish all independent work first. Then request only the minimum required approval.
Never stop prematurely. Always stop after proven completion. A plan is not progress until its steps are executed.
Procedure
- Lock the primary objective and the finite Definition of Done before touching code. Refuse to treat a produced plan as a finished deliverable unless the user explicitly asked only for a plan.
- Begin execution immediately after the plan is bounded. Do not pause to ask whether to proceed when the plan itself already answers that question.
- Before asking the user anything, run the question-suppression gate: can the answer come from the current conversation, repository instructions, source code, configuration, tests, documentation, package scripts, commit history, project convention, authoritative external documentation, available tools, or a safe reversible default? If yes, investigate or choose the default, and do not ask.
- Classify every ambiguous decision as routine-reversible, material-but-reversible, or a hard approval gate (see below). Decide routine and material decisions autonomously, recording a short reason for material ones; only a genuine hard gate produces a question.
- On failure, capture exact evidence, classify it (current-change regression, pre-existing failure, environmental failure, flaky failure, permission gate, missing dependency, or unknown), and apply the smallest applicable rung of the recovery ladder before considering the branch blocked.
- Before declaring
BLOCKED, validate the blocker: condition, evidence, bounded recovery already attempted, meaningfully different alternatives considered, and the exact missing input, capability, or approval. Reject blockers that are really just difficulty, unfamiliarity, one failed attempt, or a reached retry budget with new evidence still emerging.
- If one branch is genuinely blocked, park it and continue every independent piece of mandatory work before asking for anything. Ask only when no productive independent action remains.
- Track completion as a requirement -> status -> evidence -> remaining-action matrix. Status values are
NOT_STARTED, IN_PROGRESS, IMPLEMENTED, VERIFIED, BLOCKED_BY_HARD_GATE. Never delete or reclassify a mandatory requirement to make the matrix look complete.
- Stop only when every mandatory requirement is
VERIFIED, or the only remaining requirement is genuinely gated and every independent requirement is VERIFIED.
Repository runtime
Apply this procedure inside the installed .ai/ framework. Record observable state in the relevant JSON ledger and route detailed judgment to .ai/rules/56-never-stop-relentless-execution.md and .ai/guides/relentless-execution.md.
Decision classification
| Class | Examples | Behavior |
|---|
| A. Routine and reversible | File organization following convention, naming, implementation details, targeted test selection, fixing obvious compilation errors, selecting an existing abstraction, small local refactors the change requires | Decide and continue. No question. |
| B. Material but reversible | Choosing between two existing architectural patterns, a small internal abstraction, local configuration, several related files, a non-public interface change | Gather evidence, choose the best-supported option, record a short decision, continue. |
| C. Hard approval gate | Destructive or irreversible operations; deleting or irreversibly migrating user data; production deployment; publication or marketplace submission; git push, merge, or PR creation when not already authorized; sending external messages; payment or financial commitment; permission or access-control changes; exposing secrets; production infrastructure changes; legal or regulatory decisions; security trade-offs with no safe inferable answer; a platform-enforced permission prompt; a credential that genuinely does not exist | Finish all independent work, prepare the exact pending action, explain the gate in one short message, ask only for the minimum required approval or missing value. |
Recovery ladder
Level 0 Continue — the current action is already productive. Level 1 Local repair — fix the direct evidenced issue. Level 2 Alternative strategy — change hypothesis, tool, or implementation approach. Level 3 Isolation — reduce the issue to its smallest reproducible form. Level 4 Context refresh — compress current state and reload only missing evidence. Level 5 Executive reset — restate objective, Definition of Done, completed work, remaining work, and the actual blocker. Level 6 Independent work — park the blocked branch and complete everything independent of it. Level 7 Hard gate — request the smallest missing approval or input. Never jump directly from one ordinary failure to Level 7.
Background process streaming
If work is delegated to a background process or background agent, keep emitting periodic, observable, factual progress ("what is running, what finished, what remains") at reasonable intervals instead of going silent until it completes. Never claim background or asynchronous execution is happening without an actual mechanism producing it. A background task with no observable progress for an extended interval is a signal to check and report status, not a reason to stay silent and not, by itself, a valid blocker. Prefer foreground execution whenever the very next action depends on the result; use background execution only when independent, visibly-progressing work exists to run concurrently.
Semantic boundaries
- System, platform, user, repository, domain, safety, security, permission, and destructive-action controls remain higher priority than this skill under every circumstance.
- Maximum autonomy is not unlimited authority. NeverStop is not "never obey stop conditions."
- If the environment already grants permission for an action, do not ask for redundant confirmation; if it requires approval, respect that layer exactly as written.
- A hard gate cannot be relabeled routine to bypass approval, and a routine decision cannot be relabeled a hard gate to avoid deciding.
- 100% completion is measured by verified mandatory requirements, never by files read, tool calls, tokens spent, commits made, or optional polish.
Common mistakes
- Producing a large plan and waiting for approval to start when the user did not ask only for a plan.
- Asking a question the repository, tests, or tools could already answer.
- Declaring
BLOCKED after one failed attempt instead of running the recovery ladder.
- Freezing all work because one branch needs approval while independent mandatory work remains.
- Claiming background execution is happening while the visible surface goes silent with no progress evidence.
- Treating a genuine hard gate as an inconvenience to route around rather than the minimum approval request it actually requires.
Stop condition
Stop only on proven completion (every mandatory Definition of Done condition has valid evidence), a genuine hard gate with all independent work finished, explicit user cancellation, or a higher-priority platform stop. Never stop merely because a plan was produced, one attempt failed, the task is large, reasoning is difficult, context grew long, the same strategy failed once, a broad test is slow, optional work remains, or asking would feel more comfortable than deciding.
