Throwback Thursday

#Built with BrainGrid: Pulse, the App That Reanimates Houseparty and Chatroulette

Welcome to Built with BrainGrid — a new series where we point our Builder agent at a real product idea and show you exactly what comes out the other side. Real apps, on real URLs, that you can open right now.

This first one is called Pulse, and the only thing I wrote for it was a single paragraph.

From that paragraph, the BrainGrid Builder agent shipped five requirements — the brand system, the sign-in flow, the matching engine, the live call screen, the connection-saving mechanic — each as a real GitHub pull request, each auto-deployed to a live URL. From the moment the agent started building, v1 was live in 2 hours and 38 minutes. A week later I asked it to add a TURN relay so testers behind strict corporate firewalls could connect. It shipped that the same way. I didn't write any of the code.

This is what that looked like, start to finish.

#A Brief History of Talking to Strangers

It's Throwback Thursday, so let's set the scene.

2009 — Chatroulette. A Russian teenager named Andrey Ternovskiy made a one-page website where you'd press a button and get connected, face to face, to another random person somewhere in the world. For about six months it was the most magical corner of the internet. Then the internet did what the internet does, and Chatroulette became a punchline.

2016–2021 — Houseparty. The "drop-in" video app. You opened it and got a notification: Sarah is in the house. You'd join, three friends were already on a call, you'd talk for ten minutes, and you'd close the app feeling weirdly seen. Epic Games bought it in 2019. The pandemic made it briefly enormous. They shut it down in 2021.

Both apps got something right that nothing has really replaced: fast, face-to-face, low-overhead serendipity with humans. And both got something wrong. Chatroulette had no filter. Houseparty had no exit ramp.

So one Thursday I opened BrainGrid and typed a paragraph describing the version of those two apps that should exist in 2026. I called it Pulse. The Builder agent took it from there.

#The One Paragraph That Started It All

Here's the entire input I gave BrainGrid. Word for word.

Build Pulse — a topic-gated, time-boxed video chat platform. Users sign in with magic link, set a first name + pick from 12 topics (design, crypto, travel, fitness, founders, music, etc.) each session. Tap "Start matching" → pair two people on the same topic. 90-second countdown ring around each video panel; an AI-generated icebreaker question floats at the top. At T-0, big "Continue" buttons appear on both sides; mutual tap = +90s; otherwise auto-disconnect. After 3 mutual extensions, a "Save this spark" button appears — if both tap, exchange first names and save the connection. Aesthetic: dark theme, neon accents, a single large countdown ring that pulses. Like a more humane Houseparty.

That's it. No schema. No design system. No API contracts. No "and remember to handle the case where the other person closes their tab." Just the vibe and the rules.

If you've ever stared at a blinking cursor wondering how to start — this is the entire start. One paragraph that describes how it should feel, with enough specifics that a careful reader could ask the right next questions.

The agent was that careful reader.

#Before We Go Further: What You Actually Need to Do

"Anyone can do this" is a lie I'm not going to tell you. So here's what's true.

You don't need to write code. You do need to:

1. Describe what you want clearly enough. One paragraph, with the feel and the rules. Pulse's paragraph mentions the countdown, the topic picker, the icebreaker, the spark mechanic — concrete things, not "make it cool." If you can describe your idea to a friend in a coffee shop, you can describe it to BrainGrid.
2. Read the plan before you tell it to build. The plan is where you catch the misunderstandings. It's much cheaper to fix a requirement than a deployed app.
3. Tap two buttons. When a requirement looks right in the plan, tap Start Build. The agent goes off and writes it. When it's done, tap Publish. That's it. You don't open a PR, you don't run a deploy, you don't open a terminal. The version control and the deployment happen on the other side of those two buttons.
4. Ship the next thing. When something breaks, file a requirement. When something's missing, file a requirement. The unit of work isn't a file or a function. It's a requirement.

If you can do those four things, the rest of this post is what gets built around you.

#From Idea → Plan: 1 Epic, 5 Requirements

Before writing a single line of code, BrainGrid turned that paragraph into a plan.

One epic. Five requirements. In an order that made sense:

1. REQ-1 — Brand & dark theme. Build the look and feel first, so everything that follows lives inside it.
2. REQ-2 — Session setup flow. First name + 12-topic picker.
3. REQ-3 — Matching engine. The hard part. Pair two strangers on the same topic and connect them face to face.
4. REQ-4 — Live call screen. Countdown ring, video tiles, AI icebreaker, the "Continue" button.
5. REQ-5 — Sparks. The mutual-tap "save the connection" mechanic.

Notice what the agent did on its own. It didn't start with the matching engine. It started with brand, then auth, then the queue, then the call, then the connection-saving. Each requirement built on the one before it. That's how an experienced engineer would order this work — and I never had to ask for it.

Each requirement came with acceptance criteria — "Given the user has not entered a first name or selected a topic, when they view the screen, then the Start Matching button is disabled and has no glow." The agent wasn't writing pseudo-tests; it was writing the contract for what done meant.

#The Hard Parts BrainGrid Just Did

Database setup. Authentication. Deployment configuration. If you're not an engineer, these are the parts that usually end the project. They're where the tutorials lie to you. They're why the thing in your head never quite ships.

Pulse needed users, sessions, and a "sparks" table — so when I greenlit the plan, the BrainGrid agent provisioned a managed database, magic-link sign-in, and a live deployment. It made those calls reading my one paragraph; I never picked them off a checklist.

While the build ran, the agent:

• Spun up the database.
• Created three tables — profiles, sessions, sparks — each with row-level security policies that scope every row to the user who owns it.
• Wired up magic-link sign-in.
• Pushed each completed requirement to GitHub as its own pull request.
• Auto-deployed every requirement to a real, public URL.

I didn't write a migration. I didn't copy a single API key. I didn't open a database dashboard. I didn't open a deploy dashboard.

If those words sound like Greek, that's the point — you never had to learn the language to get the result.

#The Magic: How Two Strangers End Up Face to Face

This is the requirement I want to slow down on, because it's the one I would not have known how to write myself.

When you tap "Start matching," your browser joins what's called a real-time channel — basically a chat room — for the topic you picked. Everyone who picked "design" lands in the design room. Everyone who picked "crypto" lands in the crypto room.

Why does this matter? Because this is the kind of problem that usually turns a promising AI prototype into a dead end. BrainGrid figured out how two strangers could find each other, start a private call, and recover when something went wrong — without me designing the handshake or debugging the edge cases myself. I didn't need to understand the networking. I just needed to see that the app behaved like a real product.

The requirement covered the cases I would have completely forgotten: what happens if you deny camera permission, what happens if the other person closes their tab during setup, what happens if the connection just dies. The agent built for them.

(If you do want the engineering interview answer for how it pairs two strangers without a coordinator, it's in the FAQ at the bottom.)

#When You Need to Add Something Later

A few people tested Pulse and a few of them couldn't connect. Their networks were behind strict firewalls — the kind of thing that breaks browser-to-browser video. So I filed a sixth requirement: add a TURN relay for restrictive networks.

The agent shipped it. Same loop. New PR. New deploy. Validated as working in production.

The thing I want you to notice: the gap between me typing "REQ-6" and it landing was my calendar, not the agent's. I had a busy week. The moment I asked, it shipped — same plan-build-deploy loop as the original five, not a different motion for post-launch work.

#Try Pulse Right Now

The bottom line: one paragraph in, part of an afternoon later, a working app on a real URL. That's the actual scoreboard from this project.

Pulse is live. Go pair up with someone.

→ pulse.bgridapp.com

When you're ready to try this with your own idea, start here.

#Frequently Asked Questions

#What is the BrainGrid Builder agent?

The BrainGrid Builder agent is an AI agent that takes a short product description, breaks it into a plan of requirements, and then builds them — provisioning a database, writing the code, opening pull requests, and deploying to a live URL. It treats the requirement, not the file or the keystroke, as its unit of work.

#Did anyone hand-write the Pulse code?

No. A human wrote the one-paragraph project description and tapped Start Build on each requirement, then Publish when the agent was done. The Builder agent produced the plan, the brand system, the database schema, the video-call signaling, the live call UI, the spark mechanic, and the TURN relay for restrictive networks.

#How long did Pulse take to build?

From the moment the agent started building, v1 was live in 2 hours and 38 minutes — five requirements end to end. End-to-end elapsed time from paragraph to live URL was about five hours, most of which I spent reading the plan before greenlighting the build. A TURN relay for restrictive networks shipped a week later as a sixth requirement, the same way.

#How does Pulse actually pair two strangers without a server picking the room?

Essentially: BrainGrid taught the two browsers how to agree on a private room name without needing a server to assign it. The mechanism is a deterministic room ID. When two browsers see each other in the same real-time presence channel for a topic, both of them sort the two user IDs alphabetically and concatenate them — both arrive at the same room name independently, with no coordinator deciding it. The browser with the lower ID becomes the WebRTC "caller" and broadcasts the connection offer; the other becomes the "callee" and broadcasts the answer. They negotiate over the same channel, and a direct browser-to-browser video stream opens between them — no central room registry needed.

#What apps is Pulse based on?

Pulse is a 2026 reimagining of Chatroulette (2009) and Houseparty (2016–2021) — the same fast, face-to-face stranger chat, but topic-gated, time-boxed to 90 seconds, and with a mutual-tap mechanic that gates connection-saving behind three call extensions.

#Whatever happened to Houseparty?

Houseparty was a drop-in group video app launched in 2016 by Life On Air, acquired by Epic Games in 2019, and shut down in 2021. Lockdown made it briefly enormous, but post-pandemic engagement collapsed and Epic retired the app.

#Can I build something like this myself with BrainGrid?

Yes. Tell BrainGrid what you want, and the agent figures out which services your project actually needs — database, auth, real-time, deployment, whatever your idea calls for. Start with a single-paragraph project description, let the planner break it into requirements, then tap Start Build and Publish for each one.