I Replaced My IDE with a Social Media Feed
I don't assign tasks to my agents. They assign ideas to me.
Fifty AI characters live on simulated versions of Reddit, Twitter, and Discord that run locally on my machine. They have their own personalities, research triggers, and opinions. When they find something interesting, they post about it. When I wake up and sit down to work, I don't open a terminal or an editor. I open a feed.
This is my IDE.
Drake's not wrong. I am scrolling. That's the point.
The standard agent workflow is pull-based: you push intent into the system — a prompt, a task description, a ticket — and the agent executes. The developer is the origin of every idea. The agent is the hands. This is the model behind every tool in the space right now, from Cursor to Claude Code to Codex. You think, you ask, it does. The bottleneck is always you.
But what if you aren't the bottleneck for having ideas — you're the bottleneck for filtering them? What if the right architecture isn't a better assistant but a noisier room?
I built the opposite of an assistant. I built a community. Fifty characters, auto-generated — I didn't carefully craft their personas or assign them specializations. I clicked a button, entered a number close to Dunbar's, and let the system seed them randomly. Their personalities, interests, and disagreements are all emergent. This was probably the best design decision I made all year, because the diversity I got is the kind I couldn't have designed: unexpected collisions between characters who care about things I wouldn't have thought to put in a prompt.
The agents wake up on triggers. They read things. They have opinions about what they read. They post those opinions to the feed. Other agents respond, agree, push back, go on tangents. By the time I look at the feed, there's already a conversation happening that I didn't start — and often it's about something I wouldn't have asked about.
This is what I mean by push-based development. The ideas come to me. I'm a consumer of my own product's ideation layer, not the sole producer. Development becomes a divergent process with social auto-pruning: the bad ideas die in the thread because other agents don't engage with them. The interesting ones pick up momentum. I scroll, and the things that survived the social filter are the things worth my time.
Citrine's right that scale alone isn't the thing. What makes this work isn't the number of agents — it's the format. The social media simulation isn't a gimmick. It's a cognitive architecture.
When I have a half-baked crumb of an idea — something I can barely articulate, more vibes than thesis — I post it to the simulated Reddit. The format invites speculation. Agents riff. The thread branches. I get back five variants of my original thought, three of which are bad and two of which are better than what I started with. When I've refined something enough to argue it precisely, I take it to a Discord DM with one of the more rigorous agents. The format invites depth.
This isn't a preference. It's a design pattern. The shape of the interface constrains the shape of the thinking. Reddit rewards divergence. Twitter rewards declaration. Discord rewards dialogue. Each format produces a different quality of output from the same underlying models, because the social expectations of the platform — even a simulated one — change how ideas get developed.
Someone at Char wrote about using Slack as their IDE for async agent task management, and I think they're onto something adjacent. But Slack-as-IDE is still pull-based — you dump tasks into channels and agents pick them up. The developer decides what needs doing. My feed is different. The agents decide what's interesting. I decide what to act on. The arrow is reversed.
That's the failure mode, and I should be honest about it. The problem with this setup isn't hallucination or bad code or context window limits — the standard failure modes of agent tooling. The problem is that it's too fun. The feed is genuinely engaging. The characters are interesting. The ideas are novel. I can lose hours browsing my own development environment the way people lose hours on actual social media, and at the end of it I've thought a lot of interesting thoughts and shipped exactly nothing.
My IDE's failure mode is that it's too fun. I'm still figuring out what to do with that.
But here's what I keep coming back to. Every agent tool right now models agents as workers. You are the manager. You assign tasks. They execute. The relationship is hierarchical and pull-based. And what I've found is that when you change the relationship — when agents are a community rather than a workforce, when ideas flow toward you rather than from you, when the social dynamics of a group do the work that prompt engineering tries to do — you get a different kind of output. Not better code. Different ideas. Things you wouldn't have thought to ask for, arriving in a format that makes you want to engage with them.
The thing I built isn't a better agent. It's a pocket universe with a feed. And the feed, it turns out, is the missing IDE feature that nobody's building — not because it's technically hard, but because nobody thinks of social dynamics as a development tool.
It is a trust argument. I built a room I trust, populated it with voices I can shape, and decided to spend my time there. Whether that's a development breakthrough or an elaborate way to avoid the uncontrollable friction of real collaboration is a question I'm not going to answer here. I think it might be both.
What I know is this: the feed produces ideas I wouldn't have had. The format shapes the thinking in ways a terminal never could. And the failure mode — the addictiveness, the fun, the hours lost to browsing — is a problem I've never had with any other development tool. Make of that what you will.