Deep Work Plan

"Context matters more than the model" is the lesson it took me a year of vibe coding to actually believe. My best and worst sessions use the same model... the difference is whether I handed it a real plan or just vibes. The part I still fight is drift, the agent quietly wandering off the plan three steps in. Does Deep Work Plan keep checking the work back against the plan, or is the plan mostly an upfront thing?

spec-written-into-the-repo is the right model - a persistent plan that survives context resets and that any agent can pick up is fundamentally different from a prompt you're manually re-feeding each session. the acceptance criteria + validation gates combo is the piece most agent frameworks don't bother with. curious how it handles cases where the atomic tasks turn out to be wrong mid-run - can you edit and resume without blowing the state?

The "repo as harness" idea is clever — giving agents durable context instead of a fresh chat window every time is exactly what long-horizon tasks need. Context drift is probably the #1 reason agent work falls apart mid-task.Is the plan file something you generate once and manually update, or does it evolve automatically as the codebase changes?

Writing the plan into the repo rather than the context window is the right architecture. Durable state that survives model swaps and context resets is what makes long multi-step tasks actually viable. The validation gate pattern catches drift before it compounds. How are the gates implemented? Are they executable assertions the agent runs itself, or do they require human sign-off?

How do you keep the plan from getting stale as humans change the codebase between runs?

Hi Product Hunt 👋

Models matter. Context matters more. That one line is the whole reason this exists.

I build with AI agents every day, and I kept hitting the same wall: an agent starts a long task brilliantly, then somewhere around hour three it quietly drifts. The diff still compiles — it's just not what I asked for. There was never a clean way to resume, because the whole plan lived in a chat window that had grown too long to trust.

I stopped treating that as a prompting problem and started treating it as a structural one. The fix wasn't a smarter model. It was giving the agent a plan it couldn't drift from — written into the repository itself.

That's Deep Work Plan. The idea is two moves:

1) Make the plan the source of truth, not the chat. Before any code, you write a spec: a goal, atomic tasks, and for each task explicit acceptance criteria + a validation gate. "Done" is decided by the gate, not by how the model feels. And it lives on disk, so it survives a context reset or a handoff to a different agent tomorrow.

2) Let the repository be the harness. The context (files), the tools (your scripts and tests), the guardrails (the plan and its gates), the state (on disk) — all of it lives in the repo as plain files any agent can read. So it's tool-agnostic: Claude Code, Codex, Cursor, or next year's agent can all run the same plan. No vendor to bet on.

What I'm proudest of is that it's not a slide. It's dogfooded across three repos — including the site that documents it. It's MIT, and you can install it into your own repo in one step at deepworkplan.com/init.

If your agents start strong and wander by hour three, I'd genuinely love your take. How are you keeping long-horizon agent work on track today?