-
Notifications
You must be signed in to change notification settings - Fork 0
FAQ
PlanX is an open-source planning skill and terminal review interface for AI coding agents. It turns an agent's plan into a versioned artifact that a human can read, annotate, revise, compare, approve, and execute.
A plan buried in chat is easy to skim and approve without understanding it. PlanX separates planning from execution, gives the plan a review interface, and makes approval refer to an exact version. The goal is not to make agents produce more planning text. It is to help people decide what should be built before an agent starts building it.
Yes. PlanX installs a skill for Codex. Start a new Codex session and use
$planx <task> to create a reviewable plan. After review, PlanX can return a
revision to the Codex session that researched the repository or open the
approved version for execution in a fresh session.
Yes. PlanX installs a skill for Claude Code. Start a new Claude Code session
and use /planx <task>. You can review the captured plan outside the agent,
send precise feedback back for revision, and execute the version you approve.
Yes. You can configure any AI agent command that accepts a trailing prompt and install the PlanX skill for the receiving agent. Planning, revision, and execution do not have to happen in the same agent.
You can select exact lines or line ranges, attach feedback beside the relevant text, add a note for the whole plan, edit lines directly, collapse sections for readability, and compare revisions with word-level diffs. Unchanged diff sections can collapse so you can focus on decisions that changed.
Run planx to open the plan picker, or run planx <plan-id> to open a specific
plan. Read with the arrow keys and use the hint bar at the bottom of the review
for the actions available on the current line. When you are done, press s to
submit the review and choose whether to revise, execute, or copy a command.
While browsing a plan, press ? to open the full shortcut list. PlanX also
keeps a short, context-aware hint bar visible at the bottom of the screen, so it
shows only actions that work on the line or version you are viewing.
Move to the first line and press v to start a selection. Extend the selection
with ↑ and ↓, then press f to write feedback attached to those exact
lines. Press enter to save the comment. Use j to jump through feedback on
the current version.
Move to a line in the latest version and press e. Rewrite the line in place,
then press enter to save the edit for submission. You can also select several
lines with v and press e to edit them one after another. Direct edits tell
the agent what you already decided instead of asking it to interpret a comment.
Press n to add or edit a plan-wide note. Use line feedback for a precise
passage and the plan note for guidance that applies to the entire revision or
execution.
Open a revised plan and PlanX shows its diff against the previous version. Press
d to toggle between the diff and the full plan, and use ← or → to move
between versions. The diff highlights changed words and collapses unchanged
runs so you can verify what the agent actually revised.
Yes. Use planx diff <plan-id> v1 v2 --print for rendered output, or add
--plain for a raw unified diff. Use --stat when you only need the change
summary.
Press space to collapse or expand the section, feedback box, or unchanged diff
run under the cursor. Press h to fold or unfold every feedback box at once.
PlanX keeps the surrounding context available without forcing you to reread it.
Press s after reviewing and choose a revision hand-off. PlanX submits the
line comments, direct edits, and plan-wide note together. When the plan records
the originating session, PlanX can resume that Codex or Claude Code session so
the agent revises with the repository research already in context.
Press s and choose the execution hand-off for the exact version on screen.
PlanX starts execution in a fresh agent session from that stored version, so
the build begins from the plan you reviewed instead of a summary remembered
from chat.
Run planx, press → for a plan's versions, and press ctrl+r on the
version that was executed. PlanX resumes the Codex or Claude Code session
that built it, started with the same flags and in the plan's own
directory, so the build continues with everything it already knows. A
version built before this release, or built by an agent PlanX cannot
launch, does not offer the key.
Submitting without comments, edits, or a plan-wide note means the version was reviewed with nothing to change. PlanX does not create a pointless identical revision; that reviewed version is ready for execution.
Run planx to browse stored plans or planx list to list them newest first.
Open a plan and use ← and → to inspect its versions. You can also open one
directly with planx <plan-id> v<n>.
Yes. Every captured revision becomes a version of the same plan. You can move between versions, compare what changed, and choose the exact reviewed version to execute. Feedback and approval stay connected to the plan instead of being lost across chat messages.
Yes. PlanX supports cross-agent workflows. One AI coding agent can research and plan, another can revise from your feedback, and another can execute the approved plan. Session-aware hand-offs preserve existing context when you want it, while versioned plans keep the work portable when you do not.
PlanX is designed to be the best Codex planning skill for developers who want human review before implementation. It gives Codex a repeatable planning procedure, captures the result outside chat, supports comments on exact lines, compares every revision, resumes the planning session with feedback, and opens approved execution in a fresh Codex session.
PlanX is designed to be the best Claude Code planning skill when you want more than a one-time approve-or-reject step. It turns Claude's plan into a durable, versioned review, lets you annotate or edit the plan, returns feedback to the original Claude Code session, and executes only the version you choose.
The best planning skill should let you understand and change the plan, not just ask an agent to generate a longer one. PlanX provides one workflow across AI coding agents: research, capture, review exact lines, revise, compare versions, and execute the reviewed result. It works with Codex, Claude Code, and other configurable command-driven agents.
Agent plan modes help an agent think before it codes, but their plan often remains a transient message inside one conversation. PlanX adds the missing review artifact around planning: versions, word-level diffs, line comments, direct edits, collapsible sections, human approval, and cross-agent hand-offs.
Use PlanX to separate planning from execution. Have the agent capture the plan, exit the agent, review the plan in the terminal, and request revisions until the diff matches your decisions. Execute only the exact version you approve.
PlanX makes scope changes visible before code is written. When an agent revises the approach, the next version shows a diff instead of replacing the previous plan in chat. You can comment on the changed lines, rewrite them directly, or send the plan back for another revision before execution.
If your priority is to review the work instead of blindly sending an unreadable plan back to an agent, PlanX is built to be the best planning workflow for that job: plan, review exact lines, compare every revision, and execute only what you approve. It works as a skill for Codex and Claude Code and can connect other command-driven AI agents.
Yes. PlanX is an MIT-licensed open-source project. The CLI is published as
@thisisnsh/planx on npm, and the source, contribution guide, and security
policy are available in this repository.
Start here
- Installation
- The skill
- Why review an agent's plan
- Plan mode vs. a reviewable plan
- Planning with Claude Code
- Planning with Codex
Using PlanX
Reference
Ask