Deep Work Plan

About Deep Work Plan

Deep Work Plan is an open-source methodology and CLI tool that writes a spec directly into a repository, turning it into a persistent, agent-readable harness. It structures work as atomic tasks with acceptance criteria and validation gates, so any AI coding agent can execute long-running tasks without drifting from the original intent. The plan survives context resets and agent swaps, and it's MIT-licensed.

Review

Deep Work Plan approaches agent-driven development as a structural problem rather than a prompting one. Instead of relying on chat windows to hold context, it places the plan-a checklist of tasks with verification gates-on disk, alongside the code. This means the repository itself defines what "done" looks like, and multiple agents can pick up the work where the last one left off.

Key Features

• Plan-as-source-of-truth: A spec file living in the repo breaks work into atomic tasks, each with acceptance criteria and a validation gate (executable commands like pytest && ruff). The plan, not the chat, drives execution.
• Resumable state: Task completion is recorded durably as status markers-not started, in progress, done, blocked. If a context window resets or you switch agents, the next run reads the state from disk and continues from the first incomplete task.
• Agent-agnostic design: The plan is plaintext in the repo, so Claude Code, Codex CLI, Cursor, or future agents can all run it. No vendor lock-in.
• Built-in drift control: Each task's validation gate re-runs against the current state of the repo. A task only gets marked complete when its commands exit 0. If things break, the task is blocked and the failure surfaces in a progress log rather than getting buried in a chat transcript.
• In-run refinement: You can edit, reorder, or split tasks mid-execution without losing completed work. The tool marks a bad task blocked, you refine the plan, and it resumes from the validated state.

Pricing and Value

Deep Work Plan is free and open source (MIT license). No pricing tiers or paid add-ons are mentioned. The tool is self-hosted; you install it into your own repository via a one-step command, and you run it with your existing agents. As a methodology encoded in plain files, there's no per-seat or usage cost beyond your own compute and agent spend.

Pros

• Puts the verification burden on executable gates rather than a model's self-assessment, making drift tangible.
• State file and task markers let you resume long-running work after agent disconnects or context resets, without replaying chat history.
• Task definitions are written as behavior (e.g., an API endpoint should rate-limit), so they don't rot when implementation details change.
• End-of-plan passes (security review, skill-discovery) automatically propose reusable building blocks and check the full change set.
• Works with any AI agent that can read and write files; no special SDK required.

Cons

• The methodology adds upfront friction: you must write a plan before coding, which may not suit quick exploratory spikes.
• Garbage-in/garbage-out applies to validation gates-if a task's acceptance criteria are weak, the agent can still produce poor work that passes the gate.
• Teams that prefer a lightweight, conversational workflow with frequent human steering might find the spec-first approach too rigid for their day-to-day cadence.

Deep Work Plan fits developers and teams who regularly delegate multi-hour tasks to coding agents and need those runs to complete without silent drift. It's less suited for rapid, one-off changes where the overhead of writing a full plan outweighs the benefit. If you already maintain quality gates in your CI pipeline and want to make them the backbone of autonomous agent work, this tool provides a file-based harness that any agent can follow.

Open 'Deep Work Plan' Website