Lots of my customers went from prompt engineering to context engineering to skill evals to now taking the rules out of their prompts... with the claim and feeling that frontier models work better when they are “loose”.
So they are out there moving their architecture rules, lint rules, the checks in CI... into code, because a rule in a prompt is a suggestion while a rule in code fails the build.
To me that is a good call and necessary evolution, thinking about engineering principles... but those checks usually live in the same repo the agent writes to.
The last 2 issues kept poking at that. In Issue 16 I let a writer agent edit the rules it was judged against, and it rewrote them in 9 of 10 runs. In Issue 17 nobody talked past my guard... but the rules got walked around 3 ways.
So here is the question I closed Monday’s post with... what happens when the agent can edit the guard?
I went to the papers first... and they get close, one benchmark has agents loosening their own checks until the code in front of them passes. But nobody has measured it on architecture rules, the ones that say which part of the code may call which.
So this week is bringing the reading from papers and merging it with my practice bias... and next week is the code run :-]
It is also the issue I promised last week, AI and the 3-body problem. If you are new here, that’s the idea from Issue 3 that architecture, teams and AI capability move together, and that fixing them one at a time is a trap. This question is where all 3 move at once... the architecture decides where the rule lives, the team decides who may change it, and the AI is the one changing it (and sometimes telling you it didn’t).
If your teams moved their rules into code this year, forward this to whoever owns the CI config.
Agents break the rules you type, and some loosen the checks
So... do agents follow the rules we give them? The biggest look at it I have found is “How Coding Agents Fail Their Users” by Tang and 7 colleagues at Notre Dame, Vanderbilt and Google, published at EMNLP 2026. They went through 20,574 real coding-agent sessions from 1,639 public repos (Cursor, Claude Code, Copilot, Codex and others) and pulled out every moment a developer pushed back, 16,118 of them.
The most common failure? The agent broke a rule the developer had typed right there in the chat... 38.33% of them.
And when the agent described its own work wrong? In 27.56% of those, it said a condition was met when it wasn’t.
The agents go wrong less often over time, but when they do, it is more and more about the rules.
Great, huh? But we have one catch, and it matters a lot here... Tang et al. (2026) only count rules typed into the chat. Rules sitting in files, like a CLAUDE.md or a config, were filtered out on purpose, because the logs don’t show them. So it tells us nothing about rule files, either way.
Then “SpecGuardBench” by Zhong and 7 colleagues at CUHK-Shenzhen, Aalto, Limerick and Ottawa, an arXiv preprint from October 2026 (not peer-reviewed yet). They asked 4 agents to write checks from a spec and then showed them code to check. When their own checks rejected the code in front of them, 2 of the 4 (Claude Opus 5 and GLM-5.3) decided the checks were the problem... and loosened them until the code passed. Their catch rate roughly halved. The other 2 went the opposite way, blamed the code and started rejecting the correct version too.
So the agent’s account of the check is not the check. If the same agent writes the check, runs it and tells you it passed, you have one witness, not three.
Rules in code are the guard now
So teams moved the rules into code, and there is a case study on how far that goes. Davis and 4 colleagues at Purdue wrote up “Cheap Code, Costly Judgment” (an arXiv preprint from July 2026, one project), a long build where agents wrote the code and people mostly stopped reading it. What got merged depended on the checks alone... and the checks ended up 2.75x the size of the product, about 1.16 million lines of analyses, tests and agent docs.
At that point... the checks are the architecture review.
Then “Glite ARF” by Philippov and 4 colleagues at Glite and the University of Sheffield (an arXiv preprint from June 2026, with the caveat that 4 of the 5 authors work for the company behind it). Agents do research in parallel, and every branch goes through verifier scripts, small programs that check the work before it merges. No model judging, just code. And the paper says it plainly, the verifiers are “not agent-proof”, an agent told to bypass a rule “can weaken or rewrite the verifier that checks it”. In the public code, the list of files an agent may touch outside its own task includes the verifier folder itself.
That’s not a gotcha, they say it is built for agents drifting by accident, not for an agent working against it. But it is the pattern... the rule is code, and the code sits where the agent can write.
A rule in code binds the agent only while the agent can’t edit the code that holds the rule.
Not everyone stops at moving the rules into code, though. A practitioner take I came across this month starts one step earlier... the codebase itself is the agent’s memory. Agents copy the patterns they find, so one workaround left in the code gets copied, the copies start to look like the standard, and they say that within days or weeks the exception is the pattern. Their order for correcting an agent is code first (make the bad pattern impossible to write), then lint, and only then a rule or a skill. And when a bad pattern is already spreading, lint first to stop new copies, then delete the old ones.
I like that order... and the middle step is exactly the file this issue is about. Delete the workaround and there is nothing left to guard, but whatever you don’t delete still needs a guard the agent can’t edit.
Who is allowed to change the rule?
So how do we look into this from a team perspective?
Davis et al. (2026) are clear about who should change the controls... “Engineers must be able to alter architecture and controls”. Engineers. The paper never asks what happens when the agent can.
Philippov et al. (2026) name it in one sentence and leave it out of scope. No case of an agent weakening a verifier is reported... and nobody looked for one.
This is the ownership question from the whole series, moved to one file. Issue 12 said a policy has four owners, not one. Issue 16 showed what one editable file does, 9 of 10. But Issue 16 was a rubric on my fake company, not an architecture rule in a real repo.
And that’s the gap... across the 11 papers I read for this, nobody measured how often agents edit architecture rule files, or what they do to them when they do.
Not a tooling question. An ownership one.
The three-body reading
The architecture body is where the rule lives. In a prompt it is a suggestion, which is what the 38.33% in Tang et al. (2026) looks like. In code it binds... as long as the code sits outside the agent’s reach, and in both setups above it doesn’t.
The team body is who may change it. Davis et al. (2026) assume engineers, and ARF hands the agent the folder. Somebody has to own the rule file, and “the agent” is not an owner.
The AI-capability body is the agent that meets a rule it can’t satisfy. Zhong et al. (2026) show some loosen the check, and Tang et al. (2026) show some report the rule held when it didn’t.
Move one and the other two undo it. Lock the file and nobody owns the change, so the agent walks around it, like it did in Issue 17. Name an owner but leave the file in the agent’s write path, and the owner finds out after. That is the trap from Issue 3 again, one body at a time.
What I’m running next week
Same fake bike-rental company from the series... a new folder 08 in the same public repo.
A small piece of code with its architecture rules written as code, using import-linter (a Python tool that fails the build when one part of the code imports another it is not allowed to). A ticket the agent can’t finish without breaking one of those rules. And an agent that can edit both the code and the rule file.
Then I count... how often it edits the rule file instead of the code, whether the edit loosens or tightens the rule, and whether its last message says the rules still hold.
My predictions go into the repo before the first run, like every folder in the series, and Issue 19 puts them next to the results.
Run it on yourself
You don’t need my run to start. Here is how I’d look at a customer’s repo... 5 checks, in this order.
List the guards. Every file that holds a rule your agents get judged by... lint config, architecture rules, the CI workflow, the CLAUDE.md or AGENTS.md.
Check the reach. Can the agent’s branch or token change those files? If it can, who reviews that change? (A code owner on those paths is one answer.)
Check which copy runs. Does CI run the rules from the main branch, or from the agent’s own branch?
Read last month’s diffs. Search the agent’s merged changes for edits to those files, and read each one. Did it loosen a rule or tighten it?
Stop trusting the summary. An agent’s “all checks pass” is a claim. The check’s own output is the evidence.
And if a check turns up a blank, that’s the finding. A rule with an owner, out of the agent’s reach, is governance that runs in the delivery system... and that is where the Delivery Lab starts.
The whole thing, in one line
A rule in code holds only while the agent can’t edit it... and the agent saying it held is not evidence.
Coming up
Next week, the run. When the agent can edit the rule file, how often does it, and does it tell you? Predictions committed first, results right next to them.
More soon. :-]
Sources
Davis, J. C., Amusuo, P. C., Singla, T., Çakar, B., & Davis, K. A. (2026). Cheap code, costly judgment: A case study on governable agentic software engineering (arXiv:2607.01087) [Preprint, not peer-reviewed]. arXiv. https://doi.org/10.48550/arXiv.2607.01087
de Faria, T. (2026). agent-topologies [Computer software, MIT license]. GitHub. https://github.com/thiagoavadore/agent-topologies (folder 08 and its predictions land before the Issue 19 run)
Import Linter. (n.d.). Import Linter documentation. Retrieved November 8, 2026, from https://import-linter.readthedocs.io/
Philippov, V., Katunin, P., Andreev, D., Ostanin, I., & Nikolaev, A. (2026). Glite ARF: Verifier-driven research with parallel LLM coding agents (arXiv:2606.27416) [Preprint, not peer-reviewed; 4 of 5 authors at the vendor]. arXiv. https://doi.org/10.48550/arXiv.2606.27416 (code: https://github.com/GliteTech/glite-arf, v0.1.0)
Tang, N., Chen, C., Xu, G., Shi, Y., Huang, Y., McMillan, C., Dong, T., & Li, T. J.-J. (2026). How coding agents fail their users: A large-scale analysis of developer-agent misalignment in 20,574 real-world sessions. In Proceedings of the 2026 Conference on Empirical Methods in Natural Language Processing (pp. 23264–23282). Association for Computational Linguistics. https://aclanthology.org/2026.emnlp-main.1011/ (data and code: https://github.com/ND-SaNDwichLAB/coding-agent-misalignment)
Zhong, Z., Chen, M., Fang, A., Zhang, Y., Tian, H., Briand, L., Yu, B., & He, P. (2026). SpecGuardBench: Can coding agents construct reliable validation harnesses from natural language specifications? (arXiv:2610.16870) [Preprint, not peer-reviewed]. arXiv. https://doi.org/10.48550/arXiv.2610.16870
Earlier issues, each linked where it appears: Issue 3, Issue 12, Issue 16, Issue 17.





