I Read Every Word That Goes Out Under My Name.

Every now and then, Claude varies from what I actually said and makes up a story. A sentence reads smoothly, sounds like me, and was never said. Last week a draft had me saying "I have run ten comfortably" about direct reports. What I had actually said was that I can handle six to ten, and that it is as you head toward fifteen that it gets unwieldy. A review pass caught it before it shipped. I write on a yellow legal pad, and what I publish is me, so I read every word that goes out under my name.

What I feel when one turns up is irritation and annoyance, especially because of the guardrails I have already built. Checks run before I approve anything: one blocks the words and punctuation I never use, one refuses to hand over a web page that is not in master, and a fact-check pass tests the quotes and sources behind each piece. None of them checks what I actually said, so the last check is still me, and I wonder whether I could put in one more guardrail that spots and surfaces anything I did not say.

Engineering teams are now living with the same problem in their code. DX's Q2 2026 report found that since the first quarter, code maintainability improved by 3.8% while change confidence, developers' trust that a change will not cause a production failure, fell by 6.1%. In DX's own words, "AI is making codebases easier to understand, but it's also making the code it generates harder to trust," and its Q3 report adds: "What hasn't kept pace is everything that makes that volume safe to trust." This week has been about what a system fails to see: the work a layer carried, the judgment a budget line misses, the zero-token morning a rating cannot score. Confidence is the last of them, and the hardest to see, because it lives in a person's head.

The standard answer is ownership. When AI writes the code, make the engineer own it: you ship it, you own it. Review harder, add tests, keep a human in the loop, and confidence takes care of itself. If it is slipping, the fix is discipline: smaller pull requests, stricter review, and an author who reads every line before merging.

Confidence used to come with authorship. The person who wrote a change knew why each line was there, what it replaced, and what it touched; review checked the work, and the author vouched for it. AI moves the authorship to a tool that does not know your codebase. GitClear, which sells code-quality tooling, reported in its 2026 analysis of 623 million code changes that the rate of duplicated code blocks rose 81% since 2023 and that refactoring line moves fell 70%. LinearB's 2026 benchmarks put the median AI-assisted pull request at 96 lines, against 26 for unassisted work.

That raises two questions worth asking of your own codebase, not of the industry. Is the tool writing only the lines the change needs? When it rebuilds something that already exists, who on your team would notice? Neither has a settled answer yet, and your repository will answer both faster than any study.

"You ship it, you own it" assigns accountability, not understanding. Ownership without authorship is a signature without the knowledge behind it, and reading every line buys some of that knowledge back at a cost that grows with every line the tool adds. So the confidence lands on whoever signs off, usually the manager, and the gap probably is not found until it is in production. That is what I call a One-Bit Approval: a yes that carries no record of what was examined, how deeply, or what was left unchecked, so everyone downstream reads the thorough version into it.

Getting out of this does not mean reviewing harder; it means no longer letting your approval be the only place confidence lives. Your sign-off is where confidence lands by default, and it was never meant to carry it alone. The decision in front of you this cycle is whether your approval stays the gate or becomes the last of several. My checks run before I read, and none of them checks what I actually said, so I still read every word. Design yours so your signature is not the only check on the code.

On the next AI-assisted pull request you are asked to approve, ask the author for three lines first: what they decided, what the tool decided, and what they checked already exists elsewhere in the codebase. If they cannot write line three, that is the confidence you were about to sign for. When you find yourself asking the same three questions every time, turn them into a check that asks for you.

Then pull up the last change you approved that you did not fully understand, and ask one question: did you approve it because of what you knew, or because it was your turn to sign? If it was the signature, your approval carried confidence nobody gave it, and the next production incident will ask you to explain code you never decided.

I send a short daily email on exactly this kind of thing; today's was about the One-Bit Approval your signature sends when you did not write the code. Get the next one here: https://technicalleader.coach/daily-email