𝗖𝗼𝗺𝗽𝗶𝗹𝗶𝗻𝗴 𝗧𝗵𝗲 𝗣𝗿𝗼𝗰𝗲𝘀𝘀, 𝗡𝗼𝘁 𝗧𝗵𝗲 𝗖𝗼𝗱𝗲
Coding agents are high-speed generators. They are creative but unreliable. They often forget rules when the context gets heavy.
To fix this, you should not lecture the agent. Instead, build a verifier.
A verifier is a cheap, deterministic check that sits in front of the generator. If the agent breaks a rule, the check stops the work. This is the generator/verifier split.
Most people use these checks for code. They look for typos or syntax errors. But the real power lies elsewhere. You can use these checks to compile your entire workflow.
I use checks to enforce professional discipline:
• One check ensures a task has a written specification before implementation starts. • Another flags dependencies that have gone stale. • A third enforces a strict lifecycle: proposed, reviewed, then accepted.
On a human team, these rules live in people's heads. Mechanizing them is often too expensive. With an agent, the math changes.
An agent causes drift faster than a human. But an agent can also write the enforcement script in seconds. The cost to mechanize your process is now near zero.
When the cost of enforcement drops, you can formalize your methodology. You move from a "checklist" to a "grammar." Your instructions become shorter and more honest because the gates do the remembering.
However, stay cautious of three things:
- These are linters, not a perfect type system. They catch known errors but cannot guarantee total correctness.
- There is no master blueprint. Your rules grow reactively based on past failures.
- The agent often writes its own gates. This means a gate might only catch errors the agent already knows how to avoid.
Stop treating your instruction files as manuals. Treat them as intent. Move the correctness out of the prose and into the checks.
Compile your process, not just your code.
Optional learning community: https://t.me/GyaanSetuAi