DEV Community: Kord Campbell (kordless)

The Em Dash Isn't the Tell — Your Comment Is

Kord Campbell (kordless) — Tue, 07 Jul 2026 21:39:05 +0000

Two weeks ago one of my outdoor cats bit me. She's fine — healthy, pregnant, and deeply offended that I picked her up, but she needed flea medicine and I needed to confirm the pregnancy. (If anyone wants a kitten, I know a grumpy lady who has some.) My pinky swelled up, and typing went from "mildly error-prone" to "not happening."

So I dictated this post. If you've ever looked at raw voice transcription, you know what that produces: one giant unpunctuated block with half the words wrong. My transcript literally claims "AI needed to put flea medicine on her." It was me. That's the kind of thing the AI is cleaning up. The ideas are mine. The argument is mine. The punctuation and clarification belongs to the machine, because the machine is better at punctuation than a transcript is.

By the rules of the current discourse, you're now supposed to stop reading.

That's the game, right? "Not reading this if it's AI-generated." "It has em dashes — slop." Let's deal with the em dash first, since it's apparently forensic evidence now. You can type one. Shift-Option-hyphen on a Mac. Windows-Shift-hypen on Windows. Writers were littering pages with them for a century before the first transformer shipped. Its little brother the en dash is everywhere too, and nobody has ever accused an en dash of being a robot. The em dash gets singled out for exactly one reason: it's a fast, cheap way to judge a piece of writing without engaging with a single idea in it. Zero effort, instant superiority. Remember that phrase — zero effort. It's coming back.

Because real AI slop absolutely exists. Someone fires off one prompt, ships whatever falls out, never reads it, then farms for stars and upvotes. That's slop — not because a model was involved, but because no human was. Effort is the variable. The tool never was.

Here's what the other end of the spectrum looks like. Hundreds of hours on a single project. I decide the architecture, the language, how it compiles, how it deploys. I fork the output into a container and let three agents loose on it to tell me what's wrong, then I go look for myself, then we iterate — an annealing process, hardening the thing pass after pass. Does that catch every bug? No. Neither do you. But the result compiles, runs, and does what it claims, and I'd put its defect rate up against most hand-written code without blinking. That's how a systems architect thinks: in outcomes. There are a thousand valid ways to write the same program in a dozen languages, and the compiler doesn't award style points for matching whatever format twenty engineers blessed in a forum thread. Pick a language like Rust that enforces good behavior at compile time and the "but is it safe" argument gets a lot quieter.

And I've earned the right to skip the drudgery. CS and math degree, programming since the day I first touched a computer. I once caught a BGP misconfiguration where a router in the US was advertising and black-holing a huge block of another country's address space — and then I went and learned routing down to the nitty-gritty bits because of it. I've built the complex routes, the load balancers, the certs, the domains, the Apache configs, the backups. I know how the machine works, top to bottom. Which is exactly why I refuse to burn five days deciphering Microsoft's code-signing docs — written by humans, by the way, and still confusing — when an AI can walk me through it in an afternoon. Knowing how to do things the hard way is what buys you the judgment to skip it.

While we're at it, spare me the purity test from people whose files open with a wall of #include statements. You didn't read the source of your dependencies. You didn't audit your framework. You took the shortcut the entire industry agreed to call normal — which is fine, that's what libraries are for. Just don't pretend your shortcuts are craftsmanship and mine are cheating.

Accountability is the real line, so let's draw it. My name is on the repo, therefore the code is mine — every line, however it got there. Find a hole, a bug, a security issue? Bring me a substantive argument and I guarantee I will fix it. Probably with AI. Definitely with more scrutiny than before. That's what accountability means: answering for what you ship. It has nothing to do with which tools touched the file.

Which brings me to my actual hypothesis, formed over years of watching this play out. The drive-by "AI slop" comment is almost never a preference. A preference sounds like "I write everything by hand because X, Y, Z" — reasons, an argument, something to engage with. And honestly? Good for you. Some circles call that artisan craftsmanship, and it's a legitimate, even beautiful practice. But that's not what the drive-by is. The drive-by is a status move. It exists to knock down someone who figured out something you haven't, so you never have to feel the gap. Underneath it is fear — and the fear is rational. If you spent ten years accumulating knowledge that a model now reproduces on demand, that's terrifying. Watching your expertise depreciate hurts. But sneering at AI-built projects for another month won't un-obsolete a single thing you know. Blame-and-deflect is the oldest move we have. Humans have been generating slop since we learned to speak, and blaming someone else for your own stagnation is the classic of the genre. "AI slop" is just the newest sticker on it.

The art version is the same argument. If I draw a kick-ass owl by hand and have AI color it, and it moves you — I did my job. Eliciting emotion is the job. And if someone types one lazy prompt and happens to get lucky? Not craft. Same zero-effort laziness as the comment dismissing it. Funny how the two ends of that fight mirror each other.

And no, the labs don't get a pass either. Anthropic paid $1.5 billion to settle over the pirated books in its training pipeline — a speeding ticket at that scale — while its CEO has spent years telling the world how dangerous this technology is. Meanwhile, by their own account, their engineers barely hand-write code anymore; they architect systems and orchestrate agents. Doom for the cameras, full adoption in the building. When the loudest warnings come from the people running fastest, it stops looking like safety and starts looking like strategy — the regulatory kind.

As for "there's just too much content now" — that ship sailed with the infinite scroll. Pick your poison: Instagram, Reddit, YouTube. If we had thirty inhabited planets linked by laser comms, the same people would be complaining there are too many people online. Volume was always the condition. Triage was always the skill. And the triage tools have never been better — you can interrogate any document in seconds and get pointed answers back. The exhaustion is real. The scapegoat is wrong.

So here's the deal. Judge the work. Does it compile? Does it run? Does it hold up when you file a real issue? Does it move you? Fork it, drop it in a container, turn your own agents loose on it, and come back with specifics — I'll meet you there all day long. But if all you've got is "AI wrote this, pass," congratulations: you've produced the one genre of slop that predates the damn transistor — a human avoiding effort and calling it standards.

The raw transcript of this post is going up on Dropbox, because evidently Pastebin thinks I'm a potty mouth. Guess AI fixed that too. If you want to see what 100% organic, free-range, rant induced, human-generated text actually looks like click the link. Or just enjoy the post and know it was my messy thinking that informed. The machine cleaned it up. The thinking was always mine, messy or not.

Build on.

Hyperia: a terminal where AI agents are first-class tenants 👻🐚

Kord Campbell (kordless) — Sat, 04 Jul 2026 15:37:06 +0000

Most agentic coding today happens inside an IDE. Cursor, VS Code with Copilot — the editor owns the agent, and the terminal is just a panel at the bottom. But the terminal itself is having a moment, and two projects prove it:

cmux is genuinely awesome — vertical tabs, notification rings when agents need attention, split panes, a socket API. It's also macOS-only, native Swift on libghostty, with Windows and Linux on a waitlist.

Intelligent Terminal, Microsoft's experimental fork of Windows Terminal from Build 2026, docks an ACP-compatible agent pane (Copilot, Claude Code, Codex, Gemini) next to your shell. Windows-only, by definition.

Both are great. Both are locked to one platform. That gap is why I built Hyperia: an open source, platform-agnostic, agent-native terminal that runs the same on Windows, macOS, and Linux — no waitlist for your OS. Signed binaries. Waiting on 1.x.x to ship before putting on the Microsoft Store.

The core idea: agents are tenants, not visitors. Hyperia ships a full MCP server, so anything that speaks the Model Context Protocol — Claude Code, Codex, or a small local model on Ollama — can drive the terminal directly: open tabs, split panes, run commands, read screens, right beside you.

One hard rule, enforced in the harness rather than a prompt: an agent can never steal your focus. You keep typing in your pane; agents work in theirs, in your peripheral vision. Review becomes glancing, not switching.

Hyperia doesn't run agents itself — that's a separate concern, handled by nemesis8.

n8 launches coding agents inside containers and wires everything together securely: the agent gets a sealed environment scoped to your workspace, Hyperia gets the panes. Terminal and runtime stay decoupled, so either one can evolve without breaking the other.

Architecture

Hyperia splits its visual interface and execution layers to ensure responsiveness:

Electron UI (a fork of the open-source Hyper terminal) — handles layout, tabs, and native web panes.
Rust sidecar — owns PTYs, the MCP server (HTTP at localhost:9800/mcp), consent/identity, and telemetry. Decoupling this means heavy agent traffic never janks the UI.

Three core building blocks

1. Doors — progressive tool disclosure

There are 120+ tools across the built-in agent and the external MCP surface. Handing all of them to a model every turn is expensive and, for a small local model on an 8k context window, fatal.

Hyperia exposes a small always-on core plus category "doors" the model opens on demand. This took the per-turn tool payload from a flat ~58 KB to ~6 KB, saving substantial token costs and reducing execution latency.

It also allows you to use a local model for "Token Maximus" filtering. The local model, if enabled, can act as a summarizer for the larger models. Hyperia's built in agent uses credit based tokens, but agent CLIs use your login tokens (raw token usage vs. plan usage). I'm working on getting a Gemma4:e4b model + drafter training pipeline (in a container or hosted) setup to allow others to fine tune their own drafters to run any MCP tool. More on that soon: https://sailfish.nuts.services

2. Consent at the API layer, not the prompt

State-changing actions — opening a window, driving another pane — hit a human-approval gate in the sidecar. Identity is a low-privilege token that names the agent; it grants nothing on its own. Autonomy with a leash beats autonomy with vibes. Toasts pop up for approval.

3. Web panes as native views

Browser panes sit next to terminals (native WebContentsView, not an iframe). An agent can read the rendered, post-JavaScript DOM as clean Markdown — nav and chrome stripped to keep tokens down — so "read the docs you have open" is one call, not a scrape.

Concrete MCP Example

Agents interact with Hyperia using standard MCP JSON schemas. For instance, to read the content of an open Web Pane:

{
  "ServerName": "hyperia-mcp",
  "ToolName": "web_pane_content",
  "Arguments": {
    "pane": "DEV Community (65a885bd)"
  }
}

The server returns the clean, reader-mode Markdown structure directly back to the agent:

# DEV Community
- Announcing the First DEV Education Track: "Build Apps with Google AI Studio"
- Gemma and sandboxing cause a stir at the World's Fair
...

🧰 Secondary Features

⚡ Click to expand: Stickys™, Memory, & Command History

Stickys™: Persistent notes that can be written, updated, and queried by both you and the agent.
BM25 Search over History: Locally indexed terminal history allows agents to search past command logs to debug errors.
Built-in Agent: Runs directly inside the terminal on your configured model (local or frontier).

What I actually learned building and using it

Frontier models feel great in this shape. Small local models were useless until I stopped blaming them and made the harness hand them unambiguous data: pre-rendered strings instead of raw JSON, hard caps on runaway loops, tool schemas slimmed to fit their window.

🔗 Links & Resources

💻 Hyperia GitHub ➔ deepbluedynamics/hyperia*
💻 Nemesis8 (n8) GitHub ➔ deepbluedynamics/hyperia*
🌐 Documentation ➔ Deep Blue Dynamics Docs (also, a WIP...standby for launch)

Still building in public. How are you giving agents real access to your terminal — and keeping yourself in the loop? Let's discuss in the comments below! 👇