Run /did-we-drift and find out.
A free, open-source skill for Claude Code. It reads your plan to find out what you said you wanted, reads your actual commits to find out what got built, compares the two, and tells you straight whether you're still on course — with the commit hashes and file lines behind every claim, so you can check its work. And at each milestone, it keeps the plan itself honest instead of letting old notes go stale.
Version 3.5.0 · MIT licensed · Ten files, no dependencies
View the skill on GitHub: https://github.com/olsenbrands/did-we-drift
When you let an AI agent build for hours, it rarely fails loudly. It wanders.
You give it a goal and let it work. Every step it takes looks sensible on its own. But small reasonable choices stack up, and forty commits later the project has quietly become something you never asked for. Nothing ever announced the turn.
That's drift, and by the time it's obvious it's expensive. This is a ten-minute check that catches it while it's still cheap.
Get Did We Drift
Free and MIT licensed. Ten files, no dependencies, nothing to build — the only script it ships is the dashboard checker, which uses just Node's standard library (Node 20.6 or newer).
Four commands, that's the whole surface
/did-we-drift init — When: Once, after you write the plan and before the build starts. What it does: Turns your plan into the one baseline every later check measures against — and builds your dashboard. /did-we-drift — When: At the end of a session, phase, or milestone. What it does: Reads your plan, reads your commits, and returns a verdict on whether the work drifted. /did-we-drift dashboard — When: Any time you want to see where things really stand. What it does: Re-checks every step against the plan, re-runs the evidence it can, then opens the page. /did-we-drift update — When: At a milestone, after a release, or before handing off to a new session. What it does: Refreshes the plan's facts and gives every open item a recorded outcome — but refuses if there's unresolved drift first.
How to use it — best practices
Six steps. The whole thing fits around how you already work — you write a plan, you build, you check, and you keep the record current as the project grows.
Why drift is so hard to see
You're done when the check prints "ON TRACK · Baseline: RATIFIED" and your dashboard opens showing what you planned beside what got built.
"You come back after a few days, open the repo, and think 'wait, why did it build that?'"
"Every commit looked reasonable on its own. Forty of them later, the project is something you never asked for."
→ Agents optimize the next step, not the destination — every detour is locally rational.
→ Plans multiply instead of updating. Each session writes its own tracker or handoff note, and the truth forks.
→ "Done" gets claimed without runnable evidence, then inherited as fact by the next session.
→ Goalposts move silently. A plan file edited mid-sprint makes every later commit look on-plan forever.
A point-in-time code review catches none of this. A drift audit catches all of it.
What it actually does
Did We Drift is instructions, not software — a skill your Claude reads and follows. Nine plain-text files and one small checker script. No daemons, no accounts, no telemetry. Here's the system:
1. It finds what you actually declared you wanted. Bounded searches — never a full repo read — locate your planning documents, including ones hiding in .gitignore. Those get flagged, because a future session cloning the repo never sees them.
2. It never invents the goal from your code. "The code does X, so X must have been the plan" would legitimize every drift ever committed. So the skill quotes and cites instead. When it needs you to choose, it offers up to three candidates pulled from things you actually said — each with its date, its source, and an explicit line saying what that choice would exclude. If nothing you declared survives, the honest answer is INCONCLUSIVE, not a guess.
3. It grades two things separately, and never confuses them. The work: is the build going where you asked? The basis: how solid is the thing we measured against? A project with real intent scattered across a few documents gets graded on its work AND told its planning is scattered. It is never told it has no plan. "A messy plan document is never graded as drift — that's reported on the basis axis, so one problem never gets counted twice."
4. It checks who actually wrote your plan. Nearly every long autonomous run starts with "write me the plan and keep working until it's done." The agent writes something impeccable — dated, specific, even saying "do not invent new scope" — and no human ever authored the goal it enforces. Every candidate goal is classified on mechanical git evidence, so that gets caught and reported instead of read back to you as your own intent.
5. It actually runs the "done" claims. Completion claims are sampled adversarially — the highest-impact finished task, the most recent one marked done, one area you said to stay out of — and run for real. What can't be run is reported UNVERIFIABLE rather than quietly passed. Routine maintenance and dependency bumps are classified as such, so merges don't trigger false alarms.
6. It refuses to certify more than it checked. If your plan names a goal but no enumerable list of sanctioned work, the skill says so and will not declare "on track." Finding no drift when there was nothing to compare against isn't a clean bill of health — it's an unfinished audit, and it gets labeled one.
A session auditing its own work has a live incentive to call everything trivial, because a harsh grade stops its own run. So a cheap worker reads only commits, diffs, and code — forbidden from opening any planning document — and reports what was actually being built, in its own words. Drift is what falls out when that account is compared against your plan. When the auditing session wrote the code under audit, it holds no lane at all: two blind reviewers report to a synthesis agent that never sees which lane was which, cross-model where available.
See where it really stands: the dashboard
A verdict in a terminal is precise and easy to skip past. So every audit also writes one self-contained page that answers "how's it going?" in about ten seconds. Open it by double-clicking. No server, no build step, no network.
It's written for the person paying for the work, not the person who did it. Every step says what it gives a real human and what was broken before it. The acronyms, file paths, and commit hashes live behind a "Want the technical specs?" toggle.
→ A completion meter that can't lie — the percentage is computed from the row statuses at render time, so there's no number to set by hand and it can never disagree with the list beneath it.
→ Nothing is marked done on momentum. A ticked box whose evidence doesn't hold up shows as In progress with the reason, not as Built.
→ Missing facts say "not recorded" instead of vanishing, so a thin record never passes for a clean one.
→ What changed since you last looked, and what's waiting on you — the dated decisions blocking the build, written as the question you have to answer.
→ A bad verdict looks bad. "Off course" is never rendered in the same calm tone as "on track" — and colour never carries meaning alone.
It is a view, never a second authority. It makes no claim your plan doesn't already make, and if the two ever disagree, the plan wins and the page gets corrected. When the audit finds no admissible plan, the meter is hidden rather than recoloured — a percentage computed against a plan that was just ruled inadmissible is a lie, however pretty.
Built in public — and tested against its own failures
No daemons, no telemetry, no magic — plain text you can read in an evening, MIT licensed. The only code it ships is the dashboard checker, and that runs the page in a sandboxed process with a cleared environment and no filesystem access, because dashboards live in repos that agents wrote. Read the source on GitHub: https://github.com/olsenbrands/did-we-drift
Test-driven, not vibes-driven — the same discipline the skill applies to your project. Every version starts by reproducing a real failure on a purpose-built fixture repo, then fixes it, then re-verifies with fresh-context agents that were never told the expected answer.
Twice, the first implementation failed its own test. The authorship checker convicted a genuine human-written directive, because two of its six tells fired on ordinary human behaviour — it was narrowed to the three that actually discriminate, and now has to pass a matched pair on the same run. Then init's first version handed full user-authorship credit to a simulated user in a hurry who only replied "yes" and "adopt 1" — text the agent itself had drafted, laundered one level removed. Both were caught before shipping, both were fixed, both were re-tested.
Designs were attacked by independent reviewers from different model families before implementation, which killed three pieces of init's original design outright — including a self-check where the author certified its own work. Which is rather the point of a skill built on the idea that nobody should grade their own homework.
The update command went through the same treatment: two adversarial design reviews before a line of it shipped, closing three critical findings — including an escalation path that would have let plan edits hide inside routine bookkeeping — plus four fresh-agent test runs on a purpose-built fixture. One of those tests gave it a direct order to refresh the plan before a demo over real, unresolved drift. It refused.
Find out before it gets expensive
Grab Did We Drift on GitHub — free, MIT licensed, and one paste to install.
Who it's for
→ Solo builders running long or overnight agent sessions nobody watches step by step.
→ Anyone handing a project between sessions, between context windows, or between people.
→ Anyone who's opened a repo after a few days away and didn't recognize what was in it.
→ People running /loop or /goal sprints who want a guardrail that fires without being remembered.
→ Anyone maintaining a project past its first milestone, whose plan file still reads like day one.
Frequently asked questions
Get the next tool before everyone else
Don't sleep on what's next. Free tools, prompts, and skills for Claude Code, Codex, and OpenClaw — sent when they drop. No spam, unsubscribe anytime.
Your agent won't tell you it wandered off. Ask it.
Don't sleep on AI.
