How Developers Work With Agents; or Don't

Every few weeks someone on X asks “how do you work with coding agents?” and a few hundred people answer. I kept reading those threads, then Hacker News threads, then blog posts, and at some point I started writing it down. After 411 people the short version is this: most developers don’t use an ADE at all.

An ADE (agent development environment) is to agents what an IDE is to code: the app you sit in while agents do the work. Think Conductor, T3 Code, Herdr, or Glimmervoid (the one I build). 345 of the 411 people said what they drive agents from, and here’s where they landed.

Loading the chart of where people drive agents from...

Where people drive agents from, first tool named per person. Hover or tap a bar for who's in it.

45% run agents from a bare CLI or tmux tabs. 23% use an orchestrator app, every product on that list added together. 11% got fed up and built their own, which is about half as many people as all the orchestrator apps combined. Count those two as ADE’s and 34% have one. The other 66% drive agents from a terminal, an editor, a vendor’s own app, or a chat bot. And Glimmervoid has exactly one user in the data (me, hi).

That lines up with how fast this moved. GitHub Copilot was autocomplete in 2021. Cursor put chat in the editor after that. Claude Code and Codex CLI showed up in 2025 and turned the agent into its own process in a terminal. The ADE is the next step on that list, and most people haven’t taken it yet… the terminal tab still works fine for one or two agents.

What your setup says about how you work

I scored every account 0 to 4 on nine axes (how many agents at once, how long they run alone, who coordinates them, how much code the developer still reads, and so on). Two of those axes explain most of the differences between people:

Delegation: how many agents, how long they run unwatched, and whether agents dispatch other agents, averaged.
Reading: how much of the code the developer still reads, from every line down to outcome only.

160 people said enough to place on both.

Loading the delegation and reading chart...

Each dot is one person; each cluster is people within half a point of each other, with its head count beside it. Hover or tap a dot for who it is and what they said.

Only 17% delegate heavily (2 or more out of 4) and still read most diffs. That’s the overloaded reviewer: the agents write faster than one carbon unit can read, and these folks are reading anyway. Everyone else picked a side. 33% keep agents on a short leash and read the diffs. 30% delegate heavily and trust the harness to catch problems.

Now color that by ADE.

Loading the ADE by group chart...

Each ADE's mix of the four groups, for ADE's with at least five people placed. Mixes under 10 people are hints, not findings.

The people who built their own ADE are almost all harness trusters: 11 of 13. Only 2 of 13 self-builders read most diffs. Meanwhile 58% of bare CLI users, 67% of tmux users, and 4 of 6 Cursor users still read most of the code.

So the split isn’t really about which app you picked. Pretty sure it runs the other way: once you stop reading every line, a terminal tab stops being enough, and you start building the thing that tells you which agent needs you. I can’t prove the direction from public posts though.

Machines read instead

If carbon units read less, something else has to. 73% of people put agent or bot review in front of themselves: a second model, a fresh-context reviewer, a PR bot, evals, or hooks that block a bad change.

Loading the machine review chart...

Share with agent or bot review, evals or blocking hooks (verification 3 or 4 on the rubric), by agents running at once. Faded bar: fewer than 10 people.

It’s already 61% at one agent and peaks at 81% for people running 4 to 6. Machine review isn’t a fleet operator thing. It’s table stakes.

What still hurts

253 people named something that annoys them. The top of the list:

Loading the pains chart...

People naming each problem, bucketed by keyword. One person can land in several.

Agent quality is first (skipped tests, fake “done”, drift), and no app fixes that. But look at the next ones: relaying context between agents, environment setup (worktrees, env files, ports), and figuring out which agent needs you. Those are the jobs an ADE is supposed to do. Most people are doing them by hand in a terminal, and they’re telling you it hurts.

Where I sit

I’m the one Glimmervoid dot. My row came from seven days of my own session recordings: one to five sessions open on this machine (two on average) and more on my other one, a worktree per session, and agent review lanes plus gates in front of every merge. I read none of the code. That makes me a harness truster, which is exactly what the self-builder bar says I’d be lol

So how do developers work with agents? Mostly from a terminal tab, one or two at a time, reading most of what comes back. Or they don’t, and they build something so they can stop.

How I did this

Sources: 411 public, first-hand accounts from Hacker News (166), X (149), blogs (86), lobste.rs (5) and a few others, collected in November 2026. I left out vendor marketing and posts that only compare models.
Scoring: a language model scored each account 0 to 4 per axis against a fixed rubric, and left an axis blank when the post didn’t say. A handful of well-known people were scored by hand from their own posts, and my row came from my recordings.
Caveats: people who post about their setup lean early adopter. Scores read what people said, not what they do. Small groups (anything under 10) are hints.

All 411 sources

Loading the source list...

Glimmervoid is open source: github.com/johncwaters/glimmervoid.