Why I Still Trust Plain Text

At some point, things got complicated.

Applications became platforms. Config files turned into binary blobs. Simple files were swallowed into opaque databases. Settings disappeared behind layers of abstraction that no one asked for. Now, you can open a "text editor" that doesn't show where your files are saved.

So I stopped.

I stepped back, looked at my system, and asked myself one question:

What do I actually trust?

The answer wasn't software.
It wasn’t cloud services.
It wasn't frameworks, plugins, or extensions.

It was plain text.

I trust a .conf file because I can read it.
I trust a shell script because I can step through it.
I trust logs in /var/log because they’re just lines on a screen—no formatting, magic, or marketing.

Plain text is boring. That’s what makes it great.

We live in a world obsessed with “experience.”
Apps don’t just work — they onboard you.
Settings come in wizards.
Data gets exported in “rich formats” no human wants to read.
Everything is an interface wrapped in an abstraction wrapped in a distraction.

And yet, I keep coming back to files.

When I want to remember something, I don’t need Evernote.
I just opened ~/notes/todo.txt.

I don’t open a control panel when I want to configure something.
I open a file.
Edit. Save. Done.

Plain Text Lasts

A plain text file can live on a USB stick for 20 years and still work.

You can read it on Linux, Windows, BSD, or even a phone.
If it can display characters, it can read your file.
No software version is required. No license keys. No 30-day trials.

Structured formats like JSON, YAML, or even old-school INI give you hierarchy, clarity, and consistency — with none of the overhead.

They scale down.
They degrade gracefully.
They don’t need a desktop environment or a runtime.

They work.

Tools That Do One Thing

When your data lives in plain text, you can use tools that have been battle-tested for decades.

Want to filter lines? Use grep.
Want to count something? Use wc.
Want to batch-edit? sed or awk has your back.

These aren’t “developer tools.”
They’re survival tools.

A complex UI can hide bugs.
A broken config file fails loudly — and that’s a good thing.
It means you know where you stand.

You don’t need an app to “manage” your files.
You need a terminal and some muscle memory.

No Hidden Metadata

One of the best things about plain text is what it doesn’t have.

It doesn’t track when you read it.
It doesn’t phone home.
It doesn’t store “project IDs,” “revision hashes,” or “usage analytics.”

It’s not tied to an account.
It doesn’t accidentally sync to the cloud.
It doesn’t come with version lock-in.

It’s just… content.
Yours.

You Don’t Need Fancy

I know what you’re thinking: “But what about features? What about UX?”

I’ve used fancy tools.
I’ve written Markdown in Electron-based editors that eat half my RAM.
I’ve configured apps that sync beautifully across devices—until the company dies, pivots, or decides syncing is a premium feature.

And every time something broke, I was left with nothing.
No backups. No exports. No plan.

That doesn’t happen with ~/projects/notes.txt.
It’s not pretty — but it’s yours.

The Terminal Is Not a Punishment

People treat the terminal like a punishment — something you use only when things go wrong.

But if you embrace it, you’ll find it’s the only part of your system that doesn’t lie.

There’s no loading spinner.
No, “Just a moment…”
No buttons that don’t do what they say.

Just a prompt. A tool. A file.
Your input, your command, your result.

It’s the closest thing to honest computing I’ve found.

Structured Files Are Portable Ideas

Here’s the real secret: plain text isn’t just about simplicity — it’s about freedom.

When you write things down in open formats, you create ideas that outlast software.

Your dotfiles are portable behavior.
Your config files are documentation.
Your notes are future-proof — not because you saved them in five formats, but because you didn’t hide them behind one.

Plain Text in the Real World

I use plain text to manage my to-do list. It's not some productivity app with badges, AI summaries, and deep calendar integrations—just a simple todo.txt.

My calendar is a .ics file. My RSS feeds live in a flat config list. My blog is powered by Markdown and a static site generator. Even this article started as a .txt file in Vim.

When I onboard a new system, I don’t start from scratch.
I copy my dotfiles.
I pull down a Git repo.
I edit a few lines — and I’m home.

It’s not about avoiding modern tools. It’s about choosing tools that won’t break just because the developer lost interest or the company pivoted.

When Apps Get in the Way

Ever tried to export your notes from a modern note-taking app?
Good luck finding the one format it supports — and praying the formatting survives.

Or try changing one thing in a modern CMS without breaking five dependencies?

Or opening your photos only to realize they’ve been “optimized” into some proprietary format?

That happens when we stop asking, “What is this doing under the hood?”

We trust too easily.
We accept too much abstraction.
And we forget that the more convenient the interface, the more we lose when it’s gone.

Plain text doesn’t lock you in.
It doesn’t die with a company or a subscription model.
It doesn’t auto-update into something you don’t recognize.

It remains what it always was:
A file. Your file.

Simple Isn’t Basic. It’s Durable.

Some people think using plain text means settling for less, that it means you're not serious, and that you're avoiding "real" tools.

But I’ve seen entire teams paralyzed because a plugin broke during an update. I’ve seen data trapped in proprietary formats with no way out. I’ve watched colleagues rebuild environments from scratch because the GUI config panel didn't generate reproducible output.

Simplicity isn't about weakness. It's about durability.

When your data lives in simple formats, you gain resilience. You gain clarity. You gain time.

Complex systems break in complex ways. Simple systems fail loudly, cleanly, and understandably. That alone is worth more than the shiniest interface.

Keep It Simple

Simplicity is power.

Plain text remains reliable when systems become overly complex, fragile, and dependent on external factors. Files don’t disappear, auto-update, or become obsolete because of shifting trends.

Choose tools that bring clarity, not confusion. If you can replace a complicated process with a single file, do it — and take back control of your system.

Ask yourself:

Keep it simple.
Keep it yours.
Keep it plain.