Skip to content
Deep Work Plan is live on Product Hunt today Upvote it

Agent & developer surface

Deep Work Plan for developers and AI agents

deepworkplan.com ships a machine-readable surface alongside its pages: an OpenAPI-described agent API, a stateless MCP server, native Markdown mirrors for every page in 17 languages, and the installable DWP skill. Everything on this page is live, public, and free — there is nothing to sign up for.

Zero-auth by design

There are no API keys to generate, no OAuth dance, and no sandbox separate from production — the production surface itself is the sandbox. This is a deliberate property of the methodology: agents cannot fill in "contact sales" forms, so the site never asks for one.

Read-only

Every operation is a safe, cacheable GET — except the MCP endpoint, which is POST. There are no write operations, uploads, or state changes anywhere.

No API keys

No registration, no tokens, no rate-limit tiers. Anonymous access is the documented contract, declared in /auth.md and the OAuth discovery stubs.

Free & open source

The site content and the DWP skill are MIT-licensed. Use them in commercial and non-commercial work without asking permission.

Machine-first

Structured JSON errors on /api paths, Markdown 404 recovery bodies, RFC 9727 API catalog, and an ARD capability manifest — built for agent consumption.

Plan and execute with the skill

The API above lets an agent read this site. The DWP skill is what lets an agent run the methodology — install it once in a repository and it ships a router plus nine sub-skills, invoked as slash commands (or by name, for agents that intercept slash — most use # instead, e.g. #dwp-execute).

Two independent choices: format, and how much review you want

Every plan picks one value from each axis. They are independent — a Lite plan can run trust, a Full plan can run guided, and either can switch mode later without switching format.

Lite

Task records live inline in the plan’s README, behind stable #task-N anchors — no separate task files. Built for small, bounded work: one concern, roughly one sitting. Still a complete plan: stable task ids, a Touched Surface, acceptance criteria, a validation gate, and a Final Review — never a stripped-down sketch.

Full

One file per task under N.task_<slug>.md, for long-horizon work spanning hours or days, or when a plan has real dependencies between tasks. A Lite plan promotes to Full later with /dwp-refine promote when compact records stop being enough — promotion never re-executes finished work.

Guided (default)

dwp-create analyzes the goal, decomposes it, and materializes a reviewable plan — already the real, executable plan, never a throwaway draft — then asks: retain it, promote Lite to Full, edit it, or stop. A human stays in the loop before any product work starts. Recommended the first few times, or for anything higher-stakes.

Trust (or auto)

Append trust (or auto) as the last word — e.g. /dwp-create <goal> trust — and the agent skips the review round, materializes a pre-approved plan, and returns the execute command directly. The power-user shortcut once you trust the flow; still records every decision and gate, it just does not stop to ask.

The nine sub-skills

Each sub-skill is invoked as a slash command inside the repository that installed the skill — not against this website. The full reference for each lives in the kit catalog.

The nine sub-skills
/dwp-create <goal> Turn a goal into a plan — Lite by default, Full for larger work, either mode from the table above.
/dwp-execute Run an existing plan task by task: read it fully, execute each task in order, validate its gate, update progress.
/dwp-refine Add, remove, or reorder tasks in an existing plan while preserving completed work and its recorded evidence.
/dwp-resume Reconstruct state from the plan’s own files and continue an interrupted plan from its first incomplete task.
/dwp-status Report a plan’s progress — completed, in-progress, pending tasks — without making any change.
/dwp-verify Check, mechanically, whether the repository is AI-first and whether its plans are well-formed. Changes nothing; reports pass or fail.
/deepworkplan-onboard Make a repository AI-first: reason about its stack, then generate an adapted AGENTS.md, docs/, .agents/, and a gitignored .dwp/.
/skill-create, /agent-create The author sub-skill: grow the repository’s own kit — a reusable skill for a repeatable procedure, or an agent for a recurring role with its own model and tools.
/dwp-upgrade Check for a newer published skill release and, only after explicit approval, install it and re-run onboarding as a fresh pass — every in-flight plan under .dwp/ is left untouched.

Two ways to run it

The same skill, the same nine commands — the format and review mode change with the size and stakes of the work, not the tool.

A small, bounded fix — Lite, trust

One concern, roughly one sitting, low stakes: skip the review round and let the agent materialize and run a Lite plan directly.

Terminal — slash commands
# A small, bounded fix: skip the review round, run it directly.
/dwp-create fix the flaky checkout test trust
/dwp-execute

Long-horizon work — Full, guided

Real dependencies between tasks, or higher stakes: review the proposed plan before any product work starts, promote to Full if the goal turns out to need it, then execute and resume across sessions as needed.

Terminal — slash commands
# Long-horizon work with real stakes: review before anything runs.
/dwp-create migrate the billing service to the new payments API
# ...review the proposed plan, then:
/dwp-execute
# ...interrupted? pick up again, even in a fresh session:
/dwp-resume

Every plan’s output — manifest, progress log, task records, gate evidence — lives under a gitignored .dwp/ directory in the repository itself. Nothing is sent to or stored by deepworkplan.com; the skill makes no network calls at all.

Endpoints

The core endpoints of the agent API. The complete, typed specification — every operation, parameter, and response schema — lives at the OpenAPI document.

Endpoints
GET /openapi.json OpenAPI 3.1 specification of the whole agent API.
GET /llms.txt Curated LLM guidance index — the recommended entry point for agents.
GET /init.md The canonical DWP adoption prompt (make any repository AI-first).
GET /{page}.md Any page as native source Markdown — in all 17 languages (e.g. /es/developers.md).
GET /api/health.json Static health marker with links to the spec and this portal.
GET /api/v1/index.json Versioned catalog of the v1 family: endpoint paths, site version, and spec links.
GET /api/v1/sections.json The site map as typed JSON — name, path, and description per section.
GET /api/v1/pages.json Every Markdown endpoint in every language, grouped by language code.
GET /api/v1/health.json Versioned health marker — the v1 mirror of /api/health.json.
POST /api/mcp MCP server (Streamable HTTP, stateless): initialize, ping, tools/list, tools/call.
GET /.well-known/ai-catalog.json ARD capability manifest — the agentmap declared in robots.txt.

Unknown /api/* paths return a structured JSON error with a resolution hint, never an HTML error page.

Versioning & deprecation

The versioned JSON family lives under /api/v1/ — index, sections, pages, and health — and the unversioned canonical paths (/llms.txt, /{page}.md, /api/mcp) belong to the same v1 contract. Breaking changes ship only in a new /api/v{N+1}/ family, never inside v1. When an endpoint is deprecated, its responses carry Deprecation: true and a Sunset date at least 180 days before removal, and a Link header points at the successor.

Rate limits

Responses on /api/* carry RFC 9331 rate-limit headers — RateLimit-Limit, RateLimit-Remaining, RateLimit-Reset, and RateLimit-Policy — so agents can self-throttle in real time; a 429 response adds Retry-After. Enforcement is best-effort at the edge (120 requests per 60 seconds per visitor), and access stays anonymous: no keys, no registration, no tiers.

MCP server

A stateless Model Context Protocol server over Streamable HTTP. Three read-only tools: get_init_prompt, list_site_sections, and read_page. Protocol versions 2025-03-26 and 2025-06-18 are supported; no session is required.

Terminal — JSON-RPC over HTTP
# 1. Initialize (no session needed — the server is stateless)
curl -s https://deepworkplan.com/api/mcp \
  -H 'Content-Type: application/json' \
  -d '{"jsonrpc":"2.0","id":1,"method":"initialize",
       "params":{"protocolVersion":"2025-06-18","capabilities":{},
                 "clientInfo":{"name":"curl","version":"1.0"}}}'

# 2. Discover the tools
curl -s https://deepworkplan.com/api/mcp \
  -H 'Content-Type: application/json' \
  -d '{"jsonrpc":"2.0","id":2,"method":"tools/list"}'

# 3. Call one — read any page as source Markdown
curl -s https://deepworkplan.com/api/mcp \
  -H 'Content-Type: application/json' \
  -d '{"jsonrpc":"2.0","id":3,"method":"tools/call",
       "params":{"name":"read_page","arguments":{"path":"/init"}}}'

The MCP manifest lives at /.well-known/mcp.json and the server card at /.well-known/mcp/server-card.json. Claude, ChatGPT, and any MCP client can call these tools natively.

Markdown for agents

Every rendered page is published as native source Markdown — not an HTML conversion. Request Markdown explicitly with a URL suffix or through HTTP content negotiation on any page.

Terminal — content negotiation
# Ask for Markdown on any URL (content negotiation)
curl -s https://deepworkplan.com/methodology \
  -H 'Accept: text/markdown'

# Or fetch the .md mirror directly — every page has one, in every language
curl -s https://deepworkplan.com/es/developers.md

Content negotiation returns the same source Markdown the site renders from, in the language of the URL you request.

Install the kit

The official install path for the Deep Work Plan skill — the same command the /init endpoint gives agents. It works with any skills-compatible coding agent (Claude Code, Cursor, Codex, Gemini, and others).

Terminal — skills CLI & official CLI
# 1. Install the DWP skill — same command the /init endpoint gives agents
npx skills add DailybotHQ/deepworkplan-skill@latest

# 2. Official CLI — zero-dependency client over this API (Node >= 18),
#    prepared in the site repo's cli/ directory pending npm publication
deepworkplan init
deepworkplan read /es/developers

The skill vendors into .agents/skills/deepworkplan/ inside your repository, so every agent that touches the repo shares the same methodology. The official deepworkplan CLI — a zero-dependency client over this same API (init, sections, read, open, mcp) — is prepared for npm and lives in the cli/ directory of the site repository until publication.

Machine-readable resources

Point an agent at it

The fastest path is still one line: hand any coding agent the /init prompt and it installs the skill, onboards your repository, and starts finishing deep work.