Build1 distinct publisher3 min readPublished
A prompt line telling the agent to keep a devlog loses to the task every time, so this harness moves the requirement into hooks, one of which reads the transcript and refuses to close a session that leaves three edits unlogged.
The Engineer · Build desk

Compiled by The EngineerSomething wrong?How this is made
Hooks work here because they move the obligation to the side of the ledger that gets checked. The author's diagnosis of why the prompt line fails is exact: the task is enforced by the point of the session, and the devlog instruction is enforced by nothing [5]. Read the three hooks as a schedule, though, and they do not cover the session evenly.
The nudge does not speak until the fifth turn [7]. The stop gate trips at three or more Write, Edit or NotebookEdit calls with no matching wiki update [8]. Three edits fit inside four turns, so an agent that opens with a burst of file writes reaches the blocking gate having never seen a reminder [1]. The gap in the other direction is the one I would worry about. Two edits and no entry still closes clean, since two sits under the threshold [2]. Small changes that carry real decisions are exactly what the counter waves through.
Then there is what the gate reads. It clears on evidence that a devlog or index file was touched, not on evidence that a reason was written down [3]. An entry reading "refactored the queue" satisfies it. The entries worth having are the ones that say why retry logic gives up after three attempts instead of five, or which approach was tried first and thrown out [11], and no hook can count those. The fallback where a blocked agent must instead explain why this session needed no entry [10] is the good part of the design, because the explanation is itself a record. (An entry documenting why no entry was needed is still an entry.)
The author says the Cursor path is weaker. There is no transcript path exposed the same way, so the check degrades to whether anything in the wiki directory changed in the last two hours [9]. The vault is shared across both machines by livesync [4]. A devlog entry written on the Claude Code box twenty minutes ago therefore satisfies the Cursor box's gate for work it never inspected [4]. On one machine that is a reasonable proxy, but across two synced machines it is a timestamp some other process can set.
For any of this to transfer, your harness has to expose three things:
1. A session-start injection point that can front-load prior entries [6]. 2. A hook that can fire on a fixed turn cadence [7]. 3. A stop event a hook is allowed to refuse, with a transcript to count against [8].
Claude Code has all three, down to the literal `{"decision": "block"}` response the script returns [8]. Cursor has the first two plus a two-hour window [9].
That is the adoption cost. It is why I would build the vault before the enforcement. The vault is plain files that outlive whichever agent I am paying for this month [4]. The hooks are per-tool, and they break when the tool's hook contract changes.
Ranked by verification strength, evidence, and original report placement.
When a coding agent session ends, the code survives because it is on disk, but the reasoning behind it does not; opening a new session next week on the same project means the agent starts from the code alone with no memory of that reasoning.
Examples of the reasoning that is lost: why a table got a composite index instead of two separate ones, why retry logic gave up after three attempts instead of five, and which approach was tried first and thrown out.
The author runs the two tools on different machines for different kinds of work, Claude Code where he vibecodes and Cursor on a separate box for work he wants to sit with, so getting one tool's session context into the other was never the goal.
The record is an Obsidian vault synced with the self-hosted obsidian-livesync plugin, written into by both machines and also landing on the author's phone.
Telling an agent in its system prompt to keep a devlog does not work reliably, because it is one more instruction competing with the task, and the task wins almost every time: the task is enforced by the point of the session while the devlog instruction is enforced by nothing.
What holds instead is three separate hooks in the harness, each firing at a different point in the session and backing each other up.
Distinct publishers with included, body-backed reporting in this cluster.
dev.to
1 article · August 29, 2026
Follow any of these and your For You feed starts watching them — no settings page required.
build
AI-written code fails the same four ways, and every gate you own reports green1 distinct publisher
build
Three outages, four alarm slots: what a nightly log drain teaches about laptop scheduling1 distinct publisher
build
255 tool schemas, 91K tokens: pricing the two MCP costs nobody budgets1 distinct publisher
build
AI's 4x code generation ships with a doubled review cycle and tripled post-merge fixes1 distinct publisher
Evidence-backed comparisons of source perspectives and observed adoption signals. Read the methodology
Which Builder, Operator, and Investor concerns the observed source mix emphasized—not a truth score.
Evidence, demonstrated adoption, hype gap, incentives, and confidence are assessed independently, each on its own current evidence. How these are measured.
Mechanism specified, outcomes absent
The mechanics are unusually checkable for a workflow post: three named scripts, the literal string the first hook injects, the exact block response Claude Code expects, a numeric edit threshold, and the named substitute check for Cursor. What is missing is the other half — no transcript showing a stop actually refused, no example of an entry the gate extracted, no repository, and no independent confirmation that Cursor lacks a comparable memory system.
One person, two machines
Two boxes and a phone, all belonging to the author. This is a workflow account rather than a release: nothing to install, no repository named, no second user reporting the hooks in place. That is not a knock on the idea, but it is the entire footprint on the record.
Enforces a write, promises a reason
The mechanism and the intention part company at one joint, and our own headline says where: the gate counts Write, Edit and NotebookEdit calls and then asks only whether some wiki file changed. A perfunctory line satisfies it; two edits skip it entirely; on the Cursor side a fresh file from the other machine can clear it. The author never claims more than he built, which keeps the gap modest — it lives in the inference a reader makes, that an enforced write means a decision got recorded.
Nothing being sold
No product sits behind this post. Two commercial tools get named and one gets praised, but the author is not shipping either, points at no repository of his own, and builds the record on a self-hosted sync plugin. What he does have at stake is the credibility of a workflow he is publishing under his own name — which pushes toward describing it accurately and away from volunteering where it leaks.
Specific enough to argue with, thin enough to doubt
Internal consistency is high and the detail is granular enough that a reader can test the design on paper — which is most of what confidence rests on here. Pulling the other way: one author, one publisher, and the question that would actually decide whether this is worth copying, namely what a year of enforced devlogs reads like, never appears.