56 posts tagged #context-engineering.
Loop engineering's six building blocks are all context primitives wearing new names. The scheduling is cron. The part that decides whether the loop works is the context delivered on every iteration.
Stored session transcripts are an external memory most people throw away after 30 days. A skill that forks a cheap model to grep, expand, and re-rank them turns 'what did we decide about X' into ranked snippets — so the agent stops re-making old mistakes.
Decompose a reviewed spec into discrete tasks and drive it with a loop that spawns a fresh headless agent per task. Each unit of work gets a clean context window and a pass/fail gate instead of one agent compacting itself into confusion.
Write the exact verification step into the feature spec your agent loads, so 'done' means the test passed and the result is on the table — not that the code compiled.
Not all code is equally expensive to get wrong. Stop reviewing your agent's output uniformly and start spending your scrutiny where a mistake double-charges a customer.
Agent-driven file discovery burns turns and fills the window with wrong guesses. A parameterized priming command loads exactly the right files in one deterministic shot — reserve probabilistic search for when you genuinely don't know where to look.
Taking the human out of the loop is the real unlock — but headless plus loose permissions plus production access is how you wake up to a wiped repo. Automate only what's tested, sandboxed, and scoped.
A destructive-tool annotation plus a mid-call elicitation request gives you a deterministic human checkpoint that travels with the capability — so a confused or injected instruction can't quietly delete your data, no matter which client is driving.
A single giant root rules file dilutes the agent's attention. Split persistent context into a broad root plus directory-scoped files the agent loads by what it's touching — and push task-specific instructions into commands.
Most AGENTS.md files defend against imagined mistakes. Mine your own transcripts, count what the agent actually gets wrong, and let the failure distribution decide what to write — and in what order.
A deterministic check on the agent's output, with one retry, kills a class of wrong answers that no prompt rewrite ever reaches — and gives you a number instead of a vibe.
When a tool call lacks a parameter, the agent's two instincts — fail or guess — are both wrong. Have the server elicit the missing field against a JSON schema and turn a half-specified request into a clean, validated dialogue.
An MCP server exposes resources, tools, and prompts — context the app pulls, actions the model takes, workflows the user invokes. Wiring them to the right controller is how the agent reads your conventions instead of guessing them.
A git pre-commit hook turns 'the agent should run the tests' into 'the agent cannot commit broken code' — a deterministic gate that self-corrects from its own error output and ships with every clone.
Scatter feature-gating logic inline and consistency depends on luck. Collapse the policy into one named helper and make 'call this gate' a rule, and uniform enforcement becomes the default across every endpoint the agent writes.
Asking an agent to review what you say you did grades your spin, not your code. A small MCP server that reads the live diff and carries its own rubric grades reality instead.
Before you write one more anti-hallucination instruction, split each wrong answer into a retrieval failure and a generation failure. The two need opposite fixes, and no prompt rescues context that was never pulled into scope.
The correction you keep re-typing into the chat is a missing command. Fold the recurring ritual into one parameterized verb backed by a rules file, and the workflow stops varying with your mood.
Turn each reported agent failure into a committed synthetic scenario, then replay it headlessly on every change. The bug becomes a permanent guardrail instead of a one-time patch.
Subagents are sold as parallelism. The real win is context hygiene plus model arbitrage: delegate read-heavy investigation to cheap explorers so your expensive model only ever sees distilled findings.
Wiring up Stripe or a database you've never touched by vibe-coding traps you at the first failure. Point the agent at the service's docs over MCP and force it to teach you back — close its codebase gap and your knowledge gap in the same pass.
An unattended agent loop has no instinct for 'done.' Give it a dumb iteration ceiling it can't argue past and a completion sentinel it can raise — and it terminates correctly and cheaply.
Pairing an isolated subagent with the right tools and a thin slice of your conventions rebuilds the proven agent loop — read, pick a tool, act, report — without dragging dozens of tool-call logs back into your main thread.
The dangerous MCP server isn't the malicious one — it's the convenient all-in-one that reads untrusted data and holds privileged access to a second system. Scope it, gate the writes, and you close the confused-deputy attack.
When the window fills, agents cut corners and auto-compaction throws away the wrong things. Author a handoff file, eyeball it, and restart in a clean session you control.
An MCP server is a trust boundary, not a passthrough. Hold every secret server-side and expose a curated verb set, so a prompt-injected agent is bounded by the tools you chose — not your full API surface.
An agent that waits for you to remember to ask it is a toy. Wire a deterministic event to a headless run that reads your rules, and the routine context work fires on its own — with your conventions already baked in.
Stop fighting the context limit with a bigger window. Write an exhaustive plan to a file, then run a relay of fresh sessions that each tick off items — so a migration too big for any single context still ships coherently.
The fix for slow, flaky agent evals isn't a faster suite — it's two loops. A cheap deterministic gate on every PR, and a slow judge suite headless on a schedule. One blocks regressions; the other discovers them.
Give every consequential tool a declared output schema and validate the result against it at the boundary, so the UI gates on a real success boolean instead of trusting the agent's prose — and a malformed result fails loud instead of rendering a lie.
Build your review as a headless command with an explicit tool allowlist, and the exact check you run by hand becomes the exact gate that runs on every pull request. One definition of 'acceptable,' two surfaces.
Ship your team's recurring workflows as server-side MCP prompts that pre-load their own data as embedded resources. A teammate types a slash command, fills one argument, and gets an expert prompt with the context already attached.
Every failed agent session is a labeled example of where your context falls short. Capture them, cluster them, and fix the top category once in your rules file instead of re-correcting it forever.
A rules file is write-once and rots; auto-memory saves corrections but on its own judgment, in its own store. Add the human-gated curation layer the vendors leave open: a command that counts corrections and proposes durable edits, a hook that resolves conflicts, so corrections compound instead of contradicting.
An agent reviewing its own plan shares its own blind spots. Wire a different vendor's model in as a deterministic gate, and a fail verdict re-engages planning before a line of code exists.
Your debugging ability isn't intelligence, it's a procedure — and procedures are exactly what you can write down once and hand to an agent. Bootstrap the whole library with a meta-skill.
Reviewing irreversible actions after the fact is too late. Split tools by reversibility in permissions, force a plan, and gate the destructive step behind a human interrupt — autonomy on reads, a hard stop on anything you can't undo.
Vague prompting isn't a skill gap you fix by writing longer prompts. It's a missing shared vocabulary — and the fix is a committed glossary, not a personal habit.
The codebase is the strongest steering signal you have — stronger than your prompt or your rules. So pay the exploration cost once, freeze it into a file, and feed it to every run.
You don't author a skill from a blank page. You send a subagent to research the problem once, and the research becomes the skill — a build artifact, not a document.
The highest-leverage thing you can do for your agent isn't a better prompt — it's a better interface. Deep modules are persistent context the agent reads at a glance.
Hand the agent two committed documents — a requirements doc that fixes the destination and a phased plan that fixes the journey — and a feature too big for one window ships correctly anyway.
The blocker to running an agent overnight is never capability. It's trust. And you don't earn trust with a smarter model — you earn it with a smaller blast radius.
Let peer agents talk freely and a query hot-potatoes between them, each disclaiming the task, while your bill climbs. Route everything through one orchestrator with explicit handoff rules and a turn cap, and the chaos becomes a system you can test.
Your rules file is necessary but not sufficient. Persistent context degrades as the window fills — so move the rule that keeps getting ignored into a hook that fires at the exact moment it matters.
Prompt injection isn't an unsolvable model problem — it's a context-engineering one. Fence untrusted tool output as data in your rules, run a parallel guardrail hook that cancels on a hit, and cap the blast radius with a permissions allowlist.
Your judgment — which tradeoff, which edge cases, which empty states — lives only in your head until something extracts it. A saved procedure that explores the repo, then grills you one branch at a time, turns a vague idea into a codebase-aware spec the agent can build against.
Hand-writing an adapter for every external system is the contextless agent's biggest tax. An MCP server collapses the M×N integration blowup into one standard connection the agent discovers at runtime — scoped by permissions, configured once.
A plugin isn't a convenience wrapper. It's how a workflow survives leaving your laptop — the difference between a personal habit and a team standard.
Treat prompts and rules like code: a golden dataset of inputs with known-good outputs, run headless on every change, gated by a hook that fails the build below baseline. The eval that blocks the merge is the one that prevents regressions.
An autonomous agent isn't a bigger context window. It's a tiny window run many times, where the git log — not the chat history — carries the decisions between passes.
A million-token window won't fix a long build. Externalize state to a plan file and run a relay across fresh sessions, because quality dies long before the window fills.
Hand-passing one plan per run keeps you inside the loop doing task selection for the agent. Pipe your whole issue tracker in and let it pick the next ticket itself.
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. Every major tool added support for it this year. Here's what changes when you use it.