Skip to content

Open methodology · MIT · Agent-agnostic

Models matter. Context matters more.

Deep Work Plan turns any repository into a structured environment — context, guardrails, and a durable plan — where any coding agent executes and finishes long-horizon work with precision and efficiency.

Copy into your agent https://deepworkplan.com/init.md

Copy the init.md prompt and paste it into your coding agent — Claude Code, Cursor, Codex, or any other — to make any repository AI-first.

Deep Work Plan is spec-driven development where the repository itself becomes the harness.

See how it works Read the methodology Read the spec →
A lighthouse on a rocky shore casts a single beam guiding a small vessel — an engraving evoking the repository as a steady harness that guides any agent.
An engraved diptych: a ship adrift in fog beside jagged rocks on one side, and the same ship steady on a plotted course toward a harbor beacon on the other.

The problem and the answer

A coding agent performs beautifully on short tasks. But hand it a long-horizon mission — a migration, a new subsystem, a refactor at scale — and drift sets in: the context window fills, earlier decisions fade, and hours of work stall halfway through.

Deep Work Plan answers with spec-driven development: a durable plan, atomic tasks, and validation gates the agent must pass. Done stops being a feeling — it becomes verifiable, reviewable evidence.

And because context is the scarcest resource your agent has, the harness is engineered to keep its own instruction load small and auditable: instructions load progressively, validation touches only what changed, and every task learns locally. The load per flow is measured in bytes and published every release — the latest release cut the execute flow by 45.7% and the resume flow by 67.5%. The plan itself scales the same way: a Lite plan for a bounded fix, a Full plan for work that spans hours, the format always following the scope of the work, not the other way around.

The method · Act I

You decide what done means and where the lines are. The plan carries your intent; the agents do the hours — no babysitting, no correcting every twenty minutes.

Read the methodology →

The method · Act II

Long tasks fill any model's context. Details fall away and the agent drifts. A written plan — atomic tasks, validation gates, resumable state — is what it returns to, lap after lap.

See the core loop →

The method · Act III

Each task names its acceptance criteria and the checks that must pass. The agent doesn't get to feel finished — it has to pass, or the task stays open.

Read the specification →

The method · Act IV

Context, tools, guardrails, and state live in your repository as plain files any agent can read. No lock-in, no external brain — it survives context resets.

See what onboarding generates →

The method · Act V

Context is the scarcest resource your agent has. The harness loads progressively, validates what changed, and learns task by task — with every flow’s instruction load measured and published, release after release.

Read the methodology →

Reasoning-based onboarding

Point it at any repository. It reasons — it does not copy-paste.

The onboarding flow inspects your repository's actual languages, frameworks, package manager, and validation commands, then generates artifacts adapted to that repository. A generic stub is treated as a failure.

  1. 01

    Reasons about your stack and archetype

    Reads manifests, folder layout, and CI to infer the real test, lint, and build commands, then classifies the repository as an individual repo or an orchestrator hub.

  2. 02

    Generates AGENTS.md, docs/, and per-module docs

    A reasoned AGENTS.md, a categorized docs/ hierarchy, and a README plus docs/ inside each major module — filled with your repository's real commands, not placeholders.

  3. 03

    Scaffolds .agents/ with .claude and .cursor symlinks

    A cross-agent .agents/ directory (skills, agents, commands) and the .claude and .cursor to .agents symlinks, so every tool reads one source of truth.

  4. 04

    Installs the DWP skill and scaffolds .dwp/

    Wires the Deep Work Plan skill and creates the gitignored .dwp/ folder for plans, installs the required AI Diff Reviewer local review, then optionally layers opt-in addons such as devcontainer support.

What happens when you run it

One instruction. The repository does the rest.

You do not pick an install method or copy a template. You hand your agent one line; it installs the skill — the reusable engine — and adapts your repository to it.

  1. 01

    Your agent opens /init.md

    It reads the onboarding prompt at deepworkplan.com/init.md and the methodology, specification, and kit it links to — the standard it is about to adopt.

  2. 02

    It installs the Deep Work Plan skill

    The skill is the engine — the same in every repository. One command pulls in the router and its sub-skills (create, execute, refine, resume, status, verify, onboard, author, upgrade) for Claude Code, Cursor, Codex, Gemini, and Copilot.

  3. 03

    It adapts your repository

    Reasoning about your real stack — never copy-pasting — it writes AGENTS.md, a categorized docs/ tree, per-module READMEs, a reasoned .agents/ kit, and a gitignored .dwp/. Your repository becomes the harness.

  4. 04

    You plan and execute

    Generate long-horizon Deep Work Plans for any task and run them step by step, with explicit acceptance criteria, validation gates, and resumable state — autonomously, for hours.

The skill is installed identically everywhere; what is adapted is your repository — the AGENTS.md, docs, and reasoned .agents/ kit generated for your stack. That split is what makes the methodology a reusable standard rather than a one-off scaffold.

What you get

Everything your agent needs to work autonomously.

One run, committed atomically. Every output is Markdown and every change is auditable.

  • AGENTS.md at the repository root

    Reasoned from your repository's actual stack, commands, and structure — not a template with placeholders. CLAUDE.md is symlinked to AGENTS.md.

  • Categorized docs/ and per-module docs

    Architecture, setup, standards, and troubleshooting — plus a README and docs/ inside each major module, generated from your codebase.

  • .agents/ with .claude and .cursor to .agents symlinks

    A cross-agent .agents/ directory (skills, agents, commands) with the .claude and .cursor to .agents symlinks so every tool reads one source of truth.

  • The Deep Work Plan skill, installed

    create, execute, refine, resume, status, verify, onboard, author, and upgrade — available to your agent as a single skill pack, with no per-repository copy.

  • Conformance you can check

    /dwp-verify produces an objective pass/fail report against the specification, so "AI-first" is verified, not asserted — and re-verifiable after every plan.

  • Two archetypes, handled

    Onboarding classifies your repository as an individual repo (the common case) or an orchestrator hub that coordinates child plans across repositories.

  • A living kit your repository grows

    The author sub-skill (skill-create, agent-create) lets the repository evolve its own skills, agents, and commands; opt-in maintenance add-ons such as dependency-upgrade help it keep itself up to date.

  • Git-native, resumable, .dwp/

    No daemon and no external state. Plans land in a gitignored .dwp/ folder, and any task resumes from git alone — even after context overflows.

Agents

Works with the agent you already use.

One methodology, many adapters. Markdown couples the framework to nothing — every agent that reads Markdown can run a Deep Work Plan.

Claude Code

Full

Reference implementation, with native WebFetch and slash commands.

Cursor

Full

Full adapter. Use the offline bundle if WebFetch is gated.

OpenAI Codex

Full

Offline bundle recommended; rules installed under .codex/.

GitHub Copilot

Full

Full adapter — the dwp-* commands run via AGENTS.md and # procedures.

Gemini

Full

Requires Gemini 2.5 Pro or newer, with native WebFetch.

OpenCode

Full

Open source. Reads AGENTS.md natively and runs dwp-* via # commands.

Windsurf

Full

Rules plus # command procedures drive the full Deep Work Plan loop.

Cline

Full

Open source. Markdown rules and # commands run every dwp-* step.

Antigravity

Full

Full adapter with a native command surface.

See all agents →

Stacks

Reasoning presets for the stacks that matter.

These are reasoning aids, not templates. Onboarding reads your repository's real manifests and adapts per stack — it never blind-copies a preset. Monorepos get per-module docs.

  • Django DRF · Poetry
  • FastAPI Pydantic · Poetry
  • Vue Vite · TypeScript
  • React Next · Vite · TS
  • Astro Svelte/React · MDX
  • TypeScript · Node Express · Fastify
  • TypeScript · Lambda Serverless · SAM
  • Go Modules · stdlib
  • Rust Cargo · 2021+
  • Generic Any stack
See all presets →

Two archetypes

Individual repository, or orchestrator hub.

Onboarding forks on the archetype. Most repositories are individual repos. A hub coordinates child Deep Work Plans across many repositories. The methodology handles both as first-class.

Common case

Individual repository

A single codebase with one primary stack, its own validation commands, and per-module docs. The default — onboarding assumes it unless the repository is clearly a hub.

For example, a Django API, a Vue app, or a TypeScript Lambda service.

Coordination

Orchestrator hub

A coordination repository that orchestrates work across sub-repositories via an orchestrator manifest, spawning child plans that each commit in their own repository, plus boundary rules and a navigation index.

For example, a hub coordinating five product repositories.

Methodology versus tool

A different layer. Complementary, not competing.

Deep Work Plan is not another scaffolder. It is the methodology layer underneath any spec-driven or scaffolding tool, focused on multi-hour autonomous runs.

Methodology versus tool Deep Work Plan Scaffolding / spec tools
Primary focus Multi-hour autonomous execution Spec or scaffold generation
Unit of work A Deep Work Plan (resumable session) A spec document or a scaffold
State model Git-native .dwp/ folder, resumable Often external or in-IDE
Agent coupling Agent-agnostic (Markdown and Bash) Often tool- or IDE-specific
Context recovery Resumes after context overflow Typically restarts the task
License MIT, open methodology and kit Varies

Origin

Built by Dailybot — the company behind asynchronous standups for distributed teams. Internally we used Deep Work Plans to make production repositories spanning Django, Vue, TypeScript Lambda, and Astro agent-pilotable. After months of production use, we open-sourced the methodology under MIT.

— The Dailybot engineering team
Learn about Dailybot

Make your repository AI-first

Give your agents deep work.

Hand your agent one line — point it at /init.md — and it makes your repository AI-first: it installs the skill, reasons about your stack, and commits a complete AGENTS.md hierarchy. From there you create and execute Deep Work Plans that run autonomously for hours.

Open the /init prompt Read the methodology
For agents & developers

MIT-licensed · zero telemetry · outputs to a gitignored .dwp/ folder.