You don’t have to accept the trade-offs others make for you. The tools for efficiency and integration still exist—they just require the will to use them.

It started with a simple comparison. I found an application I used daily: as a native .deb package, it was 50MB. As a Flatpak, it was 1.5GB. Thirty times larger.

This wasn’t an outlier—it was the new normal. Snap and Flatpak packages were ballooning across my system, each bringing duplicate copies of runtimes, libraries, and desktop environments I already had. I chose Cinnamon as my desktop, yet I was downloading GNOME, KDE, and Freedesktop runtimes with every other app.

The math horrified me: multiply that 1.4GB of waste by just 10 million Linux users, and you get 14 petabytes of unnecessary storage consumption. For what? Convenience?

The Developer’s Dirty Secret

The justification for this waste was always the same: “Developers don’t want to package for multiple distributions.” Universal packages solve their problem—by making it our problem.

But I realized something: AI changes this equation completely. What if a developer could point an AI at their source code and say, “Generate native packages for Debian, Ubuntu, Fedora, and Arch”? Suddenly, the “packaging burden” excuse evaporates.

Yet the bloat continues. Why?

The Real Agenda

The more I looked, the clearer it became. Universal packaging creates platform power. Snap is controlled by Canonical. Flathub becomes the de facto app store. The traditional distribution maintainers—the curators who ensure system integration and efficiency—get sidelined.

We’re witnessing the industrialization of the Linux desktop. The wild, customizable, integrated system that attracted me to Linux is being turned into a predictable platform for app deployment. “Easy” means someone else is in control.

This was the same trade-off that made Windows dominant: surrender control for convenience. But wasn’t Linux supposed to be different?

My Awakening: The Source Is Still There

Then it hit me: I don’t have to accept this. The source code for virtually everything is still available. The compilers are still there. The traditional package management system still works perfectly.

I wasn’t experienced. I never enjoyed reading dense manuals (RTFM). But I realized: AI could be my bridge.

The Experiment

I started small. neofetch, the fun system info tool. I cloned the repository and asked an AI:
“I’m on Debian with Cinnamon. How do I build this from source?”
The AI gave me clear steps:

git clone https://github.com/dylanaraps/neofetch.git
cd neofetch
# Check for dependencies
sudo apt install make gcc
make
sudo make install

Two minutes later, I had a perfectly compiled program, Neofetch, using my system’s libraries. No runtime. No sandbox. No bloat.

The Pattern Emerges

Each project taught me something:

• For htop: I needed libncurses-dev
• For bat: I needed cargo (Rust’s package manager)
• Each error message became a learning opportunity: “Missing header file?” → install the corresponding -dev package

The secret weapon was my package manager’s build-dep command:

sudo apt build-dep <package-name>

This single command installs all development dependencies for a package. Suddenly, building from source wasn’t an arcane art—it was a repeatable process.

The Transformation

Within weeks, my system transformed:

• Storage reclaimed: GBs of duplicate runtimes gone
• Performance improved: Native binaries using my optimized libraries
• Integration perfected: Every app matched my Cinnamon theme flawlessly
• Knowledge gained: I understood my system’s architecture for the first time

Most importantly, I broke free from the bloat cycle.

The New Workflow

Here’s my practical approach today:

1. Check if a native package exists in my distro’s repositories first
2. If not, clone and build with AI assistance for dependency help
3. Keep a build script for each manually installed program
4. Contribute back by packaging for my distribution when possible

The tools have evolved to help us:

• checkinstall creates a .deb from your compiled software
• alien converts between package formats
• AI assistants explain errors in plain language

The Bigger Picture

This isn’t just about saving disk space. It’s about preserving what makes Linux special.

The push toward universal packages represents a fundamental shift:

• From: Integrated, efficient, curated systems
• To: Containerized, predictable, platform-controlled ecosystems

But we have a choice. The source code isn’t going anywhere. The compilers aren’t disappearing. The knowledge of how systems actually work remains valuable—perhaps more valuable than ever as abstraction layers multiply.

Your First Step

Don’t start with a massive application. Start tonight with one of these:

bash

# Choose one:
git clone https://github.com/aristocratos/btop.git  # Better system monitor
git clone https://github.com/sharkdp/bat.git        # Better cat
git clone https://github.com/junegunn/fzf.git       # Fuzzy finder

Follow their README. Use AI when you get stuck. You’ll be surprised how quickly you learn.

The Realization

The waste of universal packaging isn’t a technical necessity—it’s a choice. A choice made by those who value developer convenience and platform control over user efficiency and system integrity.

But we can make a different choice. We can reclaim the efficiency, integration, and understanding that drew us to Linux in the first place.

The tools are there. The source is there. The only question is, will you build it yourself?

Start with one program. Feel the satisfaction of running something lean, integrated, and truly yours. That’s the Linux way—and it’s waiting for you to rediscover it.