How I Track GitHub Releases, Security Advisories, and Tech News Without Opening 10 Apps
I maintain a dozen production services. Each one depends on frameworks, libraries, and infrastructure tools that release updates on their own schedule. Some announce breaking changes on their blog. Some push security patches to GitHub with no fanfare. Some post changelogs that bury critical fixes between cosmetic tweaks.
Missing a security advisory costs hours of firefighting later. Missing a breaking change in a dependency costs even more. But checking every project's GitHub, blog, and changelog every morning? That doesn't scale past three projects.
Here's the system I built to solve this. It took about an hour to set up and it runs on autopilot.
The information sources developers actually need
Before getting into tools, let's map out where developer-relevant information actually lives.
GitHub releases and tags. Every public GitHub repo has an Atom feed for releases. The URL pattern is https://github.com/{owner}/{repo}/releases.atom. This covers version bumps, changelogs, and security patches for any library you depend on.
Security advisories. GitHub Advisory Database publishes feeds. NIST NVD has feeds for CVEs. If you use specific ecosystems, their security mailing lists often have RSS equivalents too.
Framework and language blogs. The official blogs for React, Next.js, Go, Rust, Python, Node.js, and most major frameworks all have RSS feeds. These are where breaking changes and migration guides get announced first.
Tech news that affects your stack. Hacker News, Lobsters, specific subreddits (r/golang, r/rust, r/node), and a handful of independent bloggers. High volume, low signal-to-noise ratio. Most of it doesn't apply to you on any given day.
Competitors and adjacent tools. If you work on a product, you probably want to know when competing tools ship features or change pricing. Their blogs and changelogs have feeds too.
The problem isn't finding these sources. The problem is that they generate hundreds of items per day across dozens of feeds, and maybe 5 of those items actually matter to you.
Why RSS readers alone don't solve this
I used Feedly for years. It's good at what it does. You subscribe to feeds, organize them into folders, and read them when you're ready.
The issue is "when you're ready" never comes for the feeds that matter most. I'd open Feedly, see 800+ unread items, skim the top few, and close it. The security advisory buried at item 347 would sit there until I either stumbled across it or learned about the vulnerability from a production incident.
RSS readers are built for reading. They aggregate content and present it in a nice interface. What I needed was something that reads for me, filters out the noise, and taps me on the shoulder when something actually requires my attention.
Feedly has an AI assistant called Leo that can prioritize topics, which helps. But getting those prioritized results pushed to Slack or Teams requires their Enterprise plan, which is priced for organizations, not individual developers. Inoreader has similar filtering capabilities at $9.99/month, plus paid AI add-ons. Both are solid readers. Neither solved my core problem: I don't want to open a reader. I want the important stuff to come to me.
Self-hosted options like FreshRSS and Miniflux give you complete control and cost nothing beyond server time. I ran Miniflux for a while. It's excellent for reading. But it doesn't filter. You still have to do the scanning yourself.
The setup that actually works
My current system has three layers.
Layer 1: Direct feeds for low-volume, high-priority sources.
These go straight into my RSS reader. I use about 15 feeds here: the official blogs for my core dependencies, a few authors whose posts I always read, and the release feeds for the 5 most critical libraries in my stack. Total daily volume: maybe 10 to 15 items. I scan these over coffee. Takes 5 minutes.
Layer 2: AI-filtered feeds for high-volume sources.
This is where SignalHub fits in. I dump everything noisy here: Hacker News, three subreddit feeds, a dozen GitHub release feeds for secondary dependencies, security advisory feeds, and a handful of tech news blogs.
The total input is probably 200+ items per day. I wrote a filter in plain English: "Security vulnerabilities in JavaScript, Go, or Python ecosystems. Major version releases of frameworks I use (list). Significant funding or acquisition news for developer tools. New open source projects that solve monitoring, observability, or notification problems. Skip: opinion pieces, tutorial rehashes, Show HN posts for unrelated products, anything behind a paywall."
SignalHub's AI evaluates every item against that filter and forwards what passes. On a typical day, 5 to 8 items make it through. Each one arrives in my Slack with a short summary so I can decide in seconds whether to click through.
The key thing: I didn't have to learn a query language or build boolean expressions. The filter is just a paragraph of English describing what I care about. When my stack changes, I update the paragraph.
Layer 3: Weekly digest for everything else.
Some feeds are interesting but not time-sensitive. Conference talk recordings, long-form essays, podcast episodes. These sit in a separate group in my reader. I glance at them on Sunday mornings. No pressure, no unread count anxiety.
The feeds most developers don't know about
While building this setup, I found several RSS feeds that are surprisingly useful but rarely mentioned.
GitHub repo discussions. https://github.com/{owner}/{repo}/discussions.atom gives you a feed of new discussions. Useful for tracking community questions and feature requests for tools you maintain or use.
Reddit subreddits. Any subreddit has an RSS feed at https://www.reddit.com/r/{subreddit}/.rss. The posts from r/selfhosted, r/devops, and r/programming are solid signal if you filter the noise.
YouTube channels. Every YouTube channel has a hidden RSS feed. The URL format is https://www.youtube.com/feeds/videos.xml?channel_id={CHANNEL_ID}. You can find the channel ID in the page source. Useful for tracking conference channels and tech YouTubers without getting sucked into the recommendation algorithm.
npm, PyPI, and crate updates. Services like libraries.io provide feeds for package updates across ecosystems. If you want to know when a library you depend on pushes a new version, this is cleaner than watching GitHub releases.
Hacker News front page. https://hnrss.org/frontpage gives you the front page as RSS. There are also feeds filtered by points threshold, like https://hnrss.org/frontpage?points=100 for posts with 100+ points. Great for cutting through the noise.
What changed after switching
Before: Open Feedly, see 800+ unread, feel overwhelmed, skim 20 items, close it. Check GitHub manually for 3 repos. Miss the security advisory. Read about it on Twitter two days later. Scramble to patch.
After: Slack pings me with 5 to 8 filtered items during the day. Each has a summary. I click the ones that matter (usually 2 or 3). Security advisories hit my Slack within the hour they're published. I still open my reader for the 15 low-volume feeds over morning coffee. Weekend reading sits in a separate group with no guilt.
Total time spent on information consumption went from a scattered 45 minutes across multiple apps down to a focused 15 minutes. More importantly, I stopped missing critical updates.
The stack
RSS reader (Layer 1 and 3): Whatever you prefer. Feedly, Miniflux, FreshRSS, Inoreader, Folo. Pick based on cloud vs. self-hosted preference.
AI filter + notifications (Layer 2): SignalHub. Free tier covers 1 tracker with 5 sources and all notification channels (Slack, Discord, Telegram, email, etc.). Paid plans start at $4.99/month for more sources.
Notification target: I use Slack. You could use Discord, Telegram, email, ntfy, Pushover, or webhooks. SignalHub supports 10+ channels on every plan.
Start small
Pick the 5 GitHub repos you care about most. Grab their release feeds. Add a few noisy sources (Hacker News front page, one or two subreddits). Set up a filter describing what matters to you.
Run it for a week. If you catch something important that you would have missed otherwise, expand from there.
The goal isn't to read more. It's to stop worrying about what you're missing while reading less.