24 posts tagged #rules.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
Copilot, Cursor, Claude Code, Codex, and OpenCode all converged on the same primitive — a rules file the agent reads on every session. Use it.