56 posts tagged #context-engineering.
The loop engineering parts list from June 2026, classified by one question: five blocks are context moves, one is a schedule, and the genre's signature failure is fixed by a seventh block the list never counted.
Your session transcripts hold every decision you've made with an agent, and the only free way to search them counts mentions instead of truth. Rank the survivors by date and the reversed decision stops winning.
A frozen spec substitutes for the memory a disposable agent doesn't have - but only if every task is genuinely independent. The arithmetic for when a flat-rate build loop actually holds.
A green build proves the code compiled. It says nothing about whether the work is correct. Write the acceptance test into the spec, then measure how well it survives an agent gaming its own grade.
A vibe-coded Stripe integration buries nine decisions in one handler. A teaching clause plus a plan-mode gate surfaces all nine - only three are worth your own trip to the docs.
Your daily review-minute budget is fixed, but a missed bug's dollar cost isn't. Spend the same minutes unevenly by blast radius and cut expected losses by roughly half, without reviewing more.
Agent-driven file discovery burns 12,000 tokens rediscovering three files you already knew. A parameterized priming command drops that to 6,200, and the saving holds from session one.
While you watch an agent work, you are quietly doing two jobs: judging what it may touch, and judging when the work is actually done. Headless mode deletes you from both at once. The gate that inherits the second job fails two separate ways unless it has two teeth.
destructiveHint plus elicitation gates a destructive MCP tool for clients that declare elicitation; for the rest, the fallback you write is the whole guarantee.
A single root rules file guarantees every convention is always present for every edit - which is exactly what floods a backend edit with frontend rules it will never use. The fix is directory-scoped files, and the tax has a number: 62.5%.
Raw frequency tells you which failures are real. It still ranks them wrong. Weight each promoted category by what one instance costs, and the rule that looked #2 by count drops to last.
Against a 1-in-12 hallucination rate on a checkable failure, a deterministic hook with one capped retry drives the shipped-wrong rate to exactly zero and moves the remaining risk onto one computable number: the halt tax.
The MCP spec hands a server three levers: resources for the application, tools for the model, prompts for the user. Skip that sort and your reads ride the tool list every turn, at a price you can compute.
When a required tool parameter is a fact only the human holds, the two familiar responses, fail and guess, each cost one round trip on the wire and guarantee nothing. Under the MCP spec current since 2026-07-28, asking costs exactly two round trips, fixed, whatever the human answers.
A soft AGENTS.md rule is a per-commit probability, and probabilities compound: 95% compliance becomes a 92.31% chance of a lapse somewhere in a 50-commit sprint. The hook most teams write only cuts that to 22.37%. Here is the arithmetic, layer by layer, and the one layer that zeroes it.
Ask an agent to grade the work you just described and it grades the paragraph, not the code, because agreeing with a confident claim is the model's strongest reflex. Hand the same model the live diff and a rubric you author, and it finds the four misses your summary hid.
A one-line bug report about an agent carries exactly one testable fact: how often the failure fires. Turn the report into a committed synthetic scenario, then let that fact size how many reruns a fixed verdict is worth.
A confidently wrong answer is two bugs in one costume: a fact that never reached the context window, and a fact that arrived and got ignored. Log the window, score two binaries, and each bug routes to a different layer of the stack.
Every inline authorization check an agent writes is an independent guess at the same policy. The guesses disagree, quietly. Here is the arithmetic of how fast that compounds, and the one call that stops it.
The correction you keep re-typing into the chat is a workflow you haven't written down. Priced with a small invented schedule, it costs about 43 silently skipped build gates a quarter. Encoded as a slash command, it costs zero.
Route a codebase search to a subagent pinned to a cheap model and two things happen at once: the search itself costs a fifth as much, and only a hundredth of it ever reaches the window where your expensive model is about to think.
The agent is an agreeable judge of done and the harness is a blind one. Two brakes, a third exit state, and the one night a $1.75 bill hides a lie.
A 20-issue Sentry triage sweep run inline leaves 21,000 tokens of tool exhaust in the main thread. Dispatched to a subagent under a three-line return contract, it leaves 60. The ratio holds at every cadence.
The GitHub MCP server that leaked private repo names in May 2025 had no malicious code in it. The token's authority was ambient, good for every repo you can see. Scope it to the task and the blast radius drops 12x.
When the window fills, auto-compaction writes a faithful summary and a handoff file writes an edited one. Both can be 200 tokens; next session they are 5,000 tokens apart, and the whole gap is one line saying what was ruled out.
A raw token passthrough hands an injected agent all 34 endpoints of your billing API, five of them destructive. Hold the token server-side and expose three curated verbs instead: one bounded write, capped at $500 a call and logged.
A relay of fresh sessions inherits every earlier decision through the plan file's checkboxes. But the model that ticks a box has every incentive to believe its own diff. An unaudited checklist is a bet, and this is the arithmetic that prices it.
An event can fire a headless agent run as reliably as a hook fires inside a session. But wiring the event only removes the human who had to remember to ask. The one who caught bad output has to be rebuilt as code too: rules for what a careful review would do, guards for what it would never let happen unattended.
A model has one procedure for turning tool bytes into a sentence, so a clean success and a swallowed failure read the same. On 12 refund calls, narration confirms 3 that never happened; a validated output schema confirms zero.
A suite thorough enough to catch a real regression is too slow and noisy to gate every PR. Split the same 50 cases into a 32-case deterministic gate and an 18-case nightly judge sweep, and a team merging 8 PRs a day gets 156 minutes of blocked PR time back every week - without dropping a single case.
The triage prompt your team keeps re-typing makes the agent reassemble, through three round trips, context one expert already knew how to assemble once. That costs 600 plumbing tokens and 7.2 seconds per run. A server-side MCP prompt pays the assembly once, for everybody.
Your local review habit and your CI gate are two implementations of one question, and nothing forces them to agree. Write the policy once, pin the context, and both surfaces run literally the same check for about two cents a call. The same 30 weekly pull requests on Anthropic's managed Code Review run $450 to $750.
A rules file is right the day you write it and silently wrong forever after, because nothing marks a reversed line. Auto-memory keeps both truths and cannot pick one. A trigger, a dated demotion, and a human gate end it.
Every failed agent run is a labeled example. Capture them with a hook, judge them, count them. The count tells you which failure to fix first. The shape of the failure tells you where the fix belongs, and in one two-week log, half the rows are not fixable in the rules file at all.
Progressive disclosure keeps a skill library's index cost linear. The number of skill pairs an agent can confuse grows with the square of the library size - and nothing about a growing index tells you that's happening.
An agent reviewing its own plan misses the same defaults it always misses. Gate plan-mode exit on a different vendor's model, and a FAIL verdict re-engages planning before any code exists.
Permission systems that gate on scariness ask about everything and protect nothing. Gate on reversibility instead, and the same 12-call session drops to 3 interrupts without losing the one that counts.
Your agent spends about 38 tokens working out where to make a change for every 1 token it spends making it. Then it pays that bill again on the next run. Here's the math, and the throwaway file that ends it.
Every ambiguous noun in a prompt forces the agent into a blind search over candidate files. A committed glossary turns that search into a lookup - and nets 4,410 tokens back on the very first prompt, no waiting required.
You don't author a skill from a blank page. You commission a subagent to research the reconciliation once - across a fifteen-service fleet, that one commission is worth 56,500 tokens saved.
Rounding decided across four files costs 5,500 tokens to trace, every time anyone asks. One deep module cuts that to 700 - and pays for itself by the fourth ask.
A requirements doc fixes the destination, a phased plan fixes the journey - and every technique on this blog for keeping a long build sharp only protects the journey. Here's what the destination costs when nobody checks it first.
Full mesh and hub-and-spoke need exactly the same number of channels at three agents, which is why every swarm demo looks fine. Add a fourth specialist and the mesh pulls ahead for good - 45 paths against 10 by the time you reach ten.
A rule in your rules file only gets read if it survives to the top of a shrinking window. Move it into a hook that fires on the event instead, and expected compliance across one session's edits goes from 42.8% to 95.0%.
The blocker to running an agent overnight was never capability - it's trust. Layer a sandbox, an allowlist, and a scoped credential right, and one laptop's worst-case reach falls from 399 addressable things to 63, all recoverable with git checkout.
The model cannot tell an instruction from data, because both arrive as tokens in one flat stream. The defense that measured best marks which channel a token came from. It never reads the words.
A plan built from a vague prompt is a guess in a nicer font. ClarEval shows what skipping the interview costs: about 11 build attempts before one passes, versus about 1 if you ask first.
Your best agent workflow is six files that live on one machine. Rebuilt through Slack and memory, all six arrive intact 9.6% of the time. A plugin makes the whole loop one installable, versioned unit your team pulls.
A team wiring three agent surfaces to three systems by hand pays for nine adapters, 108 hours of year-one work. One MCP server per system, pointed at from each agent, costs 40.5 hours, and the ratio climbs with every agent the team adds.
A one-line AGENTS.md fix that visibly resolves the case you were chasing can still fail its own regression gate. Fixing one case here drops a six-case eval from 0.833 to 0.500 - and only a baseline that ratchets upward catches it before a user does.
An unattended loop that reads git log -5 each pass has a five-pass memory. In a 12-item plan, the decision made at pass 3 ages out at pass 9, two passes before pass 11 needs it. One line in PLAN.md pointing at the commit hash recovers it, for zero extra commits.
Auto-compact looks like memory because the session keeps running. Each pass is a lossy summary, and the loss compounds: two passes leave a Phase 1 decision a 25% chance of still being known. A plan-file relay holds 100% at any phase count.
Task selection is the one decision still routing every ticket through you. Write the priority order down once, and the 80 touches a sprint costs you collapse to 1 - same agent, same backlog.
The gap between agent capability and SME knowledge is the only problem worth solving. Context engineering is how you close it.
Copilot, Cursor, Claude Code, Codex, and OpenCode all converged on the same primitive - a rules file the agent reads on every session. Use it.
MCP is the standard protocol for plugging external systems - issue trackers, databases, design tools - into AI agents. Here's what changes when you use it.