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 with precision and finishes long-horizon work.

Give your agent this

Read and follow the instructions at https://deepworkplan.com/init.md to make this repository AI-first.

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

View the full /init prompt Read the methodology Read the spec →

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.

  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 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.

  4. 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.

  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) 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 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.

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

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