Reference implementation, with native WebFetch and slash commands.
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 with precision and finishes long-horizon work.
Deep Work Plan is spec-driven development where the repository itself becomes the harness.
The problem and the answer
AI coding agents are remarkably effective in short bursts. On long-horizon work — a migration, a new subsystem, a refactor across dozens of files — they drift: context fills up, decisions are forgotten, and multi-hour tasks are abandoned halfway through.
Deep Work Plan answers with spec-driven development: the plan is the durable source of truth, and agents execute against explicit acceptance criteria and validation gates. Drift drops, the work stays verifiable, and any agent can resume it across sessions.
It is also harness engineering made portable. An agent harness is the scaffolding around a model — context, tools, control loop, guardrails, resumable state — that makes it reliable. Deep Work Plan installs that harness into the repository itself (AGENTS.md, docs, the .agents/ skills home, the DWP skill), so any agent can pilot any repo. Born at Dailybot, battle-tested for months, and released as the DailybotHQ/deepworkplan-skill.
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.
- 01 Reason about your stack
- 02 Generate AGENTS.md & docs
- 03 Scaffold .agents/
- 04 Verify conformance
- 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.
- 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.
- 03
Scaffolds .agents/ with the .claude to .agents symlink
A cross-agent .agents/ directory (skills, agents, commands) and the .claude to .agents symlink, mirroring CLAUDE.md to AGENTS.md, so every tool reads one source of truth.
- 04
Installs the DWP skill and scaffolds .dwp/
Wires the Deep Work Plan skill and creates the gitignored .dwp/ folder for plans and drafts, 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.
- 01 Open /init.md
- 02 Install the skill
- 03 Adapt your repo
- 04 Plan & execute
- 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.
- 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) for Claude Code, Cursor, Codex, Gemini, and Copilot.
- 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.
- 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 the .claude to .agents symlink
A cross-agent .agents/ directory (skills, agents, commands) with the .claude to .agents symlink so every tool reads one source of truth.
-
The Deep Work Plan skill, installed
create, execute, refine, resume, status, verify, onboard, and author — 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 and drafts 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.
Full adapter. Use the offline bundle if WebFetch is gated.
Offline bundle recommended; rules installed under .codex/.
Full adapter — the dwp-* commands run via AGENTS.md and # procedures.
Requires Gemini 2.5 Pro or newer, with native WebFetch.
Open source. Reads AGENTS.md natively and runs dwp-* via # commands.
Rules plus # command procedures drive the full Deep Work Plan loop.
Open source. Markdown rules and # commands run every dwp-* step.
Full adapter with a native command surface.
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
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.
Individual repository
one self-contained codebase
Orchestrator hub
coordinates sub-repositories
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.
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.
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.
MIT-licensed · zero telemetry · outputs to a gitignored .dwp/ folder.