# Teardown — full text

Deep engineering architecture specs from any live website, metered in credits.

---

Source: https://teardown.clawdcode.ai/

# Teardown — deep engineering architecture specs from any live website

Teardown takes a live website URL plus a plain-English question and returns a
deep engineering architecture spec as a published HTML artifact: routes,
frameworks, backend surface, data model, infra. Metered in credits — 1 credit
= $0.01 — with a free 100-credit bucket on signup.

## How it works: estimate → run → artifact

**Estimate.** Enter a URL and pick a focus lens (Everything / Frontend /
Backend & API / Data & auth / Infra & perf). A fast heuristic — no LLM — scans
the public surface and shows a credit range before anything runs. Estimates
are free and never auto-charge.

**Run.** One click starts the pipeline: recon → plan → dissect → synthesize →
build. The engine fingerprints frameworks, fans AI agents out per section with
bounded concurrency, then synthesizes an executive summary plus a "how to
clone this" breakdown. Progress streams per stage; runs are resumable.

**Artifact.** A stable link to a self-contained, mobile-first HTML spec:
executive summary, per-topic sections, clone notes. Saved to your history.

## Who it's for

Engineers evaluating unfamiliar systems, tech scouts doing due diligence,
consultants scoping rebuilds, and AI agents that need structured knowledge of
how a production site is built. Agents can read this site via llms.txt, the
OpenAPI description at /openapi.json, or markdown twins of every page.

## Pricing, briefly

Credits at $0.01 each: quick single-lens reads cost about 5–15 credits; full
teardowns of mid-size sites about 20–60 credits. Every new account gets a
free 100-credit bucket — no card required. See [/pricing](/pricing).

---

Source: https://teardown.clawdcode.ai/docs

# Teardown docs

Teardown takes a live website URL + a plain-English question + a focus lens and
returns a deep engineering architecture spec as a published HTML artifact.
This page explains how it works end to end.

## The estimate → run → artifact flow

**Estimate.** You enter a URL and focus lens; a fast heuristic estimator (no
LLM) fetches the site's public surface and returns a credit range:

```
{ url, kind, routes, jsChunks, jsBytes, credits_min, credits_max, focus }
```

Nothing runs until you press "Run teardown". Estimates are never auto-charged.

**Run.** The engine pipelines five stages — recon → plan → dissect → synthesize
→ build:

- *recon*: fetches the public surface (HTML, JS chunks, CSS), fingerprints
  frameworks, extracts backend-surface hints and string literals into
  `facts.json` / `strings.txt`. Public assets only; authorized-recon rules, no
  credential probing.
- *plan*: ONE cheap model call turns facts + your question + lens into a
  6–12 section task list tailored to the target.
- *dissect*: fans out one model call per section with bounded concurrency,
  retries, and resumability (finished sections are skipped on re-run).
- *synthesize*: ONE strong model pass writes an executive summary plus a
  "how to clone this" section.
- *build*: compiles sections + summary into a single self-contained,
  mobile-first `index.html`.

You can poll progress per stage while it runs (usually a few minutes).

**Artifact.** The finished spec is published at a stable URL and linked from
your history alongside the question you asked, the credits spent, and the date.

## Focus lenses

| Lens | What it weights |
| --- | --- |
| Everything | Full stack, balanced |
| Frontend | Frameworks, routing, rendering strategy, UI architecture |
| Backend & API | Endpoints, services, server-side logic |
| Data & auth | Schema, storage engines, sessions, identity flows |
| Infra & perf | Hosting, CDN, caching layers, performance signals |

The lens changes both section selection and cost (non-everything lenses are
cheaper — see [pricing](/pricing)).

## Credits

Credits are the display unit: **1 credit = $0.01**. Your balance is shown in
the header after sign-in. A run is gated against the estimate's upper bound;
after completion you are charged for what was actually analysed
(`credits_spent` in the run metadata). New accounts get a free 100-credit
bucket. See [pricing](/pricing) for tiers.

## HTTP API

All JSON, bearer-token or httpOnly-cookie session auth:

- `POST /api/teardown/estimate` `{url, focus}` → credit estimate. No auth.
- `POST /api/auth/request` `{email}` → magic-link sign-in.
- `GET  /api/auth/verify?token=...` → sets session.
- `GET  /api/me` → `{email, credit_balance}`.
- `POST /api/teardown/run` `{url, ask, focus}` → `{id}` (auth).
- `GET  /api/teardown/:id` → status/pct/artifact_url (auth).
- `GET  /api/teardowns` → your teardown history (auth).

An OpenAPI description is served at [openapi.json](/openapi.json); agents may
also prefer this page's markdown twin (`/docs.md` or
`Accept: text/markdown`).

## Privacy & authorization

Teardown fetches only the public surface a normal browser would receive. No
credential guessing, no exploitation, no private data. Runs and history are
private to your account.

---

Source: https://teardown.clawdcode.ai/pricing

# Teardown pricing

Teardown is metered in **credits**: 1 credit = $0.01. You always see a credit
range before a run starts, and you approve it. Nothing auto-runs.

## Credit cost by tier

| Tier | Typical target | Cost |
| --- | --- | --- |
| Quick read | small/static site, single-lens | ~5–15 credits ($0.05–$0.15) |
| Standard teardown | mid-size SPA or SSR app, full lens | ~20–60 credits ($0.20–$0.60) |
| Deep dive | large multi-route app, everything-lens | ~60–150 credits ($0.60–$1.50) |

Focus lenses other than "Everything" multiply the base cost by 0.6 — a
frontend-only read of a big site costs about 40% less than the full teardown.

## Free bucket

Every new account starts with a **free 100-credit bucket** — enough for
roughly two to five standard teardowns. No card required at sign-in; you sign
in with an email magic link.

## Billing rules

- A run is rejected up front if your balance is below the estimate's upper
  bound — you'll never get halfway charged.
- After completion you are charged `credits_spent`, computed from what was
  actually analysed, which lands inside the estimated range.
- Credits are a display unit over model + compute cost; the exact spend per
  stage is written to your run log.

See [how it works](/docs) for what drives cost (routes discovered, JS chunks,
bytes fetched, lens).

---

Source: https://teardown.clawdcode.ai/faq

# Teardown FAQ

## What is Teardown?

A tool that takes any live website URL plus a plain-English question and
returns a deep engineering architecture spec as a published HTML artifact —
routes, frameworks, backend surface, data model, infra — built by AI agents.

## Who is it for?

Engineers evaluating or onboarding onto unfamiliar codebases-by-example, tech
scouts doing due diligence, consultants scoping rebuilds, and AI agents that
need structured knowledge of how a production site is put together.

## Is crawling other people's sites allowed?

Teardown performs authorized recon only: it fetches exactly the public surface
a normal browser receives (HTML, JS, CSS). No credential guessing, no
exploitation, no private data.

## How much does it cost?

Credits at $0.01 each. A quick single-lens read costs ~5–15 credits; a full
teardown of a mid-size site ~20–60 credits. Every account gets a free
100-credit bucket at signup. Details on the [pricing page](/pricing).

## How long does a run take?

Usually a few minutes depending on site size. Progress is streamed per stage
(recon → plan → dissect → synthesize → build) and runs are resumable.

## Do I need to sign up?

You need an email magic link to run teardowns (no passwords), but estimates
are free and require no account. New accounts include the free 100-credit
bucket.

## Can AI agents use Teardown programmatically?

Yes. The JSON API is documented at [docs](/docs) with an OpenAPI description
at `/openapi.json`. This site also serves markdown twins of every page
(`/docs.md`, `/pricing.md`, `/faq.md`, or `Accept: text/markdown`) plus
`/llms.txt` for machine ingestion.

## What do I get at the end?

A stable URL pointing at a self-contained, mobile-first HTML spec: executive
summary, per-topic sections, and a "how to clone this" breakdown. It stays in
your history forever.