Claude Code

Start

/planx add rate limiting to the upload endpoint

Claude researches, writes the plan, captures it, prints the id, and stops. Its turn is over — nothing is waiting on a queue, and nothing is polling.

If you were already in plan mode

The skill calls ExitPlanMode immediately with a one-line stub — not with a plan — and asks you to accept it. That is deliberate: plan mode's accept/reject gate is incompatible with a review loop, because the plan does not exist as an artifact until ExitPlanMode is accepted, and accepting it ends the planning phase. One keypress buys you one flow instead of two half-flows.

Review

In a second terminal tab:

planx <plan-id>

Press v to start a selection, extend it with the arrows, and then:

Key	What it does
f	Feedback on the selection — or edit the note under the cursor
e	Rewrite the line yourself, in place
l	Lock the selection, or lift a lock
n	A note about the whole plan
d ← →	The diff against the previous version, and the history
s	Submit everything at once
a	Approve — seals the plan
?	Every key

What your agent gets back is printed under the frame the moment you submit.

00000000000000000000

╭─ planx v0.3.0 guard-clock-a3f9 v2 ← v1 ────────────────────────────────────╮

│ │

│ ▸ ⋯ 12 unchanged lines (space to expand) │

│ 13 │

│ 14 ## Approach │

│ 15 │

│ -16 Extend the snapshot-regression guard in `poller.ts` to │

│ -17 also reject a cross-period backward jump. │

│ +16 Reject the write at the R2 path, where every snapshot │

│ +17 already passes through one function, rather than in the │

│ +18 poller that happens to have produced it. │

│ 19 │

│ -19 - Compare the incoming timestamp to the last accepted one. │

│ -20 - Reject anything more than one period behind. │

│ -21 - Count the rejection against the node that sent it. │

│ +20 - Read the period key already on the object. │

│ │

│ │

│ This version has 1 feedback. │

│ ←→ version · d hide diff · j next feedback · n note · s submit │

│ space expand · v select lines · x exit · esc back · ? help │

│ │

╰─────────────────────────────────────────────── ★ github.com/thisisnsh/planx ─╯

click to use your keyboard, or tap the keys below

Typing — enter saves, esc discards. On a phone, tap here for the keyboard.

Try it

• ·f leaves a comment on the line under the cursor
• ·s prints the one command you paste into the chat
• ·a instead of s, when there is nothing left to say

s prints one line to paste back into the Claude Code session. Claude picks the feedback up wherever it is in the loop and revises.

Nothing blocks, so nothing has to be resumed

Claude Code caps a single Bash call at 600 seconds, and you will often take longer than that to review a plan properly. planx used to work around that by blocking in slices and having Claude re-run the command — which is why you would see PLANX: no feedback yet (waited 480s) scroll past.

That is gone. Claude captures the plan, tells you to run planx, and ends its turn. You review whenever you like. The reviewer prints the command to hand back, and pasting it starts the next round with the session's context intact.

When Claude hits a lock

If Claude tries to modify a locked block, capture exits non-zero and nothing is written. The skill tells it to either fix its output — usually by using the [[planx:keep L2]] marker instead of retyping the block — or to ask:

It has to ask you in chat first — what the block says, what it wants instead, and why. Only once you agree does it run:

planx unlock <plan-id> L2 --reason "the flag adds no value here"

That grants exactly one capture and records the reason, which is what makes the decision reviewable later in planx locks.

After approval

Approving seals the plan and prints one command to paste back — no questions about agents or models. planx cannot switch a running session's model and no agent CLI lets it, so it prints the command and you run it wherever you like. See Executing.