The model isn't the moat. The harness is.

Why I build on @Replit, not Claude Code, AI Studio, Lovable, OpenClaw or Hermes

When OpenClaw showed up, I felt the pull. I always do — chasing the newest thing while the current one's still half-built is a known bug in my own wiring, and I've at least learned to notice it firing. So I gave it a fair go. I read it, watched the demos, sat with the fastest-growing open-source project in GitHub history doing its always-on, runs-on-your-own-hardware, talks-to-you-through-WhatsApp thing. Genuinely impressive. Local-first and open, which my sovereignty instincts liked a lot.

Then I closed the tab and carried on building on Replit. Not out of loyalty. Out of arithmetic.

Strip the hype and OpenClaw is an agent — a brilliant, autonomous, always-on one — that turns up and then asks you to own everything around it. The capability everyone's losing their minds over, an agent that runs a long autonomous loop until the job's actually done, is the exact thing Replit already does for the work I do. It does it more safely: OpenClaw runs loose on your real machine with broad system permissions, which is a genuine security risk, whereas my agent runs in a sandbox that can undo itself — code and database — back to before it touched anything. And it does it with better results, because it isn't improvising against your whole computer. It's building one thing and checking it against the actual running app.

Here's the ethos underneath that decision, because it's the whole reason I build the way I build.

I want to live on the leading edge of what's actually possible. The apps I care about are the ones that don't have a tutorial yet — micropayment rails, web3 primitives, BSV machine-to-machine payments, preserving data privacy and intellectual property.

Two that are already live:

SonicStar streams music and lets the artist mint each track as a Bitcoin ordinal they own outright.

Permastack publishes writing straight onto Bitcoin SV, preserving the exact bytes so a piece can't be quietly edited or erased.

That's where my attention is worth something, and attention is the one resource I can't buy more of. Every hour I spend hand-wiring hosting, deployment, OAuth, a database and a security layer as five separate problems in five separate dashboards is an hour I'm not spending on the part that's new. And it's worse than hours, it's headspace. The frontier wants all of mine. Plumbing quietly eats it.

So the real question I ask of any tool isn't "is the model clever." They're all clever now. It's "how much of my finite headspace does this hand back to me." Which is exactly why the loops conversation everyone's having lands for me the way it does.

The people who built Claude Code and OpenClaw have been making the same argument lately: stop prompting agents, start building loops — autonomous things with a goal, the context to chase it, a way to check their own work, and an agent to run the cycle. They're right. But a loop is only as good as the environment it runs against, and most tools hand you a beautiful agent bolted to half a loop. The model was never the hard part. The harness is. Replit is the only one I've used that closes the whole thing — goal, context, evaluation, agent — in one place, against a real running app, with a real database, that actually ships.

A loop you can't evaluate isn't a loop

Start with evaluation, because it's where the code-first tools quietly fall apart.

Claude Code is genuinely brilliant. So is Cursor, so is Copilot CLI. They write tight code fast and they'll happily run in a while true until the tests pass. But ask the obvious question: pass against what? They're evaluating against your terminal and a test suite you brought yourself. They assume you already have a running environment, a database with real data in it, a deploy target, the lot. They're the agent and a chunk of the context. The evaluation and the goalposts are your problem.

Replit's Agent 4 doesn't guess whether the code works. It opens a browser, drives the actual running app, writes itself a report, and fixes what it finds — Replit calls it a reflection loop, and their testing system runs it roughly 3x faster and 10x cheaper than throwing a computer-use model at the problem. Underneath what looks like one agent is a pipeline of specialised models: one exploring, one testing, one fanning out into sub-agents that build different parts of the app in parallel and resolve their own merge conflicts. You hand it a goal. It builds the loop around itself.

That's the whole difference between an agent and a very fast autocomplete. One writes code. The other writes code, runs it, watches it break, and tries again — without you in the chair.

The environment is the moat

This is the part nobody else has, and it's the part that matters most when an agent is editing your app unsupervised.

Every checkpoint Replit takes isn't a git commit. It's a complete snapshot of your app — the code, yes, but also the project files, the agent's conversation memory, and the database state at that moment. Roll back and you don't just revert the code, you restore the data and the agent's understanding to match, in one click, because it's all branched together through Neon's copy-on-write Postgres. You can preview a checkpoint from three days ago, click around the live app as it existed then, and decide whether to actually go back. Rolling code back without rolling the data back is how you end up with a schema that doesn't match its own database. Replit just doesn't let that happen.

And it keeps your development and production databases separate, on purpose. You can rip your dev schema apart, let the agent run wild, test, validate — and your live users never feel it until you deploy. (If you remember the vibe-coding horror story where an agent dropped someone's production tables during a code freeze: this split, plus point-in-time restore, plus deployment rollbacks, is the direct answer to it.)

Claude Code can't give you that. Lovable can't give you that. None of the pure code agents can, because they don't own the environment — they're a guest in yours. Owning the runtime is exactly what lets Replit close the loop, and it's exactly what the others architecturally can't do without becoming Replit.

Context is fuel, and it's all just there

A loop starved of context stalls. So look at what's wired in before I type a word.

A Neon Postgres database in every app. Object storage for files, images, video. Authentication built in — Replit Auth out of the box, or Clerk and the rest through connectors. Stripe for payments, set up in basically one click. Over 450 connectors, plus custom MCP servers for everything else. When I need real data behind an app, there are native warehouse connectors for Databricks, Snowflake and BigQuery — OAuth in minutes, no credentials stuffed into secrets, the agent just understands the org's data and builds a dashboard on top of it. Voice through ElevenLabs. LLM calls out to OpenAI, Gemini, Claude, whatever the job needs.

That's the context layer the loops piece is talking about, and it's not a pile of API keys I have to assemble. It's fuel the agent can reach for mid-build. The goal arrives, and the tools to hit it are already in the room.

One project, every artifact, shared brain

Here's the thing that actually changed how I work. It's a monorepo, and the agent holds the whole thing in context at once.

In a single project I can build a web app, a React Native and Expo mobile app, a slide deck, a data visualisation and an animation — all sharing one database, one design system, one running context. Replit went up the stack this year: it's not a code tool anymore, it's a build environment that outputs apps, sites, slides, videos and data apps from one place, with the same brain behind all of them. Nothing gets lost in translation between the design and the code, because there's no translation step — it's all one environment.

For one person shipping across code, design, writing and music, that's not a convenience. That's the difference between finishing and not finishing. I won Replit's Mobile Buildathon with SpookSeek AR — a 12-ghost-type AR game with a 50-level campaign, multiplayer races and a photo booth — built on Windows, with no Mac, in React Native and Expo with custom gyroscope data and Three.js. I could do that because I never left one environment. The loop never broke across ten tools.

The canvas is where my designer brain lives now

I came to code through design and storytelling, not the other way round, and most agentic tools are built for people who think in systems first. Replit's canvas is the first one built for how I actually think.

It's an infinite board where I can try things, and that sounds small until you remember how a designer actually works. I don't arrive at the right answer. I arrive at six wrong ones and feel my way to the seventh, and I need somewhere to put all of them where they aren't precious yet. The canvas is that somewhere. I can ask for four directions and get four — Replit spins up a separate agent for each and lays them side by side, glassmorphic next to editorial next to something I'd never have thought to ask for — and none of it is real yet. The mockups sit apart from my live app, so I can shove them around, change my mind, bin three of them, and nothing I'm doing touches anything that ships. I only build out the one I've actually chosen, once I've actually chosen it.

It also works the way a mood board works, which happens to be the way my head works. I can drop references onto it, sketch straight onto the board with arrows and shapes, circle the thing that's wrong, scribble "this spacing, not that" next to it, and hand the agent a picture instead of a paragraph. Show, don't tell. For someone who thinks in images before sentences, that closes the gap between what I meant and what I typed.

And every artifact in the project lands on the same board. The web app, the mobile screens, the deck, the landing page, all in one eyeline, so I can hold them up against each other and keep them honest. Because they share design and context across the whole project, staying on brand stops being a thing I police by hand and becomes the default. I can ask the agent to generate a graphic or a video and drop it straight onto the canvas — they folded media generation right in — so the reference, the asset and the running app all sit in the same space. I tweak across mobile, tablet and desktop without leaving it, and when something's right, one move applies it back to the real app.

For a designer, it's the ultimate design canvas. The distance between functional and considered — kerning, colour, the half-millimetre that makes a thing feel made rather than generated — is the whole job, and the canvas is the first agentic tool that lets me close it without ever leaving the place the thing actually gets built.

It ships, and people can find it and trust it

The loop doesn't end when the code works. It ends when a real person can find your thing and not get malware doing it. Replit closes that part too.

It scans your dependencies and audits them before you publish, and Package Firewall — built with Socket — now blocks malicious packages at install time, before they ever touch your project. That's running by default for everyone and it's stopping something like 8,000 bad packages a day. On the discovery side, the SEO Agent runs a Lighthouse audit on every publish, rates your app, then scans crawlability, semantic structure, meta tags, Open Graph, sitemap and robots, and fixes what it can — and new apps now ship with semantic markup and meta tags baked in. The SEO weakness that quietly haunts the front-end app-builders, where Google gets served an empty shell, is something Replit went and solved rather than left for you to discover three months after launch.

And it's still mine

This is the part that matters to me most, and it's where the app-builders that lock you in a black box lose me completely.

The code is real code. It's mine, it's editable, it's backed up to GitHub — or GitLab, or Bitbucket — and I can export the whole lot whenever I want. I can import a project straight from GitHub, bring in a Figma design, pull in skills and custom instructions so the agent works the way I work across every project. Nothing about Replit is a trap. I trade exactly none of my ownership for the convenience, which is the only deal I'm ever willing to make.

That's the throughline. Sovereignty isn't a politics for me, it's an architecture — for money, for data, for the work itself. A tool that gives me the speed of an agent and keeps the output entirely in my hands is the rare one that doesn't ask me to choose.

What isn't a tie

The smartest models in the world are a one-click switch in every one of these tools now. That race is more or less a tie. What isn't a tie is the harness — the running environment, the real database, the self-testing, the rollback that includes your data, the deploy, the security scan, the ownership. That's the hard part. That's the part Replit spent years building while everyone else was arguing about benchmarks.

The model isn't the moat. It never was. I build on Replit because it's the only one that built the whole loop.

— Ruth Heasman is a Replit Ambassador, top 0.1% Master Builder, and winner of Replit's Mobile Buildathon. Portfolio: RuthDesignsDigital.com Services: ShipWithMe-Sprint.com