Same.dev: AI Software Engineer

Most AI coding tools sit inside your editor and finish the line you are typing. Same.dev aims higher: you describe the app you want, and the agent plans the work, writes the code across multiple files, runs it, catches its own errors, and ships the result to a live URL. It is built around the idea of an autonomous software engineer rather than an autocomplete.

The product lives at same.new (the same.dev address redirects there) under the tagline “Make anything, build websites by chatting with AI,” and the site reports more than 600,000 projects built with it. This review covers what it does, how it works, its token-based pricing, and the honest limits of handing a build to an autonomous agent.

What Is Same.dev?

Same.dev is an autonomous AI coding agent that builds full web applications from natural-language instructions. Instead of suggesting snippets, it takes a goal, such as “build a landing page with a signup form” or “clone this site’s layout,” and carries it end to end: scaffolding the project, writing the components, wiring up the logic, and running the app in a cloud environment so you see it working. It is pitched at developers who want to move faster, founders prototyping an idea, and non-coders who want a working app, all in the browser with no local install.

How Same.dev Works

The workflow is built around delegation rather than line-by-line editing:

1. Describe the app. Write a prompt for what you want built, or point the agent at an existing page to rebuild its UI.

2. The agent plans and codes. It breaks the request into steps, then writes the files it needs across the project.

3. It runs and debugs itself. Same executes the code in a cloud sandbox, reads the errors it hits, and fixes them without you stepping in.

4. You preview and refine. A live preview shows the result; you refine with follow-up prompts, and the agent applies the changes.

5. Download or deploy. Export the project, remix it, or push it live to a shareable URL.

The self-debugging loop is the part that sets it apart from a plain code generator. Rather than returning code and leaving you to make it run, the agent treats “does it actually work” as part of the job.

Key Features

Autonomous end-to-end builds. Same.dev handles the full cycle, from scaffolding to a running app, so a single prompt can produce something usable rather than a block of code to assemble yourself.

Self-debugging. The agent runs its own output, reads the errors, and iterates until the app works, which is the core promise of an autonomous coding agent.

UI cloning and rebuilding. Point Same at an existing site and it recreates the layout as clean, editable code, a popular use for quickly matching a design you like.

Live preview and deployment. Projects run in a cloud environment with an instant preview, and you can deploy to a live URL without managing your own hosting for the first version.

Download and remix. You own the output: download the full project to work locally, or remix an existing build as a starting point.

Premium model on every plan. All paid tiers run on a premium model, selectable in the prompt bar (frontier models such as gpt-6-sol appear in the picker), so agent quality does not change with price; only the token allowance does.

Same.dev Pricing

Same.dev uses a token-based subscription. Every plan includes the premium model, project downloads, and remix; the difference is how many tokens you get each month. Tokens are consumed as the agent works, so heavier building uses them faster.

On the Ultra plan, usage beyond 20 million tokens is pay-as-you-go at $10 per additional 2 million tokens, so there is no hard cap if you need more. The main thing to watch is that complex builds and lots of back-and-forth burn tokens quickly, so the right plan depends on how much you build rather than how many projects you have.

Who Same.dev Is For

• Founders and solo builders who want a working prototype or MVP from a description, without a developer on hand.

• Developers who want to offload scaffolding, boilerplate, and routine debugging to move faster on the interesting parts.

• Designers and non-coders who want to turn a layout or an idea into real, editable code and a live page.

• Teams prototyping quickly who need to test an idea as a running app before committing engineering time.

Who should weigh it carefully: anyone building a large, complex, or security-sensitive production system. An autonomous agent is excellent for getting to a working version fast, but mission-critical code still needs human review, and token costs on big, iterative projects can add up.

Same.dev Pros & Cons

Languages and Access

Same.dev runs in the browser at same.new (the same.dev address redirects there), so it works on any modern system with no local setup. It is English-first in its interface and docs. Access is by subscription, from the Basic plan at $10/month up through higher token tiers, and since it is cloud-based, your projects are available wherever you sign in.

Final Verdict

Same.dev is a strong example of where autonomous coding is heading: describe what you want, and an agent builds, debugs, and deploys it while you watch. For founders, solo builders, and developers who want to skip the setup and reach a working app, it is useful, and the self-debugging loop is what makes it feel like an engineer rather than a generator. The trade-offs are real: token pricing rewards light, focused building and punishes sprawling, iterative work, and anything bound for production still needs human review. As a fast way to go from idea to running prototype, Same.dev earns its place; as a full replacement for an engineering team on a serious product, it is not there yet, and does not claim to be.