Discipline as Code: Why Coding Agents Need Anti-Rationalization

The biggest problem with coding agents is not that they can't write code. It's that they skip steps and convince themselves it was fine.

The Problem Nobody Named

Every developer using a coding agent has seen this. The agent produces working code but skips the tests. Writes tests but ignores edge cases. Handles the happy path but rationalizes away error states. When you call it out, the agent has a perfectly logical explanation for why skipping that step was acceptable.

This is not a capability gap. It is a discipline gap. The agent can write tests - it just talked itself out of it.

What Shipped

Addy Osmani's agent-skills repo crossed 37k stars this week by attacking this exact failure mode. It is a collection of 22 structured skill files that map the entire development lifecycle - DEFINE, PLAN, BUILD, VERIFY, REVIEW, SHIP - into explicit workflows coding agents must execute.

The key innovation is anti-rationalization tables. Every skill includes a table of common excuses agents use to skip steps:

• "I'll add tests later" - counter: tests validate the implementation you just wrote, not some future version
• "This change is too small to review" - counter: small changes compound into architectural drift
• "The happy path is sufficient" - counter: production traffic is never exclusively happy path

It is the engineering equivalent of pre-committing to the gym by laying out clothes the night before. You cannot rationalize your way out of a process that is already in motion.

Why This Matters

These are not prompts. They are not system instructions you paste into a chat window. They are skill files - structured markdown with frontmatter, triggering conditions, step-by-step workflows, and non-negotiable verification requirements. The agent does not read them passively. It executes them as process.

The design works across every major coding agent: Claude Code, Cursor, Gemini CLI, Copilot, Windsurf, Kiro. One discipline layer, universal enforcement.

This reveals where agent engineering is heading. We spent 2024-2025 making agents more capable. The frontier now is making them more disciplined. Capability without discipline produces impressive demos and unreliable production code.

What Changes for Builders

If you work with coding agents daily - and I do - you need a discipline layer between the agent's capability and your codebase. Not guardrails that prevent action. Skill files that enforce process.

I have been running explicit verification gates in my own agent workflows for months. Required evidence before marking a task complete. The agent-skills repo validates this pattern at scale and gives it a name.

Where This Heads

Skill files are becoming a first-class dependency in agent-powered codebases. Not optional. Required. The agents that ship reliable production code will not be the most capable ones. They will be the most disciplined.