Six pull requests merged into Panel this month, in a codebase I had not opened before October.

The diffs run from nine lines to sixty-four. Four of the six merged the day after they were opened.

// the first one is the expensive one

Everything that made the other five fast was paid for by the first. Getting the test suite running. Learning that this project keeps its tests inside the package rather than in a top-level tests directory. Working out which of the maintainers reviews what. Reading enough of the contributing guide to know the commit prefix they want.

None of that is work on the bug. All of it has to happen before the first diff, and none of it has to happen again. By the third PR I was spending the time on the actual problem, which is the only part that was ever interesting.

This is the argument for staying in a repo rather than collecting one merge each from ten of them. I have done the ten-repo version and the numbers look similar from outside, but the second contribution to a project you already know is maybe a fifth of the effort of a first contribution somewhere new.

// bugs come in families

Once you have seen how a codebase handles one conversion, you know where to look for the next one. The query param fix was about a string arriving from the URL and being turned into the wrong type. The LiteralInput fix three weeks later was a string going the other way and not being serialized as what it was. Same seam, opposite direction.

The uppercase extension bug is the same shape again. Something in the world does not match the exact form the code expected, and the code treats the mismatch as absence instead of as a variant. Projects have habits, and a habit that produced one bug has usually produced others.

That is why the fourth and fifth fixes took less searching than the second. I was not scanning the whole project any more, I was checking the places where this particular codebase tends to be careless.

// the slow one

#8821 took five days and five rounds of review. The other five carried two review rounds each and merged within a day or two.

It was the one that changed how caching decides whether two arguments are the same. Hashing by identity instead of by value is the kind of thing somebody depends on without knowing it, so a maintainer had to decide whether the new behaviour was right before they could decide whether my patch was correct.

That matches what I keep finding. The slow pull requests are not the hard ones. They are the ones where somebody has to form an opinion first, and the fix being small does nothing to speed that up.