Why I Still Value IRC and Plain Text

At 3:47 AM on a Tuesday in 2019, Link11's entire scrubbing infrastructure started dropping packets at an alarming rate. Our monitoring lit up red. The on-call rotation spun into action.

The first engineer to respond opened Slack. It took 8 seconds to load. The rich text editor hung. The "typing..." indicator froze. He switched to IRC. Connected in 400 milliseconds. The war room was already running.

By the time Slack finally rendered the channel, we'd already identified the attack vector, rerouted traffic through alternate nodes, and begun the mitigation. IRC didn't fail us. It never does.

The Tyranny of Features

Modern communication tools are built for peacetime. They prioritize presence indicators, emoji reactions, threading, rich embeds, and seamless integrations. These features are delightful—until they become liabilities.

Slack, Teams, Discord—they're all optimized for the 99% use case: casual conversation, lightweight coordination, the slow drip of daily work. They work beautifully when nothing is on fire.

But when systems are failing, when every second counts, when you need to coordinate a distributed team across continents under high stress, these tools collapse under their own weight.

• Startup time: 5-10 seconds to launch and authenticate
• Network overhead: Hundreds of KB just to render a text channel
• Failure modes: WebSocket drops, token refresh loops, modal dialogs blocking input
• Resource consumption: 500MB+ RAM for a single Electron app

IRC uses 2MB of RAM. It connects in under a second. It fails gracefully. If the network is spotty, messages queue and deliver when connectivity returns. There's no authentication dance, no loading spinner, no "please update to continue."

Plain Text as a Protocol

Plain text isn't just about minimalism—it's about interoperability and longevity.

I can parse a plain text log from 1991 with the same tools I use today. I can pipe it through grep, awk, sed, and jq. I can version it in Git. I can diff it. I can email it. I can read it on a terminal over SSH when the GUI has crashed.

Compare that to proprietary formats:

• Slack's export format is a labyrinth of JSON files with opaque user IDs and broken links
• Microsoft Teams stores messages in a database only accessible through their API (when it's up)
• Every tool has its own export/import story, none of which work reliably at scale

Plain text doesn't have this problem. It's the universal interface. It doesn't lock you in. It doesn't require a 200MB Electron app. It just works.

The Beauty of Constraints

IRC's limitations are features, not bugs:

• No rich media: Forces clarity. You can't hide behind a meme or a screenshot when you need to explain a technical issue. You have to write clearly.
• No presence indicators: People are either there or they're not. No "away" status, no "focus mode," no performative availability signaling.
• No read receipts: Messages exist in the channel. If you see it, great. If you don't, someone else will. No guilt, no pressure.
• No threads: Everything is linear and chronological. You can't fragment the conversation into nested sub-discussions that nobody monitors.

These constraints make communication faster and more resilient. There's less to load, less to break, less to distract.

When Slack Is the Right Tool

I'm not anti-Slack. We use it at Link11 for daily operations, project coordination, and casual conversation. It's excellent for asynchronous work, for teams spread across time zones, for integrating with GitHub, Jira, and monitoring tools.

But when the stakes are high, when the system is degraded, when you need to coordinate incident response under pressure—we drop to IRC.

Peacetime tools vs. wartime tools.

Slack is peacetime. IRC is wartime. You need both. But you need to know which one to reach for when the alarms sound.

The Broader Lesson: Resilience Over Features

This principle extends beyond communication tools:

• Postgres over MongoDB: Boring, battle-tested SQL beats schemaless flexibility when you need ACID guarantees.
• Static site generators over CMS platforms: When your marketing site goes down because WordPress hit a race condition, you wish you'd just committed HTML to Git.
• Nginx over API gateways: A reverse proxy that's been hardened for 20 years beats a new service mesh with 1,000 knobs.

The pattern is clear: simple, stable, and boring wins when reliability matters.

Plain Text in a Rich Media World

The modern web is built on the assumption that more is better. More fonts, more colors, more animations, more interactivity. The assumption is that users want richness.

But richness has a cost:

• It increases load time
• It increases attack surface (XSS, CSRF, client-side injection)
• It increases cognitive load
• It increases failure modes

Plain text strips all of that away. What you're left with is signal.

When I'm debugging a BGP route leak at 4 AM, I don't need syntax highlighting or a dark mode toggle. I need the raw data, fast, with zero ceremony.

The Future Isn't Richer—It's Lighter

The pendulum is starting to swing back. We're seeing a return to minimalism:

• Linear: Opinionated, fast, keyboard-first issue tracking
• Hey: Email that strips the cruft and focuses on the message
• Obsidian, Notion (local-first mode): Plain text or Markdown as the canonical format, rendered optionally

Even in the AI era, the best tools treat plain text as the source of truth. LLMs train on it. APIs consume it. Logs produce it. Configuration lives in it.

The richness is a rendering layer—optional, configurable, and disposable. The data underneath is durable, portable, and timeless.

Why I'm Betting on Boring

I've spent 20 years in cybersecurity and infrastructure. I've seen tools come and go. The ones that survive aren't the ones with the most features—they're the ones that never fail when you need them.

IRC is 35 years old. It's older than the web. It has no venture funding, no product roadmap, no growth team. It just exists, humming along, doing one thing well: moving text from one machine to another, instantly, reliably, with zero ceremony.

That's not nostalgia. That's engineering.

When the next major outage hits, when your monitoring dashboard is unresponsive, when the Slack workspace won't load—you'll understand why I keep an IRC client running in a tmux session, 24/7, waiting for the moment when everything else fails.

Because plain text doesn't crash. It doesn't hang. It doesn't need an update. It just works.