For the last few years, I've prided myself on being a fast pull request reviewer. Lately, that's getting harder.
Agentic coding is on the rise, PRs are coming in faster, and sometimes even from non-technical contributors. Some big wins, some new problems.
My old workflow was simple: review whatever was highest priority as soon as the GitHub notification came in. That kept the team moving and kept me fully in touch with the codebase. It doesn't scale the same way anymore. More often than I'd like, I'll realize a week has passed and some PR has been sitting on me the whole time.
So I'm looking into ways to address that.
Happy PRs
I built a little widget, Happy PRs, that lives in the macOS menubar and summarizes the PRs that need my attention. It sorts them into three buckets:
- Needs your approval: I'm on the reviewer list and no one has approved the current HEAD yet. These are blocking on me.
- Wants your approval: same as above, but someone else has already approved. Nice to have rather than blocking.
- Mentions you: I'm
@-mentioned in the body, a comment, or a review thread. Additive with the other buckets, because a discussion might need me even when my approval doesn't.
The app also tracks your own PRs (approved, conflicting, unresolved threads, awaiting reply), shows recently merged PRs, and surfaces system notifications for every event type. The menubar badge shows incoming, your-PR, and unread counts at a glance.
The initial value was built in a few hours, and I really appreciate that it's so easy to produce something that just does exactly what you need without having to wrestle with it. The real polish came from iteration. Since that first session the tool has grown into something I can genuinely recommend to any developer who reviews a lot of PRs.
Swift itself was a nice surprise along the way. The algebraic types and procedural style reminded me a lot of Rust in a good way, with enums that carry associated values, exhaustive pattern matching, and Result-style error handling, but without a borrow checker to argue with. It uses ARC (automatic reference counting) instead, inherited from Objective-C and closer in spirit to C++'s std::shared_ptr than to Rust's opt-in Rc/Arc. Memory just quietly works out, at the cost of some runtime overhead and the occasional retain cycle to keep an eye on.
The feedback loop
There's something a little magical about this. The same thing that's causing my problem (more code shipping faster because of AI) is also what gave me the tool to address it. I wouldn't have taken the time to build this a year ago. It would have been a weekend project, and it wasn't important enough to spend a weekend on.
The marginal cost of building a small, personal tool has fallen far enough that the calculation flips. Anything I find myself wanting for two consecutive days is worth a few hours now, and a few hours means it actually gets built instead of sitting on the mental backlog forever.
Such an exciting time to be a software engineer. Curious what other people are doing to manage PR load in the agentic-coding era.