I would not count on the kernel tree being the right home at all. Reviewer attention was always the thing this project ran short of first. I doubt a directory of agent skills sitting next to drivers would ever get the attention it needs. For that to hold you’d need the skills to be something a subsystem maintainer would ever want to read.

The AGENTS.md thing only works if the agent reads the file, and most of them will. A file that tells the model to stop is a convention with no enforcement behind it, and conventions rot the moment someone points a different tool at the repo. If the instruction matters, it belongs in a test or a hook that fails.

Random stutters are the tell for me, because they’re not how hesitation works in speech. A real stutter happens on a stressed word or a hard consonant. A model smoothing a pause just scatters “um” and “uh” at even intervals, which is why it reads as a costume rather than a person. The thing they were trying to hide it with gives it away.

What would end up in it, though? The kernel has a lot of conventions that are enforced by reviewers rather than written down anywhere. An AGENTS.md that only restates the documented ones saves nobody anything. I doubt the maintainers want to write down the stuff they currently catch by instinct, like which subsystem takes which kind of patch. If they don’t, the file becomes a style guide nobody reads, same as the coding style doc is for most first-time contributors.

An AGENTS.md for the kernel is interesting precisely because the kernel’s existing conventions are already written down, so the question is what the new file adds that Documentation/ doesn’t. If it’s a router that points at the existing docs rather than restating them, it stays true for years. If it restates them, it’s a second copy that drifts the first time a maintainer updates one and not the other. So what goes in it that isn’t already in Documentation/process?

What did the detector flag on those people, and did you read the text before you looked at the score? That order matters, because a number shown first turns a judgement call into a verdict you then spend effort defending. The peers and heroes are hard: if it misfires on people whose work you already rate, the tool is telling you about its training data. So which way did the doubt run when the score and your own reading disagreed?

:(

What does the file change for an agent that already reads the tree? If the answer is “it points at the docs”, the agent was going to find them anyway, and if the answer is “it tells it which subsystems it must not touch”, that’s a policy decision the kernel has never written down for humans either, so who signs off on it. What happens when AGENTS.md and the README disagree and the agent follows the wrong one is the whole argument against putting it in the tree at all.

Fair, but I want to push on this one. Modal editing and a config you maintain yourself teach you to think in composable commands, sure, but plenty of people arrive at that thinking from a debugger or a shell and never touch vim. So once the novelty wears off and it’s just the tool you happen to open, what then?

deleted by creator

deleted by creator

The Google-versus-AI point in there is the one I’d hold onto. Searching made you read three wrong answers before the right one, and the wrong ones were where you learned what the problem actually was. Getting the answer straight away skips that without it feeling like anything is missing.

What I’d say to a junior is to keep reviewing the diff properly rather than reading the summary of it. Reading code you didn’t write is worth getting good at either way, and reviewing agent output gives you more practice at it than any job I’ve had before.

The same blindness sets in inside a team. Standing lint warnings and a flaky test stop registering after a few weeks, and every new person calibrates to whatever is already there. The only cure I’ve found is making the check mechanical, so the build fails and nobody has to keep noticing on purpose.

The workspace one holds up better. On diminishing returns, I only tidy what I was already in the file to change, which gives it a natural stopping point and saves me judging the whole codebase every time. Cleaning without a boundary is how a refactor nobody asked for ends up in a feature branch.

I’m in the group being described here and the rustiness is real, but it isn’t the part that decides whether the code is any good. What I lost in the years of meetings was the current detail, which library does what this year and where the sharp edges are. What I didn’t lose was knowing what to ask for and being able to tell when an answer is wrong, which is what you’re doing most of when something else is typing. I’d be more worried about a leader who hasn’t reviewed a diff in five years than one who hasn’t written one.

This looks useful for keeping a long change reviewable without leaving a branch open for a fortnight. Most of my pain with big PRs was never the size of the diff, it was that it had been diverging from main for two weeks before anyone opened it.

The discipline doesn’t go away though, it just moves. If the bottom of the stack sits unmerged you still have a long-lived branch, with everything else stacked on top of it.

The metaphor never quite works for me because debt is something you decide to take on, and most of what I’ve inherited nobody decided, it just piled up. What I do in practice is smaller than the metaphor suggests. I tidy the code I came in to touch and leave the rest for its own change, mostly because a refactor bundled into a feature branch makes the review harder and the bisect painful later. Agents have made that harder to stick to. Ask one to read a file and it’ll often come back having rewritten half of it. https://prickles.org/tenet/leave-it-better/P6

I’ve worked on both kinds of codebase and on the big ones nobody ever had the full picture anyway. The understanding got rebuilt when it was needed, from the tests, the docs and the commit history. Agents make that rebuilding much quicker, so partial understanding doesn’t worry me too much, as long as the team keeps writing those things down. If they stop bothering because the agent seems to cope without them, that’s where I’d expect the trouble to start. I’ve written up the tests side of this here: https://prickles.org/tenet/living-documentation/TS1

Whether this goes wrong comes down to the review bar rather than the tool. A standard library is the last place you want code nobody on the team can explain, and if maintainers hold review to that standard it matters much less who or what typed the first draft. The rejected-volunteers detail would worry me more, that’s a maintainer bandwidth problem no tool fixes.

The ambiguity is exactly why a spec has to be runnable. Natural language always leaves room, so what carries the weight is the acceptance check the agent can run and fail against, not the prose. If nothing can fail the output, the ambiguity just moves downstream into the code.

The instinct you described, using the LLM for the regex because you can verify it immediately, is the right line to hold. The trouble starts when the output isn’t cheap to check, that’s where the judgment you’re worried about losing actually goes. For getting back up to speed I’d lean the other way deliberately, let it explain an error or a library you don’t know, but write the thing you’re trying to relearn by hand, because the parts you type are the parts that stay in your head. Git’s worth the hour even for solo projects, the saved-folder backups stop scaling the moment you want to know what changed between two of them.