Sixteen days of silence, one polite reminder, and a surprisingly good Friday in open source.
My favorite GitHub notification this month wasn't a new star, a detailed code review, or someone telling me my project had changed their life.
It was a maintainer saying:
"Sorry, I missed the request!"
That's it.
No technical discussion. No complicated review. No debate about architecture. Just five words, an exclamation mark, and a merged pull request.
And somehow, that little interaction made my Friday.
Let me explain.
The world's least dramatic pull request
On October 14, I opened a pull request to in-toto/friends.
If you're unfamiliar with in-toto, it's an open-source framework focused on software supply-chain security. The friends repository maintains a list of projects that integrate with it.
I maintain a tool called workproof, which generates verifiable engineering reports from private repositories.
I wanted to add it to the list.
The pull request was about as exciting as it sounds.
One row in a Markdown table.
Not a new feature. Not a performance improvement. Not a security patch that would save thousands of production servers from catching fire.
A row.
If GitHub had an award for the least dramatic contribution of the week, I might have been a serious contender.
I opened the PR, checked that everything looked right, and moved on to other work.
Then I waited.
And waited.
Not in the cinematic sense. There was no staring at the screen, refreshing GitHub every seven seconds while dramatic music played in the background.
I had other things to build.
But every so often, I'd check the pull request.
Still open.
No comments. No review. No labels.
Nothing.
Sixteen days passed.
The strange psychology of an unanswered PR
Here's something I've noticed about contributing to open-source projects.
When you submit a pull request, you know intellectually that nobody owes you an immediate response.
Maintainers have jobs, families, other repositories, notifications, issues, bugs, releases, and probably an impressive collection of browser tabs they'll never close.
I understand that.
But there's still a small part of your brain that starts inventing explanations when a PR sits unanswered.
Did I submit it incorrectly?
Is this repository still maintained?
Was the contribution inappropriate?
Should I say something?
Would saying something make me annoying?
The last question is particularly interesting.
As contributors, we often worry about bothering maintainers. We don't want to appear impatient or entitled, especially when the change is small.
So we wait.
Sometimes a week. Sometimes a month.
Sometimes until the repository becomes a historical artifact and someone discovers our pull request while researching ancient civilizations.
Meanwhile, the maintainer might simply have missed the notification.
That's the funny part.
We can spend days interpreting silence that contains absolutely no information.
Thirty-five minutes
On October 30, I decided to write a follow-up.
Nothing elaborate.
I mentioned that the pull request had been open since October 14, that the change still merged cleanly, and that a quick yes or no would help me plan.
That was the whole point.
I wasn't asking the maintainer to prioritize my contribution. I wasn't explaining why my project was important. I wasn't trying to turn a Markdown table update into a philosophical argument about the future of software supply chains.
I just wanted to know whether the contribution made sense.
Thirty-five minutes later, the maintainer approved it.
The response:
"Sorry, I missed the request!"
At 11:02 UTC, the PR was merged.
Sixteen days of silence.
Thirty-five minutes after a reminder, done.
I laughed a little when I saw it.
Not because the maintainer had done anything wrong. Quite the opposite.
The answer was so ordinary and so human that it immediately made the entire situation feel smaller.
There had been no hidden disagreement.
No mysterious review process.
No elaborate technical objection waiting to emerge.
The request had simply been missed.
And now it wasn't.
We talk a lot about automation. We talk less about attention.
I spend a lot of time around software engineering, open-source tooling, and AI-assisted development.
Every week, there's a new discussion about agents writing code, agents reviewing code, agents fixing bugs, and eventually agents doing practically everything except remembering where we left our coffee.
Some of those developments are genuinely exciting.
But this little experience reminded me of something that doesn't get nearly as much attention.
Open source isn't just a collection of repositories.
It's also a collection of people trying to coordinate their limited time and attention.
A pull request can be technically correct, perfectly formatted, and ready to merge.
That doesn't mean someone has seen it.
And even when someone has seen it, that doesn't mean they've had the time or context to respond.
Those are different problems.
As engineers, we're very good at building systems that track code changes. We have statuses, checks, notifications, dashboards, review requests, and activity histories.
Yet a perfectly valid contribution can still disappear into the noise.
The software is doing its job.
The humans are just busy being humans.
A reminder doesn't have to be a demand
I've seen contributors handle unanswered pull requests in very different ways.
Some wait indefinitely.
Some send repeated messages.
Some become frustrated and start questioning whether the project is actively maintained.
And occasionally, a simple follow-up turns into an argument that nobody really wanted to have.
I'm not convinced any of those extremes help.
What worked for me was making the request easy to answer.
Not:
"Why hasn't anyone reviewed my PR?"
Not:
"This is a very important contribution and deserves your attention."
And definitely not:
"Hello??? @maintainer @maintainer @maintainer"
Just a little context, a specific question, and room for the answer to be no.
That last part matters.
When you ask for a review, you're asking another person to spend time on something you care about.
They might agree.
They might disagree.
They might need another week.
They might decide the contribution doesn't belong in the project.
All of those are legitimate outcomes.
A polite reminder doesn't guarantee a merge, and it shouldn't.
It just gives the conversation another chance to happen.
Of course, every project has its own contribution guidelines and review expectations. Some maintainers explicitly ask contributors not to ping them. Those boundaries deserve respect.
But where follow-ups are welcome, one clear message can be more useful than two weeks of silent speculation.
At least, it was in this case.
Small contributions are still real contributions
I also want to avoid exaggerating what happened here.
My PR added one row to a README.
It wasn't a significant engineering breakthrough. It didn't prove the quality or security of workproof. Being listed in a repository isn't the same thing as receiving an independent endorsement.
And I don't think we should pretend otherwise.
There's already enough inflated language in technology.
Not every commit is revolutionary.
Not every feature is groundbreaking.
And not every merged pull request needs a LinkedIn post explaining how it transformed the future of engineering.
Although, apparently, one Markdown row can inspire an entire article.
So perhaps I'm not completely innocent.
But small contributions do matter in a different way.
They help projects stay connected.
They improve documentation, update integrations, correct outdated information, and sometimes simply make it easier for the next person to discover something useful.
They also give contributors opportunities to interact with communities outside their own projects.
That last part matters to me.
I maintain my own tools, but I don't want all my engineering work to happen inside repositories where I'm the person making every decision.
Contributing elsewhere means learning how other projects work, respecting their processes, and occasionally discovering that the person on the other side of the pull request is just as human as you are.
It's a modest kind of connection.
But I like it.
The other side of the notification
There's another perspective worth considering.
Imagine maintaining a popular open-source project.
You've spent months or years building something useful, often without compensation proportional to the work involved.
Your inbox is full.
Someone reports a bug.
Someone requests a feature.
Someone opens a PR that breaks three tests.
Someone asks whether the project supports a configuration you documented two paragraphs above their question.
And somewhere among all of that is a perfectly reasonable one-line contribution.
You miss it.
Sixteen days later, the contributor sends a polite reminder.
You take a look, realize it's fine, and merge it.
What do you say?
In this case:
"Sorry, I missed the request!"
I appreciated that response because it didn't try to turn a small oversight into something complicated.
No excuses.
No defensiveness.
Just an acknowledgment and an action.
That's a pretty good way to handle many situations, not only pull requests.
And if you're a maintainer reading this, I don't think the lesson is that you need to respond to everything immediately.
That would be a terrible expectation.
It's that even a short answer can be valuable.
"Not right now."
"Needs changes."
"This doesn't fit the project."
"Sorry, I missed this."
A response doesn't have to be positive to be useful.
Sometimes it just needs to exist.
One more thing before I close GitHub
I have a couple of other pull requests waiting in different projects.
After this experience, I'm going to check their statuses and see whether a follow-up makes sense.
Not because I suddenly believe every unanswered PR is one message away from being merged.
Some changes need discussion. Some need substantial review. Some may never be accepted.
That's part of contributing to projects you don't control.
But I'm less inclined to interpret silence as a decision.
And I'm a little more comfortable asking a reasonable question when enough time has passed.
If you've contributed to open source, you've probably experienced that strange waiting period where you can't tell whether your PR is being considered, forgotten, or quietly ignored.
My experience isn't proof that reminders always work.
It's just one example of why they sometimes do.
Sixteen days of silence turned out to mean exactly what the maintainer said:
They missed the request.
Nothing more dramatic than that.
So thank you to the maintainer who took the time to respond and merge the change.
You probably spent less than a minute writing that sentence.
I ended up writing an entire article about it.
That's a pretty impressive return on five words.
I'm Efe Genc, an independent software engineer building open-source developer tools. I write about engineering, experiments, and the things that happen when software meets actual human beings.
This first appeared on my site, efegenc.me. If you maintain a project, I would like to hear whether a short reminder like this has worked for you, or whether you think it is the wrong move.
Top comments (0)