Everyone designs loops. No one asks what the agent knows each tick.
Loop engineering's six building blocks are context primitives wearing new names. The scheduling is cron; what decides the outcome is the context on each tick.
#context-engineering
56 posts tagged #context-engineering.
Your agent re-litigates decisions because you delete the answer.
Session transcripts are an external memory most people delete after 30 days. A skill that greps and re-ranks them turns 'what did we decide' into an answer.
One agent drowns in a 1000-line spec. A hundred finish it by morning.
Decompose a reviewed spec into discrete tasks and spawn a fresh headless agent per task. Each unit gets a clean context window and a pass/fail gate.
A green build is the weakest 'done' - and your agent's first choice.
Write the exact verification step into the feature spec your agent loads, so 'done' means the test passed - not that the code compiled.
The fastest way to corrupt money is an agent-built payment system.
Not all code is equally expensive to get wrong. Stop reviewing your agent's output uniformly and spend your scrutiny where a mistake double-charges a customer.
Headless mode isn't a flag you set. It's a privilege you earn.
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.
When you know where the context lives, stop letting the agent guess.
Agent-driven file discovery burns turns and fills the window with wrong guesses. A parameterized priming command loads exactly the right files in one shot.
Put the confirmation gate in the tool, not the UI.
A destructive-tool annotation plus a mid-call elicitation request gives you a human checkpoint that travels with the capability, whichever client is driving.
Your 600-line rules file is teaching the agent to ignore you.
A single giant root rules file dilutes the agent's attention. Split context into a broad root plus directory-scoped files it loads by what it's touching.
Stop writing rules for failures your agent never commits.
Most AGENTS.md files defend against imagined mistakes. Mine your own transcripts, count what the agent actually gets wrong, and let that decide what to write.
You can't prompt away a hallucination. You can validate it away.
A deterministic check on the agent's output, with one retry, kills a class of wrong answers no prompt rewrite reaches - and gives you a number, not a vibe.
A missing parameter is the agent asking what only you know.
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 schema.
Three control axes are sitting in the MCP spec. Most teams use one.
An MCP server exposes resources, tools, and prompts - context the app pulls, actions the model takes, workflows the user invokes. Most teams wire only one.
The friction humans hate in pre-commit hooks is perfect for agents.
A git pre-commit hook turns 'the agent should run the tests' into 'the agent cannot commit broken code' - a deterministic gate that ships with every clone.
Gate three routes and the agent forgets the fourth. Make it one call.
Scatter gating logic inline and consistency depends on luck. Collapse the policy into one named helper, make calling it a rule, and enforcement is the default.
Stop describing your work to the agent. Hand it the diff.
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 grades reality instead.
If you can't reproduce the agent's failure, your fix is a guess.
Turn each reported agent failure into a committed synthetic scenario, then replay it headlessly on every change. The bug becomes a guardrail, not a patch.
Half your agent's 'hallucinations' never reached the prompt
Before you write another anti-hallucination instruction, split each wrong answer into a retrieval failure and a generation failure. They need opposite fixes.
If you can describe your workflow, it isn't a workflow - it's a habit.
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.
Your Reasoning Model Should Never Read Grep Output
Subagents are sold as parallelism. The real win is context hygiene plus model arbitrage: cheap explorers read, and your expensive model sees only findings.
Bootstrap a service you don't understand and you ship a black box.
Vibe-coding a service you have never touched traps you at the first failure. Point the agent at its docs over MCP and force it to teach you back.
An agent runs forever or quits one bug short. You need two brakes.
An unattended agent loop has no instinct for 'done.' Give it an iteration ceiling it can't argue past and a completion sentinel it can raise.
Your smartest worker forgets every job the moment it ships.
Pairing an isolated subagent with the right tools and a slice of your conventions rebuilds the proven agent loop without dragging tool logs into your thread.
A legitimate MCP server with two trust levels is the exploit
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.
An agent watching its context fill rushes the ending. Take the wheel.
When the window fills, agents cut corners and auto-compaction throws away the wrong things. Author a handoff file, eyeball it, restart in a session you control.
Stop handing your agent the API key. Give it a phone, three numbers.
An MCP server is a trust boundary, not a passthrough. Hold every secret server-side and expose a curated verb set, so an injected agent is bounded by it.
An Agent Gets Worse Long Before Its Context Window Fills Up
Stop fighting the context limit with a bigger window. Write an exhaustive plan to a file, then relay fresh sessions that each tick off items until it ships.
The best prompt you'll ever write is the one you delete.
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 routine work fires itself.
Run your whole eval suite on every commit and you'll stop running it.
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 on a schedule.
Your agent says the delete worked. The proof is a sentence it wrote.
Give every consequential tool a declared output schema and validate at the boundary, so the UI gates on a real success boolean instead of the agent's prose.
The best prompt your team writes is the one nobody writes twice.
Ship your team's recurring workflows as server-side MCP prompts that pre-load their own data. A teammate types a slash command and the context is attached.
Your local review and CI gate are one check. Stop maintaining two.
Build your review as a headless command with a tool allowlist, and the check you run by hand becomes the gate on every pull request. One rule, two surfaces.
An Agent That Can't Forget Is Worse Than One With No Memory
A rules file is write-once and rots; auto-memory saves corrections on its own judgment. Add the human-gated layer between them so corrections compound.
You already have labeled data. It's the transcripts you throw away.
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.
A Second Opinion It Didn't Write
An agent reviewing its own plan shares its blind spots. Wire a different vendor's model in as a gate, and a fail verdict re-engages planning before any code.
A Skill That Writes Your Skills
Your debugging ability isn't intelligence, it's a procedure - and procedures are exactly what you write down once and hand to an agent. Start with a meta-skill.
By the time you review the diff, the destructive call already ran.
Reviewing irreversible actions after the fact is too late. Split tools by reversibility, force a plan, and gate the destructive step behind a human interrupt.
Build the Glossary the Agent Wrote
Vague prompting isn't a skill gap you fix with longer prompts. It's a missing shared vocabulary - and the fix is a committed glossary, not a personal habit.
Cache the Explore
The codebase is your strongest steering signal - stronger than your prompt or your rules. Pay the exploration cost once, freeze it, and feed it to every run.
Commission the Skill, Don't Write It
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.
Design the Codebase Your Agent Can Read
The highest-leverage thing you can do for your agent isn't a better prompt - it's a better interface. Deep modules are context the agent reads at a glance.
Destination and Journey
Hand the agent two committed documents - a requirements doc that fixes the destination, a phased plan that fixes the journey - and a big feature still ships.
Full Autonomy Is Just a Small Blast Radius
The blocker to running an agent overnight is never capability - it's trust. And you don't earn trust with a smarter model, but with a smaller blast radius.
Flat agent swarms demo beautifully and ship terribly.
Let peer agents talk freely and a query hot-potatoes between them while your bill climbs. Route everything through one orchestrator with a turn cap instead.
Inject the Reminder When the Agent Forgets
Your rules file is necessary but not sufficient. Persistent context degrades as the window fills - move the ignored rule into a hook that fires when it matters.
When your agent reads a webpage, that webpage can give it orders.
Prompt injection is a context-engineering problem. Fence untrusted tool output as data, run a guardrail hook, and cap the blast radius with permissions.
The planning step's value isn't the document. It's the interrogation.
Your judgment lives in your head until something extracts it. A procedure that explores the repo, then grills you branch by branch, turns an idea into a spec.
Adding a system to your agent should be a config line, not a codebase.
Hand-writing an adapter per external system is the contextless agent's biggest tax. An MCP server collapses the blowup into one connection, configured once.
Package the Workflow, Not the Prompt
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.
'It worked for me' is not a test for a non-deterministic system.
Treat prompts like code: a golden dataset run headless on every change, gated by a hook that fails the build below baseline. Only a blocking eval works.
The Loop That Re-Reads Its Diary
An autonomous agent isn't a bigger context window. It's a tiny window run many times, where the git log - not chat history - carries decisions between passes.
The Relay, Not the Window
A million-token window won't fix a long build. Externalize state to a plan file and relay across fresh sessions - quality dies long before the window fills.
Your Backlog Is the Prompt
Hand-passing one plan per run keeps you inside the loop doing task selection. Pipe your whole issue tracker in and let the agent pick the next ticket itself.
Your AI agent is smarter than you. And knows less than you.
The gap between agent capability and SME knowledge is the only problem worth solving. Context engineering is how you close it.
Write it down once. Every AI coding tool reads the same kind of file.
Copilot, Cursor, Claude Code, Codex, and OpenCode all converged on the same primitive - a rules file the agent reads on every session. Use it.
Your AI agent can't read your Jira. MCP is how you fix that.
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.