When your coding agent makes the same mistake twice, STOP.

• Spot the issue
• Tell the agent what went wrong
• Optimize its instructions
• Proceed

Here's what most people miss: your coding agent can upgrade itself. You describe what went wrong, and the agent writes a rule to prevent that mistake in the future. No documentation to read. No config files to edit manually. The agent does it for you.

If you're new to coding agents: they're AI assistants that can read, write, and execute code in your projects. Tools like Claude Code, Cursor, and Windsurf let you have a conversation with an agent that has full context of your codebase. Most of these agents can be customized through instruction files (like CLAUDE.md for Claude Code) that persist between sessions.

The Core Insight

Your agent just made the same mistake for the third time this week. It committed without running tests. It ignored your coding standards. It used a pattern you've corrected before.

Most people fix the code and move on. Then they fix the same thing again tomorrow. And next week.

Instead, STOP. Say this:

Let's take a step back. You just did X, and I don't want that.
Please update your instructions so this doesn't happen again.

The agent updates its own instructions. The behavior is fixed permanently.

You didn't read documentation. You didn't context-switch. You just told the agent what you didn't like, and it fixed itself.

The 60-Second Upgrade

I set this up in 60 seconds:

# Landing the Plane

When the user says "let's land the plane", you MUST complete ALL steps:
1. Run quality gates (tests, linters, builds)
2. Pull and fix any merge conflicts
3. Commit and push
4. Clean up git state and temporary files
5. Suggest next task

Before this, I typed "run the formatter" then "run the linter" then "run tests" then "commit" then "push" at the end of every session. Every. Single. Time.

Now I say "land the plane" and it's done.

Time to set up: 60 seconds (I copied most of it from a blog post).

Time saved per session: 3 minutes minimum. But honestly? I used to task-switch after sending each command. Check Slack. Scroll Twitter. Sometimes I'd burn 10-15 minutes before coming back just to type "git push." Now it's one command and done.

Sessions per day: I run dozens of agent tasks daily while building products, so even small per-task savings add up fast.

That's 60-90 minutes saved. Every day. From a 60-second setup.

The Compound Effect

Here's where it gets interesting.

I've added 50+ upgrades to my coding agent over the past few months. CLAUDE.md rules. Custom commands. Sub-agents for code review and plan review.

Each upgrade was small. A minute here, 30 seconds there. But they stack.

My agent now:

• Runs quality gates before every commit
• Reviews its own code for security issues
• Follows my exact coding standards without being reminded
• Handles end-of-session cleanup automatically
• Knows my project architecture and makes consistent decisions
• Retains memory between sessions
• Spawns 5+ different types of sub-agents for specialized tasks like code review
• Has dozens of commands that help me automate work across different projects

None of this existed when I started. I built it one STOP at a time.

The agent I have today would have taken weeks to configure manually. But I never sat down to "configure my agent." I just fixed problems as they came up.

That's the compound effect: fifty 60-second upgrades equals a massively customized system that feels like it reads your mind.

For the full breakdown of my workflow and how these pieces fit together, see My Claude Code Workflow.

Why This Changed Everything

Before coding agents, every improvement was a calculation. Should I learn Vim keybindings? Maybe 20 hours to get proficient, saves a few seconds per edit. Months to break even. Should I set up that bash alias? Write that script? The answer was usually "no" because setup cost was too high.

With agents, the equation flipped. The tradeoff used to be: hours to learn, minutes saved per day, weeks to break even. Now it's: seconds to explain, minutes saved per use, breaks even immediately. When setup cost drops to near-zero, everything becomes worth doing.

Why People Don't Do This

"I'm in the middle of something."

You're always in the middle of something. But the agent has context about this mistake right now: the conversation, the code it just wrote, what went wrong. If you wait until later, that context is gone. You'll have to re-explain everything from scratch. The agent won't be able to upgrade itself nearly as efficiently.

"It's too much work."

Don't spend 15 minutes reading through the conversation to figure out what happened, then manually editing your CLAUDE.md. Just point out what went wrong and ask the agent to update its own instructions.

That turns any fix into a one-minute patch.

Start Here

Next time your agent does something you don't like, STOP.

Let's take a step back. You just did X, and I don't want that.
Please update your instructions so this doesn't happen again.

Watch what happens. The agent updates its own instructions, explains the change, and asks if you want anything else.

How much time could you save? Try it yourself:

Save the STOP Framework