Three Claude Code and Codex Skills for Catching Agent Mistakes

Author: steve8708

Steve walks through three custom skills he uses every day to solve hard problems with Claude Code and Codex. The common thread is using one agent to check another, and forcing agents to read documentation instead of guessing. All three are open source on GitHub.

Agent Watchdog: One Agent Checks the Other

The first skill is agent-watchdog. When one agent like Codex is working on a task he doesn't fully trust, he opens a second agent like Claude Code and tells it to watch the first. You copy the Codex deep link into Claude Code, and the watchdog reads the original prompt, watches the Codex thread until it finishes, then compares the result against how the watchdog would have solved it. It automatically fixes anything Codex missed and can test the work end to end.

Claude Code terminal running the /agent-watchdog command with the speaker on camera, captioned "Codex thread"

The mental model is a loop: a coding agent makes changes, a watchdog agent watches those changes, tests the code, catches issues, and suggests fixes. Steve compares this to OpenRouter's new fusion feature. Two models thinking through a problem and checking each other's work can be far more impactful than one.

Diagram of a coding agent and a watchdog agent in a loop, with arrows for "watch changes" and "test code, catch issues, suggest fixes"

Plan Arbiter: Negotiate a Plan Before Executing

The second skill is plan-arbiter. Instead of watching execution, both agents make their own plans, compare them, negotiate the differences, and produce a single final plan to execute. Steve finds Claude Code is better at writing plans while Codex is faster and cheaper to execute on them. His usual flow is to use plan-arbiter to reach a final plan, run it on Codex, then have Claude Code watchdog the Codex work and fix anything missed.

Flow diagram showing /plan-arbiter and /agent-watchdog stages: write plan, compare plans, improve plan, write code, improve code, watchdog code against plan

Read the Damn Docs

The third skill addresses a habit that frustrates him. Coding agents are reluctant to look up documentation and will guess repeatedly at the right API surface or the right way to integrate two things. Once he explicitly tells the agent to read the docs, it sees the answer and fixes the problem. The read-the-damn-docs skill teaches agents when and how to run efficient web searches for the kinds of problems that actually warrant looking things up.

Flowchart showing "code fails" leading to "read the damn docs" leading to "code works"

Why This Matters

Coding agents fail in predictable ways. They drift from the plan, miss steps, and guess at APIs rather than checking sources. These three skills target those failure modes directly: pairing two agents to cross-check each other, reconciling plans before any code is written, and forcing documentation lookups. All three are open source on Steve's GitHub at github.com/BuilderIO/skills.

Key Takeaways

agent-watchdog runs a second agent that watches the first, compares the result to its own approach, and fixes or tests what was missed.
plan-arbiter has both agents draft plans, then compare and negotiate them into one final plan before execution.
Claude Code tends to write better plans, while Codex is faster and cheaper to execute them, so the two can be paired by role.
read-the-damn-docs stops agents from guessing at APIs by teaching them when to run efficient web searches for documentation.