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.
#rules
24 posts tagged #rules.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.