I was watching this guy’s screen share the other night, and my first thought was that he’d accidentally opened his entire GPU as a tiled window manager. Twenty terminal panes, model logs flying by, agents chattering through OAuth, and he’s calmly explaining that this is “just my harness.”

I glanced at my own setup with two humble tabs and felt like the person who uses a single 24‑inch monitor while everyone else is running mission control.

But the longer I watched, the more it stopped looking like a circus and started looking like a glimpse of what “real” software work might become for a lot of us.

Parallel Tracks, Same Brain

The thing that really clicked for me was how he treated agents the way we treat junior devs. One is wiring OAuth flows, another is formatting background tasks, a third is sketching a replay system so he can time travel through sessions, and one is quietly exposing a native scrolling API because his previous terminal scrollback felt wrong. He is not “reviewing every line” in real time, because nobody can. Instead, he leans on automated tests, one‑shot tasks, and periodic architecture passes.

It felt closer to managing a team than “using a tool,” and that mindset shift is probably the only way running a dozen sessions at once doesn’t melt your brain.

When Slop Is A Feature, Not A Bug

I used to treat AI‑generated slop like radioactive waste. But watching these workflows, I started to see a different pattern: fast, slightly messy code that is aggressively validated, logged and thrown away if it fails.

He has swarm coordination to avoid agents stomping on each other, scope locks on files, git‑backed changes, and talks about maybe moving to something like jj or a patch‑per‑commit world so every change is traceable. My son was looking over my shoulder at one point and said, “…so it’s like a game where you spawn a bunch of NPCs and see which one finishes the quest without crashing.”

That is exactly what it looked like, and in that frame, some amount of slop is just an acceptable cost of exploration.

Personal Software, Not Cathedral Architecture

What really stuck with me is how much of this work is unapologetically personal. He has agents that order groceries, remember preferences, hot‑reload their own source code in a “self dev” mode, and even suggest changes to themselves.

Other people in the thread talked about “personal software” they build only for themselves, with private harnesses, local models, or weird plugins tailored to how their brains work. My wife, who normally only cares that Zoom does not freeze, has quietly been building little throwaway tools with AI that she never would have paid a developer for.

For people like us who already live in terminals and repos, this whole ecosystem feels like a net positive: more power, faster iteration, and permission to ship ugly but working things that may never need to live longer than a couple of years.

A Net Positive, If You Respect The Cost

If you strip away the cyberpunk spectacle, what remains is surprisingly grounded. Use cheap models for easy tasks, expensive ones where it hurts. Keep tests close. Accept that you cannot track every line an agent writes, so focus on behavior, validation and rollback.

It is easy to sneer at vibe coding as unsustainable, but the truth is that most codebases do not outlive their third birthday anyway.

For developers who are willing to build some discipline around automation, I think this direction is a net positive for us: less time typing boilerplate, more time orchestrating, and a future where “I built my own harness” is as normal as “I customized my editor.”