Your agent and your plan, in one window.

Plan2Code is a short, structured workflow where your AI agent asks, you decide, and the specs land in your repo as plain files. Version 3 adds an optional desktop app that holds the dashboard and your agent side by side.

Before you start

  • Node.js 18 or newer. Check with node --version. No Node? Get it from nodejs.org (the LTS download), or run winget install OpenJS.NodeJS.LTS on Windows, brew install node on macOS, or use nvm on Linux. Then open a new terminal.
  • Start from your project. Open your terminal in the project you want to work on (cd into it) before you run anything. Plan2Code works on the folder you start it in.
  • Ways in. plan2code (Claude Code, Devin or Codex), or type /plan2code in your agent ($plan2code in Codex).
  • No agent yet? Install Claude Code, Codex or Devin first, or let the plan2code command's setup page walk you through it.
npx --allow-git=all git+https://github.com/jparkerweb/plan2code.git

then, from your project, run plan2code (Claude Code, Devin or Codex), or type /plan2code in your agent ($plan2code in Codex).

Plan2Code - my-project
my-project
The Plan2Code dashboard for a task API that is half built: a Set up card, then the steps in order, with the Implement card marked Suggested and reading Phase 3 of 4 is next.
Agent Terminal: Claude Code

      
Agent running. Planny is keeping an eye on it.

The app is optional. The workflow, the specs and the skills are the same either way, and plan2code --classic keeps the terminal flow.

An illustration: the desktop app drawn around a real screenshot of the dashboard. Try the dock buttons and New Session.

The workflow, as a map

Every step is a card on the dashboard, and each one writes files the next one reads, so any session can pick up cold. Pick a station.

JavaScript is off, so every station is listed in full below.

Step 0Optional

Pathfinder

A foggy idea becomes a clear list of decisions, settled one question at a time. The agent asks a few at a time, each option with its trade-off written under it, and you pick. Skip it when you already know what you want.

/plan2code-0-pathfinder
A question card, How tasks are paged, with three options, the first marked Suggested, each with its trade-off underneath.
Questions arrive a few at a time on a page in your browser.
Step 1

Plan

Requirements, technical design and your approval: the shape of what gets built. No code is written until the plan hits 90% confidence. In the desktop app, Plan and Revise Plan can offer helpers matched to the job.

/plan2code-1-plan
The living document What we've agreed for a task API: where the plan is headed, paging marked Assumed for now, still open, and a short list still to work out.
The plan so far, with every assumption written down where you can argue with it.
Step 2

Document

The plan becomes a checklist of small tasks, grouped into phases, that a developer can just do. They are checkboxes in spec files in your repo.

/plan2code-2-document
Step 3Once per phase

Implement

Builds the next phase, task by task, with a report and your sign-off at the end. Implement + review adds a careful review of the changes before the sign-off.

In the desktop app, the Implementation Loop can build a whole spec phase by phase instead, each phase in a fresh agent, and write a report.

/plan2code-3-implement
/plan2code-3-implement-review
A phase of a task API being built: 5 of 11 done on the progress bar, and the phase's task list with the first five ticked.
Tasks tick off as they land.
Step 4

Finalize

Checks the work, writes the summary, files the specs away and suggests the commit message.

/plan2code-4-finalize
The finished screen after a phase: what happened, the next command with a Copy button, and a Back to the dashboard button.
Every ending says what to run next.
Any time

Quick task

Too small for the full process? A quick plan, then it just builds it.

/plan2code-quick-task
Any time

Review

A second opinion on the changes. Problems ranked, and you pick what gets fixed.

/plan2code-review
Any time

Handoff

Pack the current session into a document a fresh session can pick up cold.

/plan2code-handoff
Any time

Codebase X-ray

Explains how and why an area works, or ranks the rough spots worth fixing into a brief for planning.

/plan2code-xray
Any time

Diagnose a bug

Finds a bug's cause and writes it up without fixing it, then hands the fix to Quick task, or to Plan when it is big.

/plan2code-diagnose
Any time

Changelog

Picks the next version and drafts the entries, which you edit before Git commits them.

/plan2code-changelog
Any time

Git

A board for branches, pull, push and commits that opens on the likely next step. The screenshot is just below the map.

/plan2code-git
New in v3Any time

Get a PR ready

Picks the checks that cover your branch's changes, runs them, and says Ready, Ready with notes or Not ready. Then it writes a PR description for you to copy. It never commits, pushes or opens the PR, and it can read an optional test map.

/plan2code-pr-prep

An illustration, not a screenshot.

New in v3Any time

Write missing tests

Finds source files that no test covers. Once you approve its plan, it writes tests in your project's own style. It never changes source code, and it can read an optional test map.

/plan2code-test

An illustration, not a screenshot.

The git board on feature/task-endpoints: the Changes tab, badged 3, opens on a Next step card reading Commit 3 files, above the three changed files ticked for the commit. Branches and Sync tabs and a Done with git button sit beside it.

The git board

Three tabs, Changes, Branches and Sync, and it opens on the one holding your likely next step: commit, pull, push, publish, open a pull request or tidy up branches. That step is one main button. Each tab badges what is waiting on it, a stopped rebase or merge gets one block with every file marked, and nothing is pushed, published or deleted without asking. It never force-pushes.

What is new in v3

Version 3.0.0 adds a desktop app and what runs inside it, plus two utilities. None of it replaces the page or the terminal flow.

  • The desktop app

    One window: the dashboard as the main surface and your agent in a terminal panel the app owns (Claude Code, Devin, Codex or your own). New Session replaces the agent with a fresh one on a brief the app builds from its own record of the session, so in-progress work carries over. Update skills brings the installed skills level with the app, and the taskbar shows when Plan2Code needs you. Ask, Workspace, Help, Preferences, Git and Notebook open inside the window.

  • The Implementation Loop

    Builds a whole spec phase by phase, each phase in a fresh agent, and writes a report. It lives in the desktop app and replaces the old plan2code-loop CLI. Set strength per phase runs each phase on the model and effort of a strength you choose: Thrifty, Balanced, Best or Match my session. The loop strip and the report show what each phase ran on.

    An illustration of the loop strip, not a screenshot.

  • Helpers matched to the job

    Helpers (subagents) run at a strength and effort chosen for their task, never tied to one vendor. Plan and Revise Plan offer them now. A Subagents dialog turns them on or off per project and skill, with a Helper strength choice (Balanced, Thrifty, Best or Match my session), and a Subagents tab shows what each helper ran with.

  • Bring any agent

    Add your own agent CLI under User Preferences. A first-run setup page shows which built-in agents are found, install commands for your OS, and a Check again button.

  • Get a PR ready

    /plan2code-pr-prep picks the checks that cover your branch's changes, runs them, says Ready, Ready with notes or Not ready, and writes a PR description to copy. It never commits, pushes or opens the PR.

  • Write missing tests

    /plan2code-test finds source files no test covers and, once you approve its plan, writes tests in the project's own style. It never changes source code.

  • Activities

    A die in the console's top bar opens thirteen small games to play while you wait. A game pauses the moment Plan2Code needs you. They are off until you turn them on.

  • Start from your Notebook

    Start Pathfinder, Plan, Quick Task, Diagnose or Revise plan from a Notebook tab. The agent reads the tab only once you send it.

How a session goes

One page, from the first card to the sign-off. Your agent does the work in its terminal (or the app's terminal panel); you do your part here.

A Plan question card, How tasks are paged, with three options, the first marked Suggested, each with its trade-off underneath.

Pick a card, answer on the page

Pick a step on the dashboard and it starts right there. Questions arrive a few at a time, each option with its trade-off written under it.

A phase of a task API being built: 5 of 11 done on the progress bar, and the phase's task list with the first five ticked.

Watch it build

Tasks tick off as they land, and the line beside Planny says what is being worked on right now.

The Approve this phase card, with a button to read the completion report and three choices: Review the code first, Approve this phase, and I want changes.

Sign off

Read the completion report, then approve the phase or ask for changes. In Implement, you can also have the code reviewed first.

What the page gives you

The same workflow as the terminal, with more room to think. The page is there whether or not you use the desktop app.

Trade-offs in plain view

Questions arrive a few at a time, each option with its trade-off written under it, so you choose rather than guess.

Review before you approve

Review the code first, on the sign-off card, reviews exactly the files the phase changed. You tick which findings get fixed, then approve.

The Ask tab

A chat beside the cards for anything you want to know. It is answered at the agent's next check-in and never holds up your answers.

Attachments on notes

Paste a screenshot or attach a document to a note on any question, and show instead of describe.

A notebook of your own

A private pad for each project folder, in Markdown with pictures. It never goes into your project, and the agent reads a tab only when you start a workflow from it and send it.

Workspace folders

Add a shared library or a design folder as read-only context, and point at it by its @name.

Session meter

A ring in the top bar turns from green to red as a session grows long, and suggests when a fresh one would serve you better.

Runs on your machine

A small program Plan2Code starts for you serves the page on 127.0.0.1. No account, no dependencies, and nothing leaves your computer.

The Ask tab: the question Where are tasks paged? and Plan2Code's answer naming the file.
The Ask tab, answered between tasks.
The finished screen after a phase: what happened, the next command with a Copy button, and a Back to the dashboard button.
Every ending says what to run next.
The Notebook open over a question: two named tabs, and a heading, bullets and bold styled in place as they are typed.
Your own notebook, private to the folder.

The rules

Four rules do most of the work.

  1. Keep each session short.

    Chaining a couple of small skills on the dashboard is fine. Start a fresh console session when the session meter turns red, and always before a big planning or build step. The specs on disk carry everything between sessions.

  2. No code until the plan hits 90% confidence.

    Step 1 will not finalize below the threshold. Under it, the agent keeps asking and keeps reading your code, and writes every assumption down where you can argue with it.

  3. Checkboxes are the state, not the chat.

    Progress lives in the spec files. Any agent, any session, resumes cold from them.

  4. Approve a phase to close it.

    On the sign-off card, or by replying approved in the terminal. Nothing advances on a guess about what you meant.

When the agent is not running, you lose nothing. The plan, the tasks and the ticks are files in your repo, so a fresh session picks up where the last one stopped.

Prefer the terminal?

The desktop app is optional, and the workflow, the specs and the skills are the same without it. plan2code --classic keeps the terminal flow, and every skill also runs right in the terminal. Each one asks at the start whether you want the page or the terminal; add --web to skip the question and go straight to the page.

See every command in the README

# the terminal flow
plan2code --classic
# or, in your agent
/plan2code
/plan2code-1-plan --web plan a REST API for tasks

Install

Run it again any time to update.

Before you start

  • Node.js 18 or newer. Check with node --version. No Node? Get it from nodejs.org (the LTS download), or run winget install OpenJS.NodeJS.LTS on Windows, brew install node on macOS, or use nvm on Linux. Then open a new terminal.
  • Start from your project. Open your terminal in the project you want to work on (cd into it) before you run anything. Plan2Code works on the folder you start it in.
  • Ways in. plan2code (Claude Code, Devin or Codex), or type /plan2code in your agent ($plan2code in Codex).
  • No agent yet? Install Claude Code, Codex or Devin first, or let the plan2code command's setup page walk you through it.
npx --allow-git=all git+https://github.com/jparkerweb/plan2code.git

then, from your project, run plan2code (Claude Code, Devin or Codex), or type /plan2code in your agent ($plan2code in Codex).

It always opens a menu; no output at all means npm could not reach the repository and hid the reason: git ls-remote https://github.com/jparkerweb/plan2code.git shows why.

The installer also offers the desktop app. Answer Y to install it: the file is checked against the release's checksum before it is kept. There are builds for Windows x64, macOS (Apple silicon and Intel) and Linux x64, and the app needs Node.js 18 or newer. Plan2Code works without it.