Reclaiming Information With RSS, Wallabag, And A Phone

How to stop letting algorithmic feeds decide what you read, and how to build a small personal pipeline for intentional information consumption.


The Modern Information Problem

The internet did not run out of good information. The problem is that most of us no longer control the sources, order, rhythm, or incentives behind the information we consume.

When we open a social network, a video app, or a news aggregator, we usually do not start from a question like:

What do I want to learn today?

We start from a feed.

That feed is not neutral. It is a ranking system optimized by someone else. It may optimize for engagement, advertising inventory, session duration, outrage, novelty, or whatever metric best serves the platform. Sometimes the result is useful. Often the result is that our attention gets pulled through a sequence of unrelated items that were selected for us.

The subtle issue is not only misinformation. It is loss of agency.

Platform-controlled consumption

  +------------------------------+
  | You open the app             |
  | platform-owned surface       |
  +---------------+--------------+
                  |
                  v
  +------------------------------+
  | Platform selects sources     |
  | allowed or incentivized      |
  +---------------+--------------+
                  |
                  v
  +------------------------------+
  | Algorithm ranks content      |
  | engagement decides priority  |
  +---------------+--------------+
                  |
                  v
  +------------------------------+
  | You react and scroll         |
  | attention becomes feedback   |
  +---------------+--------------+
                  |
                  v
  +------------------------------+
  | Platform learns              |
  | retention loop improves      |
  +------------------------------+

Platform-controlled consumption: the reader reacts to a feed designed elsewhere.

This loop is convenient, but it moves control away from the reader. The platform decides what deserves the top of the page. The user mostly reacts.


Inverting The Control

RSS gives us a simple way to invert that relationship.

Instead of asking a platform to decide what we should see, we choose the sources ourselves and subscribe to their feeds. A feed reader checks those sources and brings new items into one place.

The mental model changes from "show me what is trending" to "show me what changed in the sources I trust".

Reader-controlled consumption

  +------------------------------+
  | You choose sources           |
  | blogs, journals, institutions|
  +---------------+--------------+
                  |
                  v
  +------------------------------+
  | RSS reader checks them       |
  | updates arrive unranked      |
  +---------------+--------------+
                  |
                  v
  +------------------------------+
  | You select what matters      |
  | not everything is reading    |
  +---------------+--------------+
                  |
                  v
  +------------------------------+
  | Wallabag archive             |
  | save good links for later    |
  +------------------------------+

Reader-controlled consumption: the reader designs the input surface.

This is a small technical change with a large behavioral effect.

The user becomes the editor. The feed reader becomes a delivery mechanism. The read-it-later tool becomes a personal library.


What RSS Actually Gives You

RSS is not fashionable, but it is extremely useful. It is just a machine-readable list of recent posts from a website.

A site publishes a feed:

https://example.com/feed.xml

Your reader periodically checks it and shows new entries.

That means RSS gives you:

  1. Source control: you decide which sites are allowed into your information diet.
  2. Chronological visibility: you can see what was published without algorithmic ranking.
  3. Portability: feed lists can usually be exported as OPML and moved to another app.
  4. Low friction: no need to visit twenty websites manually.
  5. Calm consumption: fewer notifications, recommendations, and engagement traps.

RSS is not a complete answer to information quality. You can still subscribe to bad sources. But the important part is that the subscription choice is explicit.


A Practical Phone Workflow

For day-to-day reading, the phone is usually where this system needs to work. If the workflow only works on a laptop, it will probably not survive normal life.

One simple Android setup is:

  +------------------+      +------------------+      +------------------+
  | RSS feeds        | ---> | Reader You       | ---> | Android share    |
  | blogs, news,     |      | browse updates   |      | sheet            |
  | institutions     |      | on the phone     |      | send selected    |
  +------------------+      +------------------+      +--------+---------+
                                                                  |
                                                                  v
                                                        +------------------+
                                                        | Wallabag app     |
                                                        | capture the URL  |
                                                        +--------+---------+
                                                                  |
                                                                  v
                                                        +------------------+
                                                        | Private Wallabag |
                                                        | backend          |
                                                        +------------------+

A phone-first workflow: scan in Reader You, save with Wallabag, read later from your own backend.

Reader You is an Android RSS reader. It gives you a clean place to follow feeds from your phone. When an article looks worth keeping, you use the Android share menu and send it to the Wallabag app.

Wallabag then stores the article in your own backend. Later you can read it in a distraction-free interface, tag it, archive it, or search it.

The key separation is this:

Discovery happens in the RSS reader.

Long-form reading happens in Wallabag.

Storage belongs to your backend.

That separation prevents your feed reader from becoming a pile of unread tabs. The reader is an inbox. Wallabag is the library.


Setting Up Reader You

The exact screens may change over time, but the flow is usually simple:

  1. Install Reader You from your preferred Android app source.
  2. Open the app and add RSS feeds manually, or import an OPML file.
  3. Organize feeds into folders such as Economics, Technology, Local, or Personal Blogs.
  4. Read the feed list as an inbox, not as an infinite stream.
  5. Share only the articles that are worth deeper reading to Wallabag.

A useful mental rule is to keep Reader You light. Do not try to read everything there. Use it to scan headlines, opening paragraphs, and sources.

If an article deserves attention, save it.


Setting Up Wallabag With A Private Backend

Wallabag has two parts in this workflow:

  1. The backend server where articles are stored.
  2. The Android app that receives links from the share sheet.

The Android setup looks like this:

  1. Install the Wallabag Android app.
  2. Open the app settings.
  3. Configure the server URL, for example https://wallabag.example.com.
  4. Log in with your Wallabag user.
  5. Test saving a page from the browser or from Reader You through the Android share sheet.

The full saving path becomes:

  +------------------------------+
  | Interesting item appears     |
  | in Reader You                |
  +---------------+--------------+
                  |
                  v
  +------------------------------+
  | Tap share                    |
  | Android opens share sheet    |
  +---------------+--------------+
                  |
                  v
  +------------------------------+
  | Choose Wallabag              |
  | Wallabag app receives URL    |
  +---------------+--------------+
                  |
                  v
  +------------------------------+
  | Send to backend              |
  | authenticated Wallabag API   |
  +---------------+--------------+
                  |
                  v
  +------------------------------+
  | Store readable copy          |
  | article is parsed and saved  |
  +------------------------------+

Saving is a deliberate action, not another infinite queue.

The result is that useful links stop being scattered across chat messages, browser tabs, bookmarks, and social feeds. They land in one archive.


The New Information Pipeline

The final system is small, but it changes the default behavior.

Before: platform push                 After: reader pull

  Social app / platform                 Chosen sources
           |                                  |
           v                                  v
  Algorithmic feed                     RSS reader
           |                                  |
           v                                  v
  Attention capture                    Intentional selection
           |                                  |
           v                                  v
  Maybe remember later                 Wallabag archive

The shift is from platform push to reader pull.

This is the paradigm shift:

From: platforms push content into your attention.

To: you pull updates from selected sources.

It does not require rejecting the modern internet. It requires creating a layer between you and the attention market.


Reducing Curation Cost With LLMs

There is one real problem with RSS: building a good feed list takes time.

You need to know which sites publish useful feeds, which sources are active, which ones are too noisy, and which ones are worth following. This setup can fail if the first step feels like a research project.

This is where LLMs are useful. Not as final authorities, but as curation assistants.

You can ask an LLM to propose a starter feed list for a topic, then manually inspect the result. The model saves time by generating candidates. You keep control by choosing what enters your reader.

The pattern is:

  +------------------------------+
  | Ask                          |
  | LLM proposes candidate feeds |
  +---------------+--------------+
                  |
                  v
  +------------------------------+
  | Verify                       |
  | check URLs and source quality|
  +---------------+--------------+
                  |
                  v
  +------------------------------+
  | Import                       |
  | add survivors to Reader You  |
  +---------------+--------------+
                  |
                  v
  +------------------------------+
  | Prune                        |
  | remove noisy feeds after use |
  +------------------------------+

Use LLMs to accelerate discovery, not to outsource judgment.

The important word is candidate. Do not blindly import everything. The goal is faster discovery, not automatic trust.


Example Prompt: Economic RSS Feeds

Here is an example prompt for creating a starter list of economics feeds:

Create a curated RSS feed list for following economics and macroeconomic news.

Requirements:
- Prefer official institutions, central banks, research organizations, and high-quality analysis.
- Include a mix of global macro, European economy, US economy, monetary policy, development economics, and markets.
- Return the result as a table with: source name, category, RSS URL, why it is useful.
- Only include sources that are likely to have public RSS or Atom feeds.
- Avoid social media accounts, newsletters without RSS, and low-quality SEO sites.
- Keep the list to 20 feeds.
- At the end, provide an OPML file that I can import into an RSS reader.

You can make the prompt more specific:

Focus on Europe, inflation, productivity, sovereign debt, ECB policy, and long-form economic analysis.
Avoid daily market noise unless the source explains context well.

The LLM might suggest sources like central bank publications, IMF blogs, World Bank blogs, OECD updates, think tanks, economics blogs, and newspaper economics sections.

Your job is to verify them:

  1. Open the RSS URL in a browser and check that it returns XML or a valid feed.
  2. Add it to Reader You.
  3. Watch the next few days of posts.
  4. Remove sources that are too noisy, duplicated, biased in unhelpful ways, or inactive.

This turns feed curation into an iterative process instead of a one-time perfect decision.


Example OPML Shape

Many RSS readers can import OPML. OPML is just an XML file containing feed subscriptions.

An LLM can generate something like this:

<?xml version="1.0" encoding="UTF-8"?>
<opml version="2.0">
  <head>
    <title>Economics RSS Starter Pack</title>
  </head>
  <body>
    <outline text="Economics">
      <outline text="IMF Blog" type="rss" xmlUrl="https://www.imf.org/en/Blogs/RSS" />
      <outline text="World Bank Blogs" type="rss" xmlUrl="https://blogs.worldbank.org/rss.xml" />
      <outline text="OECD News" type="rss" xmlUrl="https://www.oecd.org/newsroom/publicationsdocuments/rss.xml" />
    </outline>
  </body>
</opml>

Treat the generated OPML as a draft. Feed URLs can change, and LLMs can hallucinate plausible URLs. Verify before relying on them.


Operating The Feed Like A Garden

The best feed list is not the largest one. It is the one you can actually use.

Think of it as a garden:

Add sources slowly. Remove noisy feeds. Group by topic. Watch unread count pressure. Keep the signal high.

If a source creates anxiety or fills your reader with low-value posts, remove it. If two sources repeat the same wire content, keep the better one. If an author consistently teaches you something, keep them.

The goal is not completeness. The goal is a high-signal personal information environment.


Why Wallabag Matters In This System

RSS helps with discovery, but discovery is not the same as reading.

Without a read-it-later layer, RSS can become another inbox. Wallabag fixes that by giving selected articles a second stage.

Layer Question
RSS reader What is new?
Wallabag What is worth reading properly?
Archive What was worth keeping?

Separate discovery, reading, and long-term storage.

This reduces pressure while scanning feeds. You do not need to read everything immediately. You only need to decide whether an item deserves future attention.

That small change makes the feed sustainable.


Focus Reading On An E-Reader

The phone is excellent for discovery, but it is not always the best device for focused reading. It has notifications, messaging apps, browser tabs, and the same attention traps we are trying to avoid.

A useful final step is to move long-form reading to an e-reader.

One practical setup is an e-reader running KOReader with the Wallabag plugin enabled. KOReader is an open-source document reader available for many e-reader devices. Its Wallabag integration can connect to your Wallabag backend, download saved articles, and let you read them in an e-ink environment.

The device roles become clearer:

Device or service Role
Phone with Reader You Fast discovery and triage.
Android share sheet and Wallabag app Capture links with minimal friction.
Wallabag backend Store, parse, tag, and synchronize articles.
E-reader with KOReader Slow, focused reading away from the feed.

The Wallabag plugin turns the e-reader into a calm reading endpoint:

Wallabag backend -> KOReader Wallabag plugin -> E-reader article list -> Focused reading

The integration usually follows this shape:

  1. Install KOReader on the supported e-reader.
  2. Open KOReader's Wallabag plugin or Wallabag settings.
  3. Configure the Wallabag server URL, for example https://wallabag.example.com.
  4. Authenticate with your Wallabag user credentials or token, depending on the plugin version.
  5. Synchronize articles from the Wallabag backend.
  6. Read saved articles on the e-reader and archive them when done.

This creates an important behavioral boundary. The phone is allowed to be an inbox. The e-reader is not an inbox. It is where selected articles become actual reading.

The mental model becomes:

Stage Question Tool
Discovery What is new? Reader You
Capture What deserves later attention? Wallabag Android app
Storage What should be preserved and synced? Wallabag backend
Reading What am I reading now? KOReader on an e-reader

That last step matters. It turns Wallabag from a link bucket into a reading pipeline.


Final Picture

With the e-reader added, the complete loop looks like this:

You define interests
        |
        v
Curated RSS sources
        |
        v
Reader You on phone
        |
        v
Share good links only
        |
        v
Wallabag Android app
        |
        v
Private Wallabag backend
        |
        v
KOReader Wallabag plugin
        |
        v
E-reader article library
        |
        v
Focused reading away from the feed

The final loop restores ownership of discovery, selection, storage, synchronization, and reading time.

In this design, every piece has a job:

Layer Responsibility
RSS sources Publish updates from places you chose.
Reader You Let you scan new information on the phone.
Wallabag app Capture links through Android sharing.
Wallabag backend Store, clean, and synchronize articles.
KOReader plugin Pull saved articles onto the e-reader.
E-reader Provide a quiet place for focused reading.

The old internet reading model asks you to trust a feed you did not design.

This model asks you to design a feed you can trust enough to improve over time.

That is the real benefit of RSS and self-hosted read-it-later tools. They do not merely save articles. They restore some control over what gets the chance to enter your mind.