InPlan Interactive Planning Editor
Turn an ambiguous coding request into a reviewable Markdown plan before implementation begins.
- Source repo
- melly-lgtm/inplan
- Stars
- ★ 23
- Last updated
- 29d ago
- License
- AGPL-3.0
- Primary language
- TypeScript
- FA score
- 81/100 · Good
At a glance
- Works with
- Universal · cross-platformClaude CodeCodex (Partial support)
- You'll need
- Typical use
- A developer preparing an authentication rewrite can ask an agent to draft requirements, surface migration questions, and resolve them before implementation.
- Main limitation
- Adoption requires Node.js 22 or newer, local filesystem access, shell execution, and a coding agent capable of invoking the CLI.
- Source review
- 81/100 · Good
What does this agent do, and when should you use it?
InPlan is a Markdown workspace where a person and a coding agent refine an evolving requirement into a versioned specification before code is written. The repository contains `@inplan/core` for embeddable editing and plan-format logic, `@inplan/cli` for the agent-facing command loop, and `@inplan/app` for the human-facing Electron editor. A bundled skill has the coding agent create a plan, open the editor, raise inline questions, and react to the user's comments or direct edits. The resulting artifact is a normal Markdown file whose comment records live in a trailing HTML-comment JSON array, allowing the plan and its rationale to travel together through Git. The open core can be run locally, while a hosted edition is available at inplan.ai; the documented maturity is strongest on macOS with Claude Code in Turn mode.
The coding agent creates a <name>.plan.md file, drafts the requirements, and anchors comment threads with links such as [text](#cmt-id). Comments, replies, document-level notes, and structured choice questions are recorded in one trailing <!--inplan ... --> JSON block. The agent runs inplan open <file> to launch the desktop editor and block until the user acts. The user can reply to a thread, select a choice, or edit the Markdown directly, using Auto-accept or Review and Turn or Instant modes. The agent then reads the updated plan, revises it, and continues the exchange; inplan wait <file> waits for another action, while inplan signal <file> --done proposes that the plan is ready without overriding the user's decision. Control logs, canonical bases, and backups are kept under ~/.inplan/sidecars/<key>, while the portable output remains the Markdown plan.
- A developer preparing an authentication rewrite can ask an agent to draft requirements, surface migration questions, and resolve them before implementation.
- An engineering team with changing requirements can preserve answers, rationale, and revisions as inline discussions inside the same Markdown plan.
- A senior engineer supervising risky agent work can use Review and Turn modes to inspect each proposed planning change before accepting it.
- A solo developer doing rapid prototyping can replace an ephemeral chat trail with a Git-reviewable specification that remains available during later refactoring.
- A product manager, developer, and architect can work against one document while contributing product requirements, implementation detail, and architectural decisions.
- A team working from a source checkout or in a restricted environment can run the open core and configure the application and sidecar locations through the documented environment variables.
How do you install or deploy this agent?
Node.js 22 or newer is required. For the packaged installation, run npm install -g inplan, followed by inplan --version. This installs the inplan command, bundles the desktop editor launched by inplan open, and attempts to install the agent skill for detected Claude Code, Pi, and Codex environments. Set INPLAN_NO_SKILL_INSTALL=1 to skip that step, or run inplan install-skill later. For development from source, run git clone https://github.com/melly-lgtm/inplan.git, cd inplan, npm install, and npm run build. In a source checkout, point INPLAN_APP_CMD at the built @inplan/app, or start the editor separately with npm run dev -w @inplan/app.
How do you use this agent?
After installation, ask a supported coding agent to plan a task in plain language, for example: “Plan the auth rewrite with me.” The bundled skill directs the agent to create <name>.plan.md, run inplan open <file>, and place its unresolved questions in inline comment threads. Reply to those comments, select choice chips, or edit the plan directly in the desktop editor, then review the agent's next revision. The underlying loop uses inplan open <file>, inplan wait <file>, and inplan signal <file> --done. If agent detection fails, point the agent to the bundled skill/SKILL.md; the agent must be able to read that skill and execute the inplan CLI.
What are this agent's strengths and limitations?
- The specification, comments, and decision history remain in one readable Markdown artifact that can be versioned and reviewed through Git.
- Auto-accept versus Review and Turn versus Instant modes provide concrete choices about review strictness and collaboration cadence.
- The separation between
@inplan/core, the CLI, and the Electron application supports both the packaged desktop workflow and source-level embedding or development. - The skill-and-CLI integration covers Claude Code, Codex, and Pi instead of requiring one model provider.
- Adoption requires Node.js 22 or newer, local filesystem access, shell execution, and a coding agent capable of invoking the CLI.
- The project is primarily developed and tested on macOS with Claude Code in Turn mode; Windows, Instant mode, Codex, and Pi are described as lightly exercised.
- Comments use an InPlan-specific Markdown-link and trailing-JSON convention. Other Markdown software can render or diff the file, but no compatible interactive comment behavior is documented.
- The README specifies AGPL-3.0-or-later for the open-source edition; proprietary or SaaS adoption without its copyleft requires a separate commercial license.
- The default installation detects agent environments and installs skills and hooks, so users who do not want those changes must set
INPLAN_NO_SKILL_INSTALL=1.
How does this agent compare with similar options?
Unlike a linear coding-agent chat, InPlan places requirements, open questions, answers, and revisions in a versioned Markdown specification and adds review behavior resembling document comments and pull-request diffs. It complements an existing coding agent rather than replacing its code-generation model.
Key facts side by side with the most closely related agents.
| Agent | Source review | Stars | Updated | Language | Full support on |
|---|---|---|---|---|---|
| InPlan Interactive Planning Editor This agent | 81 · Good | ★ 23 | 29d ago | TypeScript | Claude Code |
| Pilot Shell | 53 · Major gaps | ★ 2.1k | 5d ago | JavaScript | Claude Code |
| Agent Skills — Production-Grade Engineering Skills for AI Agents | 71 · Some gaps | ★ 99k | 1d ago | JavaScript | Codex · Claude Code · OpenAI API |
| Ateam Agent Workbench | 70 · Some gaps | ★ 12 | 8d ago | TypeScript | Codex · Claude Code |
How does FollowAgents rate this agent?
Why each dimension lost points
The evidence shows read-only CI permissions, checkout without persisted credentials, opt-in telemetry with throwaway identifiers and person profiling disabled, and no localization-cloud request when no token exists. Review mode, proposal diffs, final user control, canonical copies, and backups provide strong confirmation and recovery, justifying full scores for user_confirmation and rollback. Deductions apply because global installation automatically detects and writes skills into multiple agent directories; those external effects are disclosed but still broad by default. The README does not comprehensively document telemetry endpoints, event fields, token handling, or localization-cloud flows. Sensitive-data evidence is limited to token gating and anonymous telemetry, without broad retention, encryption, or credential-lifecycle guidance. Dependency controls include lockfile synchronization, commit-pinned GitHub Actions, and a release-key build gate, but no vulnerability scan, dependency audit, or mitigation record is shown. Licensing, a corporate contact, and document author fields aid attribution, while the unverified publisher and absence of a complete maintainer provenance chain prevent full attribution.
The documented workflow, format, review behavior, offline degradation, and session-event model are directly consistent with the supplied tests and CI configuration, supporting full self-consistency. Node.js 22 is explicit, and fallbacks exist for absent tokens, unreachable cloud services, failed proposal lookup, and source-checkout operation. Dependency availability is reduced because CI deliberately skips the Electron binary, localization partly depends on a hosted service, and secondary platforms and agents are only lightly exercised. Tests cover network errors, missing parked files, races, and sidecar lookup failures, but evidence for comprehensive user-facing diagnostics and recovery instructions is limited.
The intended audience and scenarios are explicit: developers and teams collaboratively drafting, commenting on, reviewing, and approving plans with coding agents. Boundaries are unusually clear: this is a Markdown planning editor and CLI rather than an autonomous implementation system, and the support matrix distinguishes primary from lightly exercised integrations. Environment variables, headless behavior, source-checkout operation, restricted-network guidance, and the portable Markdown representation demonstrate strong environment fit. Trigger precision is deducted because the trigger is summarized only as any “plan X” request, while the actual skill was not supplied, so ambiguity handling, exclusions, and complex-intent matching cannot be assessed.
The README has clear sections for installation, quick start, internals, document format, compatibility, status, and licensing. Commands, package names, filename conventions, and event concepts are stable, with useful examples. Node requirements, npm and source installation, suppression of automatic skill installation, and development operation are concrete. Known limitations deserve full credit because the project explicitly identifies macOS, turn mode, and Claude Code as the principal tested combination. The full AGPL text and dual-license explanation are present. Deductions apply because there is no real FAQ and troubleshooting examples are limited; an npm badge and lockfile drift check do not replace a changelog, release cadence, or compatibility policy. Contribution and licensing contacts exist, but the unknown publisher identity and lack of an explicit maintainer roster, support commitment, or update-ownership policy leave maintenance responsibility only partly established.
The product yields portable, renderable, Git-diffable Markdown that retains comments, replies, questions, and selected answers. Review proposals, canonical baselines, and backups make the output directly usable for implementation, supporting full output usability. A versioned plan and inline decision record plausibly add value beyond linear chat, but claims of safer refactoring, reduced drift, and large correctness gains are only summarized in the README with links to external material not included here. The install path is short and configuration is usually unnecessary, yet Node 22, a global npm package, Electron, possible hosted features, and AGPL/commercial-license implications impose meaningful adoption costs.
Many concrete claims are traceable to supplied tests: telemetry consent and anonymity, token-gated localization and offline caching, proposal baselines, race protection, save-state handling, and the CI release-key guard. README, tests, and workflows strongly corroborate the core architecture and safeguards, justifying full cross-source corroboration. Deductions apply because high-level outcome and performance claims lack included experimental data, implementation files, or repository tests, and the evidence set omits the actual skill, environment reference, CLI implementation, and complete release materials. The project appropriately labels aspirations and lightly tested combinations, but some marketing causal claims are not cleanly separated from demonstrated facts.
- Global installation automatically detects Claude Code, Codex, and Pi and writes a skill into detected agent directories; managed environments should set INPLAN_NO_SKILL_INSTALL=1 and inspect the skill first.
- Opted-in telemetry sends event names and aggregate OS/Electron properties to a PostHog endpoint. Although tests show throwaway identifiers, deployments should verify the actual build configuration against privacy requirements.
- Non-English localization uses a login token to contact inplan.ai and stores catalog data in a local cache; the supplied material does not fully explain token storage, retention, or server-side processing.
- Windows, Instant mode, Codex, and Pi are explicitly described as lightly exercised and should not be assumed to match the maturity of the primary macOS, Turn, and Claude Code path.
- The AGPL-3.0-or-later and commercial dual-license model may affect proprietary distribution or SaaS use; review LICENSING.md and applicable obligations before adoption.
- This assessment is based only on the supplied static excerpts; no program execution, test execution, or dependency vulnerability scan was performed.
FAQ
Can it run entirely on my machine?
Is Claude Code mandatory?
Where are plans, comments, and auxiliary data stored?
.plan.md file, with comments encoded as JSON inside a trailing HTML comment. Control logs, canonical bases, and backups are stored centrally under ~/.inplan/sidecars/<key>.Can a proprietary or SaaS product adopt it?
What happens if the desktop app is not configured in a source checkout?
INPLAN_APP_CMD to the built @inplan/app; otherwise the CLI runs headless. The editor can also be started separately with npm run dev -w @inplan/app.