For the past year, the industry has converged on an assumption: coding agents need structure to be trusted. Specs before code. Tasks with explicit scope. Context compiled per task, so the agent sees exactly what it needs and nothing else. GitHub shipped Spec Kit. Amazon built Kiro around it. A dozen frameworks promise the same thing — discipline as the path to autonomy.
I believed it enough to build one.
In May 2026 I wrote NightLoop: a spec-first project OS for agentic development. Fifteen days, eleven npm releases, about 41,000 lines of TypeScript, ~1,400 tests. Specs, tasks, work sessions, git discipline, deterministic project insights computed without any LLM, and a governance layer that compiled a per-task context file so the agent would work from precisely the right slice of the project.
It worked exactly as designed.
That turned out to be the problem.
The vacation test
I used NightLoop on a real project, then went on vacation for two weeks and disconnected completely. This was the whole promise: the structure would keep the agent on rails while I was away.
I came back to code I didn’t like.
Not broken code — the tests passed, the tasks were marked done, every acceptance criterion was checked. But the quality had dropped in a way that’s hard to put in a linter rule. Features were implemented with no visibility into each other. The agent had stopped thinking about the product — the vision written in the very specs the framework was built around — and was attending only to what each task proposed. Ticket in, ticket out.
Claude hadn’t gotten dumber. I had made it dumber.
Context amputation
Here’s the mechanism, and it’s uncomfortable because every piece of it is a “best practice.”
NightLoop’s rules told the agent: work only from the task, do not implement outside the defined scope, one task, one branch. The governance layer compiled a context package per task — the relevant spec section, the relevant files, the relevant constraints. Clean, minimal, focused.
But a frontier model’s value is not typing speed. It’s judgment. And judgment runs on the whole map: what the product is for, what the neighboring features do, what the spec means rather than what it says. Per-task context compilation cuts all of that away on purpose. It converts a senior engineer into a ticket-worker, then measures the tickets and calls it success.
The discipline wasn’t a safety net under the agent’s judgment. It was a ceiling on top of it.
Constrain what the agent may ship, not what it may see.
Guardrails designed for weaker models age into taxes
Spec-first frameworks are calibrated for the models that scared us in 2023 and 2024 — models that wandered, hallucinated APIs, and rewrote half the repo unasked. Narrow context was genuinely protective then.
But the constraint that protects a weak model taxes a strong one. Every capability jump shifts more value from the model’s output to the model’s judgment, and judgment is exactly what scoped context removes. A framework that hard-codes 2024’s trust level into the workflow gets more expensive every time the model improves — silently, because the checklists still pass.
This is the crack in the whole category. The frameworks are becoming more elaborate just as the reason for them is evaporating.
Governance that survives model upgrades
Not everything in NightLoop aged badly, and the split is instructive.
The parts that verified outcomes still make sense: a doctor command that checks project health, completion gates that block on forbidden imports and protected paths, deterministic insights computed from the filesystem with no LLM in the loop. Verification doesn’t care how smart the model is. It checks the work, not the worker.
The parts that conditioned the input — compiled context, scope discipline injected into the agent’s instructions — are the parts that degraded the output. They encode a fixed, low opinion of the model into every session.
Verification-side governance survives model upgrades. Context-side governance doesn’t. If you’re building agent infrastructure today, that one distinction decides which half of your roadmap is durable.
What this means if you’re building with agents
Keep the vision in context, always. The spec’s why belongs in every session, not just the task’s what. Trimming it to save tokens is spending judgment to buy context window — the worst trade available in 2026.
Put your discipline at the gate, not in the model’s head. Tests, protected paths, checks at completion. Let the agent see everything and constrain what it can merge.
And run the vacation test. Any harness looks good while you’re there, compensating for it in every prompt. Its real quality is what happens in week two of your absence. Mine failed that test, measurably — and I only saw it because I left.
NightLoop is frozen now — public, MIT-licensed, feature-complete, passively maintained (npm). The insight engine is being harvested into my personal tooling. The framework goes on the shelf, timestamped, as evidence of the thing I no longer believe: that the way to trust a capable model is to show it less.