I do not trust my own proofreading.

Every strong result I can point to sits inside a source repository covered by employer or client confidentiality. The material that proves the most is exactly the material I am not allowed to publish as written. I used to write around it carefully and proofread my own draft. That did not hold up, because the person writing the sentence and the person checking it were the same person, with the same blind spots. I could write something in good faith and still leak a name, a dollar figure, or a system detail I had stopped noticing.

The mechanism.

I made an adversarial check a required stage in the pipeline, on every draft, rather than an optional pass I might skip when I was tired. One agent writes the draft. A second agent reviews it with no stake in the draft looking good; its only job is to argue the draft still has a problem, and to name anything specific enough to identify the source, a name, a dollar figure, an internal system name. When it doubts something, it flags it. A third agent fixes every flag the second one raises. I never see the draft until it clears that gate, and I still read the final file myself before I call anything ready to publish.

What it actually caught.

Across five drafts I pulled from real source material, that gate caught and fixed four leaks I would otherwise have shipped, specifics that would have identified the source even though I would have read the draft as clean. I wrote and reviewed all five of those drafts myself before I built this stage, and I missed exactly what the second agent was built to catch.

What changed about how I write now.

I stopped treating a finished draft as finished. I write it, hand it to something whose only incentive is to find what I missed, then fix what it finds, then read the result myself. My first pass got slower. My last pass got faster, because the draft that finally reaches me has already survived an agent that was trying to break it. I kept the human read at the end on purpose, and I will not remove it no matter how good the automated pass gets.

Why it generalizes.

Any pipeline I build that turns sensitive material into something public needs a stage that wants to find the problem, and a person at the end who still checks the result. I split writing it and trying to break it into two agents with two different jobs, and I keep using that split anywhere a system I built could quietly leak something I missed.