q is context-dependent. If no run is flying it is an exact alias of p and starts the autopilot. If a run is already flying it means land cleanly: finish the work in flight, ship it (commit, push, merge, deploy), QA the live result, then stop. It is the graceful way to wind a run down, where stop halts at the current leg.

The four keys: `p`, `q`, `d`, `O`

Q: How do you control an AI coding agent without writing prompts?

With a single keystroke. TaskPeace's autopilot prompt defines four keys: p runs the agent until you stop it, q lands a run cleanly, d does exactly one verified step, and O walks you through only the items that genuinely need a human. The agent decides what to work on from your ranked queue, so the only thing you choose is how long it should run.

Q: What is the difference between p and d?

They run the identical engine and differ only in duration. d does exactly one leg — one highest-leverage action, verified, then it stops and names the next candidate so you can chain. p loops that same leg until you type stop, pause or halt. Use d when you are watching and want to redirect between steps; use p when you are walking away.

Q: What will the agent never do on its own?

Two things always stop for you: spending real money, and publishing publicly under your identity. Beneath those sits a safety floor — it never types your passwords, MFA codes or CAPTCHAs, never makes the final create-click on a new account, and never force-pushes to a shared branch or permanently deletes. A blocked step becomes an item in your queue and the run keeps going.

Q: What happens when the queue is empty?

An empty board is not a stop condition for p. The agent runs a gap sweep — it looks for a live bug, an unshipped asset, or the biggest gap against your goal — creates that task and works it. Only stop, pause or halt ends a run, so an unattended session does not sit idle.

Q: Can I point a key at one project or one specialist?

Yes. Any trailing text scopes the key, so p ship checkout runs the loop on that scope and d fix nav does one step on it. A digit or a pilot name selects a specialist instead: p2 or p bounty runs the autopilot as that pilot with its own lane and guardrails, and d2 does one leg as that pilot.

One keystroke is the whole interface. p runs your agent until you stop it. q lands it cleanly. d does exactly one verified step. O hands you only the things that genuinely need a human. You stop writing prompts.

The short answer: the agent already knows what to work on — it reads your ranked queue. The only thing left for you to decide is how long it should run. That is one letter, and it is the entire interface.

Open the board — free →

The whole key set

Key	What it does
p	The autopilot. Starts the loop if none is running, continues it if one is. Works your queue top to bottom until you stop it — and never dead-ends.
q	Alias of `p` when nothing is running. Land when something is — finish the work in flight, ship it, QA the live result, then stop.
d	One leg, then stop. The single highest-leverage action, verified, with the next candidate named so you can chain.
O	Operator walkthrough. Only the items that genuinely need you, one at a time, with exact steps.
stop	Halt at the current leg. `pause` and `halt` do the same.

Aliases: d also answers to Next and DTBNS. A key fires only when it is essentially the whole message — “add a p flag” is a task, not a keystroke.

Why four keys instead of one?

Because duration is the one decision an agent must never guess.

Everything else it can work out from evidence: which task ranks highest, which approach to take, whether the change actually worked. But how long you want it running is a fact about you — whether you are sitting there ready to redirect, or closing the laptop.

Guessing that is expensive in both directions. Guess "keep going" and you get an unsupervised overnight run you never authorised. Guess "stop" and the machine parks itself after one step when you wanted the whole backlog cleared. So the agent doesn't guess: it reads your intent off the key you pressed. d means I'm watching. p means I'm leaving.

What actually happens on one leg

Every key runs the same engine. Only the throttle changes — d is exactly one iteration of what p loops:

Select. Pull the highest-value task from your ranked queue, weighted by revenue, retention and reach — and skip anything another session already holds.
Execute. Do the work. Reversible actions run without asking; the gates below never do.
Verify, in the same turn. Fingerprint the live page, check the build is green, read the metric back. "It looks right locally" is not proof when the live surface is what matters.
Complete with proof. The task closes carrying the evidence, not a checkmark.
Report one line — what shipped, and how it was verified.
Name the next candidate with a rough estimate, so you can chain with d or hand the rest to p.

That last step is why a run reads as a chain of results instead of a wall of narration.

What the agent will never do on its own

Two hard gates, always. Spending real money, and publishing publicly under your identity. Beneath them sits a floor: it never types your passwords, MFA codes or CAPTCHAs, never makes the final create-click on a new account, and never force-pushes to a shared branch or permanently deletes.

A gated step does not stall the run. It becomes an item in your queue with the exact steps written out, and the agent flies past it to the next-best work. Later you press O and clear those items one at a time — that is the whole point of the fourth key.

Does it stop when the queue is empty?

No — an empty board is not a stop condition for p. The agent runs a gap sweep: a live bug, an asset that was built but never shipped, the biggest gap against your goal. It creates that task and works it. Only two things end a run: you typing stop, pause or halt — or a genuine sweep across every axis turning up nothing worth doing, which it reports honestly rather than pretending.

The same applies to trouble. A rate limit becomes a degrade — cheaper model, keep going — rather than a halt. A machine that stops banks nothing.

Scoping and specialists

Any trailing text scopes the key:

p ship checkout      # run the loop, but on that scope
d fix nav            # one step, on that scope
O billing            # walk me through only billing's blocked items

A digit or a pilot name picks a specialist instead — each with its own lane, guardrails and cost tier:

p2                   # run the autopilot as pilot 2
p bounty             # ...or by name
d bounty checkout    # one leg, as that pilot, on that scope

Try it in two lines

Connect your agent to the queue:

curl -fsSL https://taskpeace.com/install.sh | bash

Paste the autopilot prompt once. After that, press p.

The prompt is public and readable — every key, every gate, nothing hidden: taskpeace.com/autopilot-prompt.txt

Frequently asked questions

How do you control an AI coding agent without writing prompts?

With a single keystroke. The agent decides what to work on by reading your ranked queue, so the only thing left for you to choose is how long it runs — and that is one letter.

What is the difference between `p` and `d`?

They run the identical engine and differ only in duration. d does one verified leg and stops. p loops that same leg until you stop it. Watching? d. Leaving? p.

What does `q` do?

It depends on whether something is running. Nothing flying: q is an exact alias of p. A run in flight: it lands — finish the work, ship it, QA the live result, stop. It is the graceful wind-down, where stop halts at the current leg.

Why keep `q` if it is just an alias?

Muscle memory and scripts. q was the original key and plenty of automation still sends it. Keeping it costs one line and breaks nothing.

What will the agent never do on its own?

Spend real money, or publish publicly as you. It also never handles your credentials, MFA codes or CAPTCHAs, never makes the final create-click on a new account, and never force-pushes or permanently deletes.

What happens when the queue is empty?

It runs a gap sweep, creates the biggest missing piece of work, and does it. An empty board never ends a run.

Can I point a key at one project or one specialist?

Yes — trailing text scopes it (p ship checkout), and a digit or pilot name selects a specialist (p2, p bounty).

Put your backlog on autopilot — free → How to run Claude Code autonomously →

The four keys: p, q, d, O