You’ve probably felt it. That specific wave of nausea when you ask your AI coding agent to refactor a function, and it returns 200 lines of perfectly valid code that completely ignores your project’s architecture, naming conventions, and established logic.
We’ve been trying to solve this by throwing bigger context windows at the problem. We paste in more documentation. We upgrade to the latest model with a million tokens of memory. And yet, the agents still hallucinate. They still drift. They still act like brilliant interns who absolutely refuse to read the company handbook.
We’ve been treating AI hallucinations like a memory problem, when all along it’s been a governance crisis.
The real bottleneck isn’t the model’s capacity to remember your rules. It’s the lack of a structured, repo-owned instruction set. When instructions live in an external prompt or a fragile heuristic in your IDE, the agent has too much autonomy and zero accountability. It guesses what you want, and usually guesses wrong.
Enter Directed Contexts. It’s a shift in how we think about coding agents, moving away from external prompting and embedding instruction modules directly into the repository itself.
Think about what happens when instructions become a first-class citizen of your codebase. They aren’t just suggestions floating in a chat window anymore. They are version-controlled. They evolve alongside your code. When a developer updates the architecture, the agent’s behavioral constraints update with it in the exact same pull request.
If the agent doesn’t follow the rules, it’s not because it forgot them. It’s because you haven’t made the rules impossible to ignore.
This resolves the central paradox of working with AI agents: they need enough freedom to be useful, but too much freedom leads to inconsistency. Directed Contexts creates a deterministic boundary. The agent can operate autonomously within the repo’s defined context, but it cannot deviate from the embedded governance.
For developers exhausted by fighting their tools, this is a return to control. You don’t need a smarter model. You need a system where the agent’s behavior is owned, auditable, and aligned with the codebase’s own evolution. Stop begging the AI to remember your conventions. Put them in the repo, and make compliance the default.
FAQ
Q: Isn't a massive context window enough to keep the agent on track?
A: No. A bigger memory just means the agent has more room to ignore what's important. Without strict, repo-owned governance, context windows just scale the chaos.
Q: How does embedding instructions in the repo actually work in practice?
A: It means instructions are treated like code. They are version-controlled, updated via pull requests, and evolve with the codebase, ensuring the agent's behavior is always aligned with the current state of the project.
Q: Does this kill the agent's autonomy and creativity?
A: It kills the bad kind of autonomy—the kind that breaks your build. It gives the agent a deterministic sandbox to play in, making it reliably useful rather than unpredictably brilliant.