Zum Inhalt springen
Dokumentation

Website mit deinem Agenten umziehen

Zieh eine bestehende Website zu Neleto um, sodass jeder Text, jedes Bild und jeder Link im Page Builder bearbeitbar ist, mit einem Prompt für deinen Agenten.

Es gibt zwei Wege, eine bestehende Website zu Neleto zu bringen. Beide funktionieren; sie führen zu unterschiedlichen Ergebnissen.

ImportNeuaufbau mit deinem Agenten
Was übernommen wirdBlogbeiträge aus einer WordPress-Exportdatei und jede Seite über ihre AdresseJede Seite, neu aufgebaut aus Komponenten
Was du bekommstSeiten kommen als reines HTML an: ein Block Code pro SeiteJeder Text, jedes Bild, jeder Link und jede Farbe ist im Page Builder bearbeitbar
AufwandMinutenEin paar Minuten pro Seite für den Agenten; ein Nachmittag für eine kleine Website
Sinnvoll, wennDie Inhalte schnell drin sein müssen oder du Blogbeiträge umziehstDie Website vom ersten Tag an wie eine Neleto-Website funktionieren soll (empfohlen)

Mit dem Import allein hast du das System gewechselt, aber seine Vorteile noch nicht: Eine Überschrift auf einer importierten Seite zu ändern heißt weiterhin, HTML zu bearbeiten. Sofort profitierst du, wenn dein Agent die Website aus Komponenten neu aufbaut. Den Prompt dafür findest du auf dieser Seite.

Blogbeiträge ziehst du ohnehin am besten mit dem WordPress-Import um. Die Prompts unten kümmern sich um die Seiten.

Bevor du startest

  • Eine Neleto-Website. Zum Ausprobieren reicht der Gratis-Plan.
  • Dein Agent ist mit dieser Website verbunden, siehe Agenten verbinden.
  • Am besten ein Agent, der Webseiten öffnen kann (ein Browser-Werkzeug). Er liest das echte Design der alten Website und prüft das Ergebnis auf der Live-Seite. Ohne Browser arbeitet er mit dem HTML-Quelltext.
  • Die Adresse der Website, die umziehen soll.
  • Bei großen WordPress-Websites: Zugriff auf die WordPress-REST-API (/wp-json) oder ein Anwendungspasswort und eine Agenten-Umgebung mit Shell (zum Beispiel Claude Code), weil der Lauf seinen Fortschritt in einer Datei speichert.
  • Für ein Projekt auf deinem Rechner (ein HTML-Ordner, ein Vite-, Astro- oder Next.js-Projekt): eine Agenten-Umgebung mit Shell, die den Projektordner öffnen und das Projekt starten kann.

Welcher Prompt?

  • Bis etwa 30 Seiten: Prompt 1. Er baut die Website Seite für Seite nach dem Live-Design neu auf.
  • WordPress mit mehr als 100 Seiten: Prompt 2. Er arbeitet in Phasen, holt die Inhalte direkt aus WordPress und hält nach der Bestandsaufnahme an, damit du den Plan prüfen kannst, bevor etwas gebaut wird.
  • Ein Projekt auf deinem Rechner, noch nicht online: Prompt 3 zusammen mit Prompt 1. Er liest Seiten und Design aus dem Projektordner und lädt Bilder und Schriften von deiner Festplatte hoch.

Die Prompts sind auf Englisch. Agenten verstehen sie genauso gut, und die Texte deiner Website bleiben in ihrer Sprache.

So läuft es ab

  1. Prompt kopieren und <SOURCE_URL> durch die Adresse der alten Website ersetzen.
  2. In eine Sitzung deines verbundenen Agenten einfügen.
  3. Der Agent findet alle Seiten, liest das Design und listet die Abschnittstypen auf, die die Website nutzt (Hero, Text mit Bild, Kachelraster, FAQ …). Ein Abschnitt, der auf mehreren Seiten vorkommt, wird eine Komponente. So lernen du und dein Kunde ihn nur einmal.
  4. Er baut das Layout, die Komponenten und alle Seiten, übernimmt Titel und Meta-Beschreibungen und legt Weiterleitungen für alte Adressen an, die sich ändern. Neleto prüft jede Seite direkt beim Speichern auf kaputte Links, Alt-Texte und die Grundlagen für Suchmaschinen und Barrierefreiheit. Der Agent behebt die Befunde sofort.
  5. Er prüft jede Seite: alle Abschnitte vorhanden, keine kaputten Bilder, keine Template-Fehler, Position und Größe jedes Elements auf drei Bildschirmbreiten gegen die alte Website gemessen (2 px Toleranz), Barrierefreiheit und Lighthouse-Werte.
  6. Er meldet alte und neue Adressen, Weiterleitungen und alles, was er noch von dir braucht, zum Beispiel wohin Formulareingaben gehen sollen oder eine Markenfarbe, die beim Kontrast durchfällt.

Danach prüfst du die Seiten im Admin, lädst deinen Kunden als Editor ein und verbindest die Domain.

Funktionen aus Plugins ziehen nicht von selbst um: Shops, Buchungen, Mitgliederbereiche oder wohin Formulareingaben gehen. Der Agent listet sie in seinem Bericht auf, damit du entscheiden kannst, was sie ersetzt.

Prompt 1: kleine und mittlere Websites

<SOURCE_URL> ersetzen, zum Beispiel https://www.example.com, dann den ganzen Block einfügen.

Replicate <SOURCE_URL> 1:1 on our Neleto CMS as a fully component-driven site — every text,
image, link and color editable in the CMS, nothing hard-coded in templates. Build every page
reachable from nav, footer and in-page links. Verify everything yourself before reporting.

Pass `verbose:false` on EVERY create/update call (responses shrink to ids; halves token cost).

## Step 1 — Discover
- Try /sitemap.xml (or /sitemap_index.xml) first, then crawl nav + footer + in-page links.
- Produce a page table: old URL → new Neleto route (no trailing slash — Neleto strips it,
  "/x/" serves at "/x"), page <title>, meta description, og:image, canonical, lang.

## Step 2 — Pull the REAL design (live site = truth, never an archive)
- With a browser tool (Claude in Chrome, built-in browser, Playwright): per page a full-page
  screenshot + computed styles (font-family/-weight/-size, line-height, colors, backgrounds,
  padding, radius, section heights, buttons) + section/DOM structure. Match exact values.
- Capture at 1440px, 768px AND 390px wide, plus every breakpoint in the source's media queries.
- Base styles (the usual cause of misalignment — they come from the theme, not the sections):
  html/body font-size, line-height, color, margin; box-sizing; container max-width + side
  padding per breakpoint; default margins of h1–h6, p, ul. Copy the source's reset as is.
- Page builders (Elementor, Divi, WPBakery): the layout also comes from builder CSS (global kit
  CSS, per-page post-<id>.css, frontend.min.css). Port the rules the page actually uses (Chrome
  DevTools Coverage or PurgeCSS against the rendered page) — never paste whole builder
  stylesheets; they cost Lighthouse points.
- Fonts: for every font-family in use, find where it is loaded (Google Fonts <link>,
  @font-face in theme CSS, Adobe/Typekit, Elementor/OMGF local copies). Note family,
  weights, styles and the woff2 URLs.
- Bot protection (Cloudflare 403 on fetch): a real browser session usually passes.
- No browser: read HTML/CSS source directly. Real values, not visual approximation.
- Screenshots I attach override anything you fetch.

## Step 3 — Section inventory (before creating anything)
Compare ALL pages and list the distinct section TYPES (hero, text+image, card grid, CTA
band, FAQ, contact …). A section that repeats across pages with different content is ONE
component used many times — not one component per page. Show the inventory as a short
table (type → pages using it → editable fields) and continue.

## Step 4 — Build

### Engine rules (strict)
1. Inline helpers: parentheses + commas — `{{ render_elements(page.elements) }}`,
   `{{ image_path(img, "w_800,f_webp") }}`.
2. Block helpers bind with `as` — `{{#if x as v}}…{{/if}}`, `{{#each list as item}}…{{/each}}`.
3. String literals double-quoted, also inside attributes: `src="{{ image_path(img, "w_800") }}"`.
4. Undefined symbol / wrong arity = hard compile error that blanks the page — guard nullables.
5. Never triple braces (engine panics).
6. `{{ }}` is HTML-escaped — structural HTML (`<br>`, bold, spans) goes in the template.
   Exception: a `richtext` property renders raw (use it for long body copy).
   Richtext values may only contain what the admin editor can edit: p, h1–h4, strong, em, u, s,
   a, ul/ol/li, blockquote, br, img, and a `<span class>` around a word. Layout markup inside
   richtext (wrapper divs, block spans as line breaks, grid classes) locks the field in the
   editor — put it in the template. A headline with a highlighted word = text properties
   (e.g. `title`, `titleHighlight`) rendered in the template, not a richtext blob.
7. `{{ properties.key }}`, `{{ relations.id }}`, `{{ render_elements(children) }}` — never bare `{{ key }}`.

### Architecture — layout + page split
Layout `style` IS injected into <head>, before all component styles. Layout `script`, page
`style` and page `script` are NOT. So:
- Layout `style`: the @font-face rules (see Fonts) and the source's reset/base styles from
  Step 2, nothing else.
- ALL other CSS in one Global Styles component (`template:""`, whole stylesheet in `style`,
  source order). Section components carry template + form only (`style:""`) — this avoids
  cross-component specificity ties. If you do put CSS in a section component, scope it
  (`.banner .banner-inner{…}`), never bare classes that collide with shared ones.
- Site-wide JS in one Site Scripts component, wrapped in `DOMContentLoaded`; null-check every
  lookup that isn't on every page. `position:fixed` nodes created by PAGE-element JS must be
  `document.body.appendChild()`-ed at runtime (a fixed nav in the layout is fine).
- Slot component: `template:"<div>{{ slot }}</div>"`, empty form, icon `tabler:layout-dashboard`
  (built-in id 0 does not resolve).
- Layout (`layout_create`, ONE call): template `{{ render_elements(page.layout.elements) }}`,
  `style` as above, elements in order Global Styles, Site Scripts, Nav, slot, Footer. Resend
  template AND style on every `layout_update` or they blank.
- Page template: `{{ render_elements(page.elements) }}` — section elements only, `layoutId` set.
  Never repeat Nav/Footer/styles/scripts in `page.elements`.
- Fallback only if `layout_create` errors: Nav, Global Styles, Site Scripts, Footer as page
  elements on every page; @font-face + base styles at the top of Global Styles.
- Icons: Tabler strings with `tabler:` prefix (`tabler:photo`, `tabler:menu-2`).

### Form properties
One per client-editable value: camelCase `id`, `label:{en,de}`, `type`, `defaultValue` from the
source. Types: text, textarea, richtext, number, checkbox, select, relation, builder. Leave
structural classes, decorative SVG, aria-*, animation hooks hard-coded.
Values repeated across pages (phone, address, opening hours — per location if there are
several) are global strings, edited in one place (admin → Translations):
`translation_create {key:"location.leipzig.phone", language:"de", content:"…"}`, rendered with
`{{ translation("location.leipzig.phone") }}` — the key must be a string literal.

### Images — ingest by URL, never upload when a URL exists
Editable image = `file` relation + sibling alt text property:
`{ "id":"image","type":"relation","relationName":"file","multiple":false,"defaultValue":null }`
`{ "id":"imageAlt","type":"text","defaultValue":"…" }`
Render: `{{#if relations.image as file}}<img src="{{ image_path(file, "w_900,f_webp") }}" alt="{{ properties.imageAlt }}">{{/if}}`
- `f_` is FORMAT only (webp/jpeg/png/avif). Never `f_cover` (400). Crop with CSS `object-fit:cover`.
- On the element: `data.image = { "sourceUrl":"https://…", "path":"<site>/<name>.webp",
  "title":"…", "status":"public" }` — always set `path` (else opaque `mcp-ingest/…`).
  Works in page_create/page_update/layout_update, on children and multiple relations.
- `sourceUrl` must be reachable by the Neleto server. Re-ingesting a Neleto file needs
  `?options=w_800,f_webp` on the serve URL (bare → 400).
- Only a local file with no URL → `file_upload_url {path}`, then
  `curl --upload-file <file> "<uploadUrl>"` (needs a shell). No shell: `file_upload_multipart`
  (stripped small webp, ~1.2 KB parts with sha256, all parallel).

### Fonts — self-host every font, never hotlink
- Ingest each woff2 once (Google Fonts too — hotlinking them is a GDPR problem in the EU):
  `file_upload {sourceUrl, path:"<site>/fonts/<family>-<weight>.woff2", status:"public"}`.
  For Google Fonts, take the woff2 URLs from the fonts.googleapis.com/css2 response.
- Reference it as `url("/files/user-upload/<site>/fonts/<file>.woff2")` — the path you
  uploaded to. NOT the returned serveUrl (bare serveUrl → 400).
- One @font-face per weight/style with `font-display:swap`, in layout `style`.
- Never point @font-face at the old domain: browsers block cross-origin fonts and the old
  site goes offline after the move. Adobe/Typekit kits only work on registered domains →
  ASK ME (add the new domain to the kit, or a licensed replacement).
- Copy each font-family stack in full, fallbacks included.

### Repeating lists — builder (undocumented shape, copy exactly)
{ "id":"items","type":"builder","label":{"en":"Items","de":"Items"},"description":null,"hint":null,"required":null,
  "defaultValue":[{"id":"r1","data":{"title":"…","body":"…"}}],
  "items":[{"id":"row","type":"text","name":"row","label":{"en":"Row","de":"Zeile"},"icon":null,"items":[],
    "data":"","defaultValue":"","property":{"type":"text","defaultValue":""},
    "props":[{"id":"title","type":"text","label":{"en":"Title","de":"Titel"},"defaultValue":null,"description":null,"hint":null,"required":null},
             {"id":"body","type":"textarea","label":{"en":"Body","de":"Text"},"defaultValue":null,"description":null,"hint":null,"required":null}]}]}
- exactly one row-template; fields in its `props`; its `data`/`defaultValue` MUST be "".
- read rows as `{{#each properties.items as item}}{{ item.data.title }}{{/each}}`.
- Rows needing their own image/markup → child component under a `canHaveChildren:true` parent.

### Elements & data
- Every element: `visible:true`, `tempId`, `componentId`, `data`, `children:[]`
  (page_create needs no `pageId`; page_update does).
- First creation auto-seeds `data` from each property's `defaultValue` → only send what has no
  default (image ingests) or differs per instance (content of a reused section!).
- LATER updates are replace-semantics: `data` is NOT merged, auto-seed does NOT re-run.
  Sending `{}` or a partial object wipes the section. Always resend COMPLETE data, and every
  element with `id` AND `tempId` — omitted elements are deleted.
- Never `page_get` a finished page (blows the token limit); use `*_list`, or
  `page_get` with `componentDetail:"minimal"` if you must inspect.

### Build order
1. `component_list` / `layout_list` / `page_list` — reuse what exists.
2. Create ALL components from the Step-3 inventory in one or two parallel batches.
3. `layout_create` in one call.
4. One `page_create` per route (parallel where possible): `layoutId`, `renderMode:"dynamic"`,
   `status:"public"`, `useTailwind:false`, all section elements with their content and inline
   image ingests, plus the page title/meta description/og data from Step 1 in the page's SEO
   fields (check the page_create schema for their names). No create-empty-then-update.
   Every page_create/page_update returns `check`: fix its errors and warnings before moving
   on. Issue with `field` → resend the element with that field fixed; without `field` → fix
   the component template (`component_update`, then `page_check` the pages using it);
   `scope:"layout"` → `layout_update`.
5. Redirects for every old URL whose shape changed (trailing slash, renamed paths, .html).
6. Verify (Step 5). Then flip pages to `renderMode:"prerendered"` and re-verify.

## Step 5 — Verify every page
First `page_check` every page (server-side, fast): 0 errors, every remaining warning explained
in the report. It covers title/description/og tags, h1 and heading levels, alt texts, link and
button text, form labels and internal links. Then the browser checks below for what it can't
see (layout, fonts, contrast).
Load each live page (base URL from `settings_get` → publicBaseUrl) and run once:
(() => { document.querySelectorAll('.reveal,[class*="reveal"]').forEach(e=>e.classList.add('in'));
  const q=s=>document.querySelectorAll(s).length;
  const imgs=[...document.querySelectorAll('img')].filter(i=>!i.closest('#nlto-widget'));
  return { sections:{/* expected counts per section class */},
    imgBroken: imgs.filter(i=>i.naturalWidth===0).length,
    leftovers: document.body.innerHTML.includes('{{') || /could not resolve symbol/i.test(document.body.innerText),
    title: document.title, h1: q('h1'), mains: q('main'), lang: document.documentElement.lang }; })();
Bar: each section once and in order, imgBroken 0, leftovers false, one h1, HTTP 200, then one
screenshot per width (1440, 768, 390) next to the source's. Then:
- Fonts + layout match: run this on the SOURCE and on the copy, at 1440px, 768px and 390px:
  (async()=>{ await document.fonts.ready;
    const els=[...document.querySelectorAll('header,nav,section,h1,h2,h3,p,li,button,a[class*="btn"],img,footer')]
      .filter(e=>!e.closest('#nlto-widget')).slice(0,120);
    return { w:innerWidth,
      fonts:[...document.fonts].filter(f=>f.status==='loaded').map(f=>f.family+' '+f.weight),
      boxes:els.map(e=>{const r=e.getBoundingClientRect(),s=getComputedStyle(e);
        return [e.tagName,(e.textContent||'').trim().slice(0,30),Math.round(r.left),Math.round(r.top+scrollY),
                Math.round(r.width),Math.round(r.height),s.fontFamily.split(',')[0],s.fontSize,s.textAlign]}) }; })();
  Bar: every family the source loads is loaded on the copy; elements matched by text are within
  2px in left, top, width and height, with the same fontSize and textAlign. "The page loads" is
  not a match — fix layout style / Global Styles until the numbers are.
- axe-core on every page: 0 violations (lang, labelled inputs, heading order, one <main>,
  unique landmark labels, AA contrast). If fixing contrast would change a brand color, ASK ME.
- Lighthouse on the home page and one page per section-heavy template: report
  Performance / Accessibility / Best Practices / SEO next to the source site's scores.
  Target: no category worse than the source.

## Step 6 — Report
Table per page: old URL → new URL, redirect (y/n), axe violations, notes. Lighthouse
before/after. Fonts: self-hosted (family + weights) or open (licence). Everything you had to
assume. Open items that need my input (forms, analytics IDs).

Prompt 2: große WordPress-Websites

<SOURCE_URL> und <WORKDIR> ersetzen (der Ordner für die Fortschrittsdatei und Skripte). Diesen Prompt und darunter Prompt 1 einfügen: Prompt 2 nutzt dessen Regeln zum Bauen und Prüfen.

Migrate the WordPress site <SOURCE_URL> to our Neleto CMS. Work in phases and keep all state
in <WORKDIR>/manifest.json so any run can be resumed or repeated without duplicates.
Follow all engine, architecture, image, builder and data rules from the site-copy prompt
(pasted below this one) — they apply unchanged. Pass `verbose:false` on every create/update.

## Phase 1 — Inventory (read-only). STOP afterwards and report to me.
1. Detect the API: GET /wp-json/ . If blocked, fall back to /wp-sitemap.xml or Yoast's
   /sitemap_index.xml plus per-page HTML.
2. Pull everything, paginated (per_page=100, follow X-WP-TotalPages):
   /wp/v2/pages, /wp/v2/posts, /wp/v2/categories, /wp/v2/tags, /wp/v2/media,
   custom post types from /wp/v2/types, menus (/wp/v2/menu-items or /wp-api-menus if present).
   Keep per item: id, slug, link, parent, template, modified, title, content.rendered,
   excerpt, featured_media, and SEO from `yoast_head_json` (title, description, canonical,
   robots, og:image) or Rank Math equivalents.
3. Detect the stack from HTML/body classes and asset paths: theme, page builder (Elementor,
   Divi, WPBakery, Gutenberg), multilingual (WPML/Polylang → hreflang), forms (CF7, Gravity,
   WPForms), shop (WooCommerce), search, comments, sliders, embedded maps/videos, tracking.
4. Cluster pages into TEMPLATES by WP template + section structure (screenshot 1–2
   representatives each). Typical: home, standard content page, service/product detail,
   team, contact, landing page, blog index, blog post, category archive, legal.
5. Write manifest.json: one row per URL with type, template cluster, SEO fields, image
   URLs, word count, status:"pending", neletoId:null, newRoute (no trailing slash).
6. Report to me and WAIT:
   - counts per type/template, languages, total media
   - proposed component library (section types → fields) and content model
     (what becomes a page, what goes into a Neleto content type/collection e.g. blog)
   - plugin functionality that has NO 1:1 Neleto equivalent and needs a decision
     (forms, shop, member areas, search, comments, events)
   - dead weight to drop (drafts, orphan pages, empty tags, attachment pages, old landing pages)
   - SEO risks and the redirect patterns you'll need

## Phase 2 — Template pilot (after my OK)
Build layout + component library + ONE representative page per template, with the
site-copy rules (layout/page split, Global Styles, one component per section TYPE, builder for lists,
images via sourceUrl with path "<site>/<yyyy>/<mm>/<file>"). Design from the live site's
computed styles, base styles and fonts (site-copy Step 2). Verify each pilot page (site-copy
Step 5: audit script, fonts + alignment check, axe 0, screenshots vs. source, Lighthouse). Write a `template-map` into the manifest: for each template, which
component receives which WP field. Report pilot URLs to me before bulk.

## Phase 3 — Bulk content (batches, resumable)
- Process manifest rows with status "pending" in batches of 10–20. For each: transform
  WP content into the element data of its template, then ONE page_create (or page_update if
  neletoId exists — then resend COMPLETE data + id + tempId; data is replace-semantics).
  Write neletoId + status:"built" back to the manifest after each page.
- If you have a shell and API access to the Neleto MCP endpoint, do the transform and the
  calls as a script (deterministic, no LLM retyping of content); the model only handles
  rows the script flags.
- Content cleanup: strip page-builder wrappers and shortcodes ([vc_row], [et_pb_*],
  elementor data attributes), keep semantic HTML (h2–h4, p, ul/ol, a, strong/em, table,
  blockquote) in a `richtext` body; flag any unknown shortcode instead of dropping it.
- Links: rewrite internal absolute URLs to relative Neleto routes WITHOUT trailing slash;
  resolve ?p= / ?page_id= links via the manifest; flag links to removed pages.
- Images: sourceUrl = original from /wp-content/uploads (not the -300x200 size variants),
  explicit path, alt from WP media alt_text; dedupe by URL so each file is ingested once.
- SEO: carry title, meta description, canonical, robots/noindex and og:image into the
  page's SEO fields; hreflang for language variants.
- Posts: into the Neleto blog/content type if the instance has one (check the tool list),
  keeping date, author, categories, featured image; otherwise a post template page.

## Phase 4 — Redirects, verification, report
- Redirects: every old URL whose shape changes → 301 to its new route. Cover patterns:
  trailing slash, /category/…, /tag/…, /author/…, date archives, /feed, attachment pages,
  ?p=/?page_id=, /wp-content/uploads/… for important PDFs, removed pages → nearest parent.
- `page_check` over ALL built pages: 0 errors (covers title + meta description, one h1,
  alt texts, link text, form labels and every internal link). Plus, by script or batched
  audit: HTTP 200, no "{{" or "could not resolve symbol", imgBroken 0, word count within ±10%
  of the WP source.
- Layout match over ALL built pages, not just the pilots: the site-copy Step 5 fonts + layout
  script on the WP URL and the Neleto URL at 1440, 768 and 390 px, same 2px bar. List every
  page that misses it; most misses come from missing theme or page-builder CSS.
- axe-core 0 violations on every template pilot + a random 10% sample; Lighthouse per template
  vs. the WordPress original (no category worse).
- Old sitemap: request every old URL against the new site → 200 or 301, never 404.
- Flip verified pages to renderMode:"prerendered".
- Report: counts built/skipped/flagged, redirect list, URLs with issues, open decisions.

Prompt 3: lokales Projekt

Für eine Website, die noch nicht online ist, zum Beispiel ein Ordner mit HTML-Dateien oder ein Vite-, Astro- oder Next.js-Projekt. <PROJECT_DIR> durch den Projektordner ersetzen. Diesen Prompt und darunter Prompt 1 einfügen: Prompt 3 ersetzt nur, wie der Agent Seiten, Design und Dateien findet.

Replicate the local project in <PROJECT_DIR> on our Neleto CMS. Follow the site-copy prompt
(pasted below this one) with the changes below — everything else applies unchanged.

## Instead of Step 1 — Discover
- Routes from the project itself: file tree (pages/, app/, src/pages/, *.html) or the router
  config. Ignore build output, node_modules and tests.
- Same page table as in Step 1; take title and meta from the source files or the rendered page.

## Instead of Step 2 — Design
- The project's CSS/SCSS and theme/Tailwind config are the truth. Start the dev server (or
  open the build output) in the browser and collect computed styles, base styles, fonts and
  screenshots at 1440 + 390 px from it, exactly as in Step 2.
- Tailwind projects: keep `useTailwind:false`. Run the project's build and put the generated
  CSS into Global Styles (base/reset part into layout `style`), so the classes in your
  templates keep working.
- Fonts usually sit in the project (public/, assets/fonts/) or in a package (@fontsource/…):
  use those woff2 files.

## Assets (images, fonts, PDFs)
- The Neleto server cannot reach localhost or this disk: `sourceUrl` does not work for local
  files. Per file: `file_upload_url {path:"<site>/…"}`, then
  `curl --upload-file <local file> "<uploadUrl>"`. Use the returned id in element data, and
  `/files/user-upload/<path>` for fonts. Never base64.
- Files that are also online (CDN, an old live site) can use `sourceUrl` as usual.

## Verify
- Step 5 as written, with the dev server as the source.

Tipps aus echten Umzügen

  • Zuerst die Liste der Abschnitte. Wer ohne sie Seite für Seite baut, bekommt fast gleiche Komponenten, die der Kunde dann doppelt lernen muss.
  • Schriften und Abstände kommen vom Theme, nicht von den Abschnitten. Sitzt Text ein paar Pixel daneben oder stimmt die Schrift nicht, fehlen die Grundstile, Schriftdateien oder das CSS des Page Builders (Elementor, Divi). Der Prompt lässt den Agenten sie übernehmen und jede Seite auf drei Breiten gegen das Original messen. Übernommen wird nur das Builder-CSS, das eine Seite wirklich nutzt, damit Lighthouse nicht absackt.
  • Ohne KI bearbeitbar halten. Eine Überschrift mit hervorgehobenem Wort bekommt eigene Felder statt HTML in einem Richtext-Feld, so kann sie im Admin geändert werden. Telefonnummern und Adressen, die auf vielen Seiten stehen, liegen an einer Stelle (Übersetzungen).
  • Titel, Beschreibungen und Weiterleitungen sind so wichtig wie das Aussehen. Eine Kopie, die perfekt aussieht, sie aber verliert, verliert ihre Suchmaschinen-Platzierungen, und das merkt man erst Wochen später.
  • Lass den Agenten die Barrierefreiheit prüfen. Eine 1:1-Kopie übernimmt die Probleme der alten Website; mit den Prüfungen im Prompt werden sie beim Umzug behoben.
  • Markenfarben entscheidest du. Würde eine Kontrast-Korrektur eine Markenfarbe ändern, fragt der Agent dich, statt selbst zu entscheiden.
  • Inhalte später korrigieren: Updates ersetzen den Inhalt eines Abschnitts komplett. Lass den Agenten immer den vollständigen Inhalt eines Abschnitts senden, nicht nur das geänderte Feld.

Ziehst du zum ersten Mal eine Kundenwebsite um? Sprich mit uns: Die erste machen wir gemeinsam mit dir.