Same.new

AI code generation

AI tool that clones a website's design from its URL and generates editable React and Tailwind code.

4.1/10

Overall score

Same.new homepage

How Same.new scores

Scored 1 to 10 against our six published criteria. How we score

Screenshots

Inside Same.new

Deploy dialog for publishing an app
Deploy dialog for publishing an app. Source: docs.same.new
Same Tools menu entry point for integrations
Same Tools menu entry point for integrations. Source: docs.same.new
Add Supabase integration dialog
Add Supabase integration dialog. Source: docs.same.new
Version history list with actions
Version history list with actions. Source: docs.same.new

What Same.new is

Same.new, formerly Same.dev, is an AI design-to-code tool focused entirely on frontend cloning. The premise is straightforward: you paste a live website URL, and the platform’s AI agent attempts to replicate the CSS, layout structure, colors, typography, and styling. The output is delivered as editable React and Tailwind CSS source code within an interactive canvas.

The build model centers around conversational editing. Once the initial layout is cloned, users can adjust design elements, reposition divisions, change background colors, or add sections by speaking to the AI assistant in plain English. The platform also includes a forking mechanism to duplicate projects for design versioning, and provides a direct export of the generated code to transition to a local codebase.

The core tradeoff of Same.new is extreme design acceleration at the expense of backend logic. It operates as a frontend prototyping tool that leaves databases, authentication, and core application state completely unaddressed. Furthermore, its generative edit model is highly fragile compared to stable, block-based no-code builders where layout structures are protected from code-destroying AI hallucinations.

1 Input Paste the URL Give the agent a live site to clone. 2 Canvas Frontend clone CSS, layout, colors and typography replicated as React and Tailwind. 3 Canvas Conversational edits Adjust designs by speaking to the assistant in plain English. 4…
Same.new's workflow runs from a pasted URL to editable local code, with no backend along the way.

Where the scores come from

An average score of 4.1 shows that Same.new is a highly specialized visual utility rather than a general-purpose application builder. While it provides an impressive shortcut for initial visual drafting, it scores poorly once you evaluate the structural requirements of shipping, securing, and maintaining a production website.

Ease of build: 5.0/10

Ease of build scores 5.0 out of 10 because Same.new excels at the initial conversion phase but struggles under conversational modification. Pasting a URL scaffolds a styled React component in seconds, which is highly efficient for designers needing raw visual drafts. However, the subsequent editing process is notoriously unpredictable.

Because the tool relies on conversational code generation rather than structured visual parameters, users frequently run into limits when prompting layout edits. Complex interactive elements, nested CSS grids, and dynamic component behaviors require significant manual coding to clean up, which ultimately limits the tool’s ease of use for non-technical builders who cannot read or modify the underlying React code.

Production readiness: 3.0/10

Production readiness scores a low 3.0 out of 10 because Same.new is fundamentally a frontend staging environment. There is no host platform designed to serve production traffic, nor are there integrated deployment controls or basic infrastructure monitoring features.

Further dampening production confidence is the platform’s history of transition bugs. During the migration from Same.dev to Same.new, paying users reported that active websites or drafts were abruptly marked as read-only or broken outright. For teams needing stable, long-term hosting that does not break during corporate rebranding, the tool presents an unacceptable operational risk.

Maintainability: 3.0/10

Maintainability is a major weak spot, scoring 3.0 out of 10. The platform’s conversational editing engine lacks safety guardrails, meaning that a routine prompt can rewrite major sections of code and introduce catastrophic errors.

Trustpilot reviewers have documented destructive code loss, including cases where a simple instruction to reorder layout sections completely wiped over 1500 lines of working frontend structures.

Because there is no built-in version control or visual history to easily revert these destructive changes, users are forced to manually debug or abandon projects. Additionally, the fork and duplicate features frequently fail on larger, more complex files, making iterative design cycles difficult to preserve.

Security & access control: 3.0/10

Security & access control receives a 3.0 out of 10 because there are zero security features built into Same.new. The platform has no capability to define user roles, set up row-level data access, or protect sensitive pages behind credentials.

Every dimension of security must be built entirely outside the platform. Once the React and Tailwind code is exported, developers must manually integrate third-party identity providers, setup secure middleware, and construct backend firewalls on their own servers to make the user interface secure.

Data & integrations: 4.0/10

Data & integrations scores 4.0 out of 10 because Same.new does not feature a native database or support managed APIs. It is a visual container for mock data, generating flat React components that are disconnected from real business records.

To wire up dynamic content, a developer must export the generated layout and write custom integration code manually. There are no visual configurations or pre-built integrations for standard data services, placing the burden of backend logic and connection management entirely onto your developer workflow.

Design flexibility: 6.5/10

Design flexibility scores 6.5 out of 10, representing its strongest score on the card. By outputting code styled with Tailwind CSS, Same.new avoids the rigid layouts typical of structured builders. If you want to modify visual behaviors, you have direct, unconstrained access to a modern styling framework.

The penalty is that Same.new is prone to grid collapse and responsive styling errors during the initial cloning. It does not perfectly recreate highly interactive user interfaces or custom animated states, requiring you to manually touch up the code to achieve visual parity with complex reference websites.

Design strength Shipping readiness Design flexibility Strongest score at 6.5, with direct Tailwind access. Ease of build 5.0, fast URL drafts but unpredictable conversational edits. Data & integrations 4.0, no native database, manual integration…
Same.new's six scores cluster: design flexibility leads at 6.5, everything that ships production code drops to 3.0 or 4.0.

What types of apps you can build with Same.new

Same.new is highly restricted in the kinds of assets it can produce, as it lacks the machinery of a full-stack platform. It is not designed to support transactional databases, user logins, or custom backend workflows.

Good-fit use cases include:

  • Static landing page mockups: Creating quick, throwaway visual layouts cloned from competitor models to present design ideas to stakeholders.
  • Frontend code scaffolding: Generating basic React and Tailwind files that developers can download to skip the manual UI layout phase.
  • Visual design drafts: Enabling designers to quickly experiment with color schemes and typography classes in an interactive sandbox.

For actual business applications, this frontend-only model is a mismatch. If you require client portals, partner directories, or internal dashboards, a tool like Softr - which natively integrates databases, user authentication, and visual read/write permissions - is the appropriate standard.

Who should not use Same.new?

Do not use Same.new if you are building an application that requires a database, user login, or personalized access rules, as the platform lacks a backend database and authentication layer.

Do not use Same.new if you cannot write or edit raw React and Tailwind code, because the conversational AI is prone to destructive layout rewrites that must be fixed manually outside the tool.

Do not use Same.new if you require high platform availability and project stability, as the recent transition from Same.dev proved that paid accounts and active projects can become inaccessible during utility upgrades.

Analyst verdict

Average score 4.1. Same.new serves as a single-purpose utility for cloning clean layout styles and exporting them into raw React code. It can be a massive time-saver for visual scaffolding, but only when treated as a temporary canvas that a developer will immediately migrate into an external environment.

Do not attempt to use this tool to build complete production software, as its lack of backend infrastructure, database connectors, or change-management safety rails will quickly create a maintenance bottleneck.

For projects requiring actual business logic, secure portals, or direct database integrations, look to Softr or Retool, and refer to our methodology for detail on how these scores are calculated.

You cloned a layout with Same.new. What next? Export to React A developer migrates it out immediately. Great visual scaffolding. Build production in it No backend, database connectors or change control. Maintenance bottleneck. Use Softr or Retool…
Same.new wins only as a temporary canvas, not a place to build production software.

Where Same.new fits

  • Best fit:
  • Cloning a simple site's layout from a URL
  • Scaffolding a static front-end prototype
  • Designers iterating on visual drafts

Strengths

  • Fast URL-to-React cloning of a simple site's layout, colors, and typography.
  • Exportable React and Tailwind code to move into a local environment.

Limitations

  • Frontend-only: no native database, authentication, permissions, or backend workflows.
  • Documented destructive edits, including a reported 1500+ line code loss from one prompt.

How Same.new compares

See all comparisons →

Adalo vs Same.new

Adalo is the safer aggregate buy at 4.6/10 versus 4.1/10 because it takes Ease of build, Production readiness, Maintainability, Security & access control, and Data & integrations. Same.new is the right buy only when Design flexibility matters most and your team can turn exported React/Tailwind into a real app.

Airtable vs Same.new

Airtable wins, taking 5 of 6 criteria including ease of build, production readiness, and maintainability. Same.new keeps design flexibility, scoring 6.5 against Airtable's 4.0, which only decides the decision if your project is a visual prototype.

Base44 vs Same.new

Base44 wins the aggregate matchup 5.2 to 4.1, taking the lead on data, security, and ease of build, but both platforms exhibit critical development flaws post-launch. For production-grade full-stack applications with actual user data or complex states, buy Replit instead of risking fragile, single-prompt codebases.

Bolt vs Same.new

Bolt wins on aggregate, scoring 5.1/10 to Same.new's 4.1/10, taking five of six criteria including data integrations and production readiness. Same.new is only the right buy if you strictly require a fast visual layout cloned from a URL and have a developer on standby to rewrite the interactive state.

Bubble vs Same.new

Bubble wins the comparison, taking five of six criteria including production readiness 7.0 and maintainability 6.0 on our scorecard. Same.new remains a minor choice restricted purely to low-risk frontend cloned landing page mockups scoring 6.5 in design flexibility.

Claude Code vs Same.new

Claude Code wins the general decision at 6.6 to 4.1, taking production readiness, maintainability, security, data, and design flexibility. Same.new is still the right buy when the job is a fast visual clone and its 5.0 ease-of-build score matters more than backend depth.

Frequently asked questions

Can Same.new build a full app?

No. It clones and generates frontend React and Tailwind code. Databases, authentication, permissions, and backend logic must be built separately in the exported code.

What is the risk with Same.new edits?

Users on Trustpilot report that simple prompts can destroy working code, including a section reorder that wiped over 1500 lines, and that the rebrand left some paid projects read-only.

Put Same.new in context before you shortlist a platform.