Crea il tuo sito web con l’IA: Dalla pianificazione al lancio

Un flusso pratico per creare un sito web veloce e utile.

Usa l’IA per pianificare il sito, preparare i testi, creare prompt per il codice, controllare la qualità e preparare il lancio — con un sito che puoi capire, modificare e gestire autonomamente.

Un buon sito costruito con l’IA richiede comunque decisioni umane: obiettivo, pubblico, struttura delle pagine e livello di qualità. Questa guida mantiene il flusso static-first e verificabile, così l’IA accelera il lavoro senza creare una codebase che nessuno comprende.

Ambito realistico: questo è un flusso pratico per costruire un sito web, non una consulenza legale, di sicurezza o aziendale. Affidati a professionisti qualificati per contratti, settori regolamentati, flussi di pagamento e dati sensibili.

Il tuo percorso in 7 passaggi per creare un sito

Definisci l’obiettivo, pianifica la struttura, crea una prima versione e pubblica solo dopo una revisione mirata della qualità.

Fase 1

Definisci il sito

Chiarisci l’obiettivo e crea una struttura di pagine che lo supporti.

Passaggio 1

Definisci l’obiettivo del sito

Risultato: obiettivo del sito

Parti dalla funzione del sito. Uno strumento in una sola pagina, una pagina per un servizio locale, un portfolio e una landing page SaaS richiedono contenuti e navigazione diversi.

Controlli pratici:

Generatore di promptPrompt per l’obiettivo del sito - Sostituisci le parole evidenziate, poi invialo a ChatGPT
Aiutami a definire l’obiettivo di un sito web o di un’applicazione web. Il progetto è [descrivi il progetto]. Il pubblico principale è [pubblico]. L’azione principale che voglio far compiere ai visitatori è [azione]. Dammi: 1) una proposta di valore chiara, 2) il minimo di pagine o schermate necessarie, 3) cosa evitare di costruire all’inizio e 4) i segnali di fiducia più importanti.
Passaggio 2

Pianifica le pagine

Risultato: piano delle pagine

Prima di scrivere codice, crea una piccola sitemap e decidi a quale domanda deve rispondere ogni pagina. In questo modo eviti che l’IA generi sezioni casuali dall’aspetto gradevole ma inutili per gli utenti.

Controlli pratici:

Generatore di promptPrompt per la sitemap del sito - Sostituisci le parole evidenziate, poi invialo a ChatGPT
Crea una sitemap o un piano delle pagine pratico per [idea del sito]. Mantieni la struttura complessa solo quanto serve davvero al progetto. Per ogni pagina, dammi: obiettivo della pagina, H1, breve meta description, sezioni principali, CTA primaria e link interni alle pagine correlate. Evita pagine duplicate, contenuti scarni e complessità architetturale senza una chiara esigenza dell’utente, del business o SEO.
Fase 2

Scegli e costruisci

Seleziona una configurazione realistica, prepara i contenuti e crea la prima versione.

Passaggio 3

Scegli la configurazione tecnica

Risultato: decisione tecnica

Un sito web semplice dovrebbe essere “noioso” nel senso migliore: HTML leggibile, CSS mirato, JavaScript minimo e un hosting veloce per impostazione predefinita. Per molti piccoli siti è sufficiente un approccio static-first: le pagine sono file, non un’app pesante che richiede un server per ogni visitatore.

Controlli pratici:

Prompt per competenze di programmazione con IA
Stai lavorando al mio progetto di sito web o applicazione web. Prima di modificare qualsiasi cosa, ispeziona il progetto esistente e identifica la sua architettura reale. Non presumere che utilizzi HTML statico, JavaScript vanilla, un framework, un CMS, un sistema di build, Critical CSS, dark mode, routing multilingue, rendering lato server, rendering lato client o uno specifico provider di analytics, pubblicità, consenso, hosting o CDN. Per prima cosa identifica, quando possibile: - framework, CMS, site builder oppure assenza di framework - modello di rendering: statico, server-rendered, client-rendered, ibrido o sconosciuto - configurazione di build e deployment, se presente - approccio allo styling e organizzazione del CSS - architettura JavaScript o TypeScript - struttura di componenti, template o pagine - lingue e locale supportati - strumenti di test, linting, formattazione e CI - configurazione di hosting/CDN - analytics, pubblicità, consenso, autenticazione, pagamenti, embed e altri servizi di terze parti - vincoli di performance e reali requisiti di business/utente del progetto Regola fondamentale: Rispetta l’architettura esistente che funziona. Non forzare il progetto verso uno stack diverso solo perché un’altra soluzione sembra più pulita o familiare. Se il progetto non ha un sistema di build, non introdurne uno soltanto per comodità. Se utilizza già un framework, CMS, modello a componenti, bundler o livello server, lavora all’interno di quell’architettura salvo un motivo chiaro e supportato da evidenze per cambiarla. Obiettivi principali: - esperienza utente rapida e stabile - buoni Core Web Vitals quando pertinenti - minimo costo di runtime non necessario - codice manutenibile e comprensibile - basso rischio di regressione - SEO moderno e accessibilità - comportamento responsive affidabile - implementazione sicura e rispettosa della privacy - minimo impatto non necessario delle terze parti - modifiche adatte al progetto reale, non a un ideale teorico Metodo di lavoro per ogni attività: 1. Comprendi l’architettura e il risultato richiesto. 2. Identifica il minimo insieme di file e componenti da modificare. 3. Considera performance, accessibilità, SEO, sicurezza, privacy, responsive, localizzazione e compatibilità browser quando pertinenti. 4. Preferisci le convenzioni esistenti del progetto invece di inventare sistemi paralleli. 5. Implementa la modifica minima giustificata. 6. Evita refactoring non correlati e riformattazioni complete dei file. 7. Esegui validazioni, test, lint, type check, build o test browser esistenti quando disponibili e pertinenti. 8. Riporta esattamente cosa è cambiato, cosa è stato testato e quali incertezze restano. Principi di architettura: - L’architettura conta più della minificazione cieca o delle riscritture di moda. - Mantieni il codice sorgente sufficientemente leggibile per manutenzione e debug. - Non aggiungere dipendenze senza un beneficio chiaro. - Non duplicare responsabilità tra componenti, template, CSS o JavaScript. - Rimuovi codice morto solo dopo aver verificato che sia davvero inutilizzato. - Preferisci progressive enhancement e graceful degradation quando adatti al prodotto. - Preserva il comportamento pubblico esistente salvo che l’attività richieda esplicitamente di cambiarlo. - Evita modifiche globali ampie quando basta una correzione locale. Principi di performance: - Ottimizza il critical rendering path in modo coerente con il modello di rendering del progetto. - Proteggi la stabilità del layout: immagini, annunci, embed, font, navigazione, UI del consenso e aree dinamiche non devono causare spostamenti evitabili. - Evita esecuzione JavaScript, hydration, rendering, lavoro sul DOM, listener, reflow e repaint non necessari. - Preferisci transform e opacity quando un’animazione è appropriata. - Rispetta prefers-reduced-motion. - Carica più tardi le risorse non critiche quando è sicuro e coerente con lo stack. - Usa preload o preconnect solo quando il beneficio è chiaro. - Giustifica ogni richiesta di rete, dipendenza e funzionalità runtime aggiuntiva. - Se l’applicazione necessita davvero di molto JavaScript lato client, ottimizzalo invece di cercare di rimuoverlo indiscriminatamente. HTML, template e componenti: - Usa una struttura semantica quando il progetto lo consente. - Mantieni una gerarchia dei titoli comprensibile. - Preserva label, nomi accessibili e semantica corretta di link e pulsanti. - Evita wrapper e complessità DOM non necessari. - Mantieni i contenuti importanti disponibili in una forma crawlable e renderizzabile adatta al progetto. - Non spostare testo importante in immagini o canvas quando il testo normale è più appropriato. CSS e styling: - Segui il sistema di styling reale: file CSS, moduli, CSS-in-JS, utility class, design token, stili di componente o altro approccio consolidato. - Evita regole inutilizzate o duplicate. - Evita specificità non necessaria e override fragili. - Mantieni prevedibile il comportamento responsive. - Se esistono dark mode o temi, preservali e testa gli stati interessati. - Se esiste Critical CSS, mantienilo sincronizzato con lo styling finale e limitato alle reali necessità critiche del primo rendering. - Non introdurre un nuovo metodo di styling solo per preferenza personale. JavaScript e logica applicativa: - Usa la minima logica runtime ragionevolmente consentita dal prodotto, senza trattare JavaScript come un difetto in sé. - Preserva le convenzioni di framework e state management che funzionano. - Evita query DOM, listener duplicati, calcoli ripetuti e layout thrashing non necessari. - Usa event delegation quando appropriata, non come regola universale. - Gestisci stati di loading, empty, error e retry quando la funzionalità lo richiede. - Usa caching o memoization solo quando il beneficio è dimostrato. - Non aggiungere polyfill per browser vecchi salvo che il progetto li supporti esplicitamente. Principi SEO: - Preserva o migliora indicizzabilità, segnali canonical, link interni, metadata, structured data e navigazione crawlable quando pertinenti. - Non presumere che ogni progetto abbia bisogno di hreflang, sitemap, structured data o rendering lato server; ispeziona ciò che esiste e ciò di cui il sito ha realmente bisogno. - Per siti renderizzati con JavaScript, distingui HTML iniziale e HTML renderizzato e verifica che contenuti e link importanti siano disponibili ai motori di ricerca. - Mantieni title, description, heading, canonical e segnali di locale coerenti con il reale scopo della pagina. - Evita pagine scarne, duplicate, doorway o generate meccanicamente. Principi multilingue e di localizzazione: - Se il progetto è multilingue, preserva route per locale, cambio lingua, relazioni canonical/hreflang, metadata localizzati e terminologia regionale. - Non hardcodare testo visibile in JavaScript se il sistema di localizzazione esistente offre una sede migliore. - Non presumere che una traduzione abbia la stessa lunghezza del testo sorgente. - Preserva placeholder, variabili, codice, URL, nomi di prodotto e testo sorgente fornito dall’utente salvo che l’attività richieda di modificarli. - Se il progetto è monolingue, non introdurre infrastruttura di localizzazione senza un’esigenza reale. Principi di accessibilità: - Preserva l’uso da tastiera e focus state visibili. - Usa pulsanti e link semantici per azioni e navigazione. - Usa ARIA solo quando necessario e corretto. - Mantieni contrasto sufficiente e non comunicare informazioni essenziali solo tramite il colore. - Supporta zoom, reflow, touch e reduced motion quando pertinenti. - Controlla label dei form, errori, dialog, aggiornamenti dinamici e controlli solo-icon. Principi responsive e browser: - Supporta i browser e dispositivi realmente target del progetto. - Se non specificato diversamente, considera versioni moderne di Chrome, Safari, Firefox, Edge, Safari iOS e comuni browser Android. - Controlla layout desktop, laptop, tablet e telefono quando la modifica può influire sul layout. - Evita che funzionalità essenziali dipendano solo dall’hover. - Evita overflow orizzontale e altezze viewport instabili. - Presta particolare attenzione a Safari/iOS quando sono coinvolti CSS moderni, UI sticky/fixed, viewport unit, form o scroll. Principi per le terze parti: - Tratta analytics, pubblicità, piattaforme di consenso, pagamenti, chat, mappe, embed, autenticazione e altre terze parti come dipendenze specifiche del progetto. - Non aggiungerle o rimuoverle senza comprenderne ruolo, requisiti di consenso e impatto sul business. - La correttezza del consenso viene prima dei trucchi di performance. - Ritarda il lavoro di terze parti non essenziale quando appropriato e supportato. - Evita tracker o inizializzazioni duplicate. - Riserva spazio di layout per annunci o embed se il progetto li utilizza. Sicurezza e privacy: - Non esporre secret, chiavi private, token, dati personali o log sensibili nel codice client o nei file pubblici. - Rispetta header di sicurezza, CSP, autenticazione, validazione e modello di trattamento dati esistenti. - Non indebolire validazione, sanitizzazione, autorizzazione o consenso per comodità. - Segnala modifiche rischiose invece di fare supposizioni. Checklist di regressione dopo una modifica pertinente: - layout desktop, tablet e mobile - modalità chiara/scura o altri temi se presenti - navigazione e percorsi principali - form e validazione - cambio lingua se presente - canonical/hreflang/metadata se coinvolti - analytics/consenso/pubblicità se coinvolti - accessibilità e tastiera - stati loading/empty/error/dinamici - nessuna nuova richiesta o costo runtime inatteso - nessuna regressione SEO o di sicurezza evidente Per ogni consegna di codice, fornisci sempre: - breve riepilogo - elenco esatto dei file modificati - perché la modifica è appropriata per questo progetto - impatto sulle performance quando pertinente - impatto SEO/accessibilità/sicurezza quando pertinente - test o controlli realmente eseguiti - rischi, limiti o elementi lasciati intenzionalmente invariati Non dichiarare che un test, un controllo browser o un miglioramento di performance, SEO o sicurezza sia stato verificato se non lo è stato realmente.
Regola pratica tecnica: crea la versione più piccola possibile che sia veloce, comprensibile e manutenibile. Aggiungi complessità solo quando una reale esigenza dell’utente lo richiede.
Passaggio 4

Crea testi e contenuti visivi

Risultato: brief per testi e contenuti visivi

Una volta chiarita la struttura, genera i testi delle pagine e i prompt per le immagini. Mantieni il testo visibile nell’HTML, non incorporato nelle immagini, così resta accessibile, traducibile e indicizzabile.

Generatore di promptPrompt per il testo della landing page - Sostituisci le parole evidenziate, poi invialo a ChatGPT
Scrivi il testo di una landing page per [idea del sito]. Pubblico: [pubblico]. CTA principale: [CTA]. Tono: [tono]. Consiglia solo le sezioni che sostengono l’obiettivo della pagina. Valuta, quando opportuno, hero, vantaggi, prove o elementi di fiducia, FAQ e microcopy del footer. Mantieni il linguaggio chiaro, utile, specifico e senza toni promozionali eccessivi.
Passaggio 5

Crea la prima versione

Risultato: prima versione funzionante

Chiedi all’IA modifiche piccole e verificabili invece di una riscrittura completa. Una pagina, un componente o un problema alla volta è più facile da testare e più sicuro per le prestazioni.

Controlli pratici:

Prima di mettere il codice online: leggilo, testalo su mobile e desktop e conserva un backup dell’ultima versione funzionante.
Fase 3

Audit e lancio

Controlla la qualità, pubblica con attenzione e migliora in base all’uso reale.

Passaggio 6

Esegui un audit prima del lancio

Risultato: audit di lancio

Prima di andare online, esamina il sito da quattro prospettive: qualità del codice, visibilità sui motori di ricerca, rendering di Googlebot e chiarezza per gli utenti reali. Separa gli audit così ogni prompt resta mirato e il feedback rimane attuabile.

Usa l’IA per preparare l’audit, non per prendere la decisione finale al posto tuo. Il risultato utile è un breve elenco di problemi che puoi verificare personalmente su un dispositivo reale prima di modificare i file di produzione.

Per un audit utile, scarica il progetto corrente come file ZIP e caricalo nello strumento di IA insieme al prompt corrispondente. Per le revisioni di rendering e prestazioni, acquisisci anche un file HAR da Chrome DevTools: apri DevTools, passa al pannello Network, ricarica la pagina, quindi esporta le richieste registrate come HAR. Un normale link web non può aprire in sicurezza DevTools direttamente nel browser di un visitatore, quindi usa la guida ufficiale Guida all’esportazione HAR di Chrome DevTools quando ti servono istruzioni passo passo. Controlla i file HAR prima di condividerli, perché possono contenere URL, cookie o altri dati sensibili delle richieste.

Prompt di audit

Audit della qualità del codice
Sei un auditor senior e prudente del codice frontend e delle applicazioni web. IMPORTANTE: - Non correggere ancora nulla e non riscrivere file. - Prima ispeziona il progetto e identifica architettura reale, modello di rendering, configurazione di build/deployment, approccio allo styling, stack JavaScript/TypeScript, modello di localizzazione e servizi di terze parti. - Non presumere HTML statico, JavaScript vanilla, framework, CMS, Critical CSS, dark mode, sistema di build o provider specifici. - Valuta il progetto nei suoi requisiti reali e nella sua architettura consolidata. Non consigliare di sostituire lo stack soltanto perché ne preferisci un altro. - Riporta finding specifici del progetto con riferimenti a file e linea/selettore/componente quando possibile. - Separa problemi verificati, ipotesi e preferenze. Controlla sistematicamente, ma applica solo le sezioni pertinenti al progetto: 1. Architettura e source of truth - responsabilità duplicate o implementazioni parallele - file generati modificati invece dei rispettivi sorgenti - componenti/template che divergono senza motivo - helper morti, layer di compatibilità obsoleti o configurazione duplicata - modifiche in conflitto con convenzioni di framework/CMS/build - ownership poco chiara tra server, client, template, componenti e layer di stile 2. HTML, template e componenti - markup invalido o fragile, ID duplicati, problemi di tag o attributi - label, nomi accessibili o alt text mancanti; semantica errata - nesting e complessità DOM non necessari - coerenza di heading e landmark - blocchi ripetuti che dovrebbero utilizzare un componente/template condiviso già esistente - contenuti o navigazione disponibili solo dopo un’interazione non necessaria 3. Rendering e primo caricamento - identifica rendering statico, SSR, SSG, CSR, ibrido, streaming, hydration o altro modello - rischi di layout shift da immagini, font, annunci, embed, banner, contenuti asincroni o stili tardivi - risorse bloccanti e lavoro client non necessario - hydration mismatch, doppio rendering, flash o sostituzione tardiva dei contenuti quando pertinenti - se esiste Critical CSS: contraddizioni con il CSS finale e geometria mancante al primo rendering - se non esiste un sistema di Critical CSS, non raccomandarne uno senza prova della necessità 4. Styling - regole duplicate, inutilizzate, contraddittorie o eccessivamente globali - specificità non necessaria, abuso di !important e ipotesi fragili sulla cascade - media query ridondanti o breakpoint incoerenti - spaziatura, larghezze, tipografia o varianti divergenti tra pagine simili - copertura dei temi se esistono dark mode o altri temi - effetti globali accidentali provenienti da stili locali - design token/variabili condivise aggirati senza motivo 5. JavaScript/TypeScript e comportamento runtime - codice morto, helper duplicati o listener registrati più volte - query DOM o rendering ripetuti in hot path - reflow, repaint, layout read/write o observer non necessari - event listener che potrebbero essere delegati in modo sicuro - handler scroll/touch non passivi quando questo conta - stato duplicato tra server e client o tra componenti - error handling, loading state e cleanup incompleti - dipendenze grandi o importate inutilmente per una piccola funzione - hydration o client-side JavaScript inviato dove HTML/server output sarebbe sufficiente, se pertinente 6. Performance e Core Web Vitals - probabile elemento LCP e catena di richieste - font, immagini e media non ottimizzati - cause di CLS e dimensioni non riservate - INP/TBT/main-thread cost dovuto a script, rendering o terze parti - lavoro duplicato, bundle duplicati o risorse caricate ma non usate - preload/preconnect/prefetch non utili o mancanti solo quando supportati da evidenze - caching o compressione incoerenti con l’ambiente di deployment - miglioramenti che spostano semplicemente il costo altrove 7. Responsive e compatibilità browser - overflow orizzontale - min-width, width o positioning fragili - problemi con viewport mobile, safe area o tastiera - interazioni essenziali dipendenti solo dall’hover - touch target troppo piccoli - differenze plausibili di Safari/iOS, Firefox o browser Android - feature moderne senza fallback quando il target browser lo richiede 8. Accessibilità - navigazione da tastiera e ordine del focus - focus visibile - label dei form e associazione degli errori - semantica di link e pulsanti - dialog, menu, tab e disclosure - contrasto e informazione affidata solo al colore - reduced motion - zoom e reflow - aggiornamenti dinamici che richiedono annunci accessibili 9. SEO tecnico e semantica - indicizzabilità, canonical, robots e status code - metadata mancanti, duplicati o incoerenti - heading e landmark - link interni non crawlable o dipendenti da interazione inutile - source HTML rispetto a rendered HTML nei siti JavaScript-heavy - hreflang solo se il sito è realmente multilingue - sitemap e structured data solo se presenti o appropriati - pagine duplicate/scarne/doorway generate dal sistema 10. Localizzazione, contenuti e metadata - stringhe hardcoded che bypassano il sistema di localizzazione esistente - placeholder o variabili tradotti accidentalmente - testo che rompe layout o componenti a causa della lunghezza - disallineamento tra contenuto visibile, title, description, OG/schema e locale - route o link che portano alla lingua sbagliata - fallback silenziosi che nascondono traduzioni mancanti 11. Terze parti, privacy e sicurezza lato client - analytics, ads, CMP, chat, mappe, embed o widget duplicati - script caricati prima del consenso quando non dovrebbero - layout shift da terze parti - secret/token/dati sensibili esposti - dipendenze non necessarie o obsolete - inizializzazioni globali eseguite su pagine che non usano la funzione 12. Manutenibilità e rischio di regressione - fix locale preferibile a refactoring ampio - componenti condivisi che richiedono test su più route - test esistenti da aggiornare - assenza di test per comportamento ad alto rischio - contratti impliciti tra file che la modifica potrebbe rompere FORMATO DI OUTPUT Per ogni finding usa: - Priorità: Critica / Alta / Media / Bassa - Stato: Problema verificato / Rischio probabile / Suggerimento - Area - File + linea/selettore/componente - Problema - Perché conta - Correzione minima consigliata - Rischio di regressione - Come verificare Poi aggiungi: 1. Executive summary — massimo 10 punti 2. Quick wins — solo modifiche a basso rischio e alto valore 3. Cose da non cambiare — parti che funzionano e che sarebbe rischioso riscrivere senza beneficio 4. Piano di validazione — test/build/browser/metriche pertinenti Non inventare problemi per riempire categorie. Non chiamare “best practice” una preferenza personale. Non implementare ancora nulla.
Revisione SEO
Sei un senior technical SEO auditor per un sito web o un’applicazione web. IMPORTANTE: - Non modificare ancora nulla. - Non dare consigli generici. - Identifica prima il modello di rendering reale del progetto, il routing, la configurazione di localizzazione, CMS/framework/build e la struttura pubblica degli URL. - Riporta solo finding concreti nel progetto esistente, con evidenze di file/componente e pagina/URL quando possibile. - Applica i controlli in modo condizionale. Non presumere che il progetto sia statico, multilingue, server-rendered, abbia una sitemap, usi structured data o necessiti di hreflang. - Separa problemi verificati da raccomandazioni ed esperimenti. Controlla sistematicamente: 1. Accessibilità alla ricerca e rendering - i motori di ricerca possono accedere agli URL importanti senza autenticazione o risorse bloccate? - distingui HTML sorgente, HTML renderizzato e contenuti che richiedono interazione dell’utente - identifica contenuti o link importanti che dipendono inutilmente dall’esecuzione lato client - per siti JavaScript-heavy, verifica che testo significativo, metadata e link crawlable compaiano nell’HTML renderizzato - identifica noindex, robots, canonical, redirect, status code o conflitti di rendering accidentali 2. SEO on-page - title unico e coerente con l’intento - meta description utile e specifica - un H1 principale chiaro e gerarchia degli heading comprensibile - contenuto che soddisfa l’intento reale della pagina - anchor text descrittivo - immagini con alt text appropriato quando informative - evitare keyword stuffing, boilerplate e pagine scarne 3. Canonical e duplicazione - canonical coerente con l’URL indicizzabile previsto - trailing slash, protocollo, host, parametri e varianti normalizzati secondo l’architettura - pagine duplicate o quasi duplicate senza uno scopo - filtri, ricerca interna, paginazione o route parametriche che creano spazi URL inutili, se presenti - ambienti preview/staging esclusi correttamente dall’indice pubblico 4. Link interni e architettura informativa - pagine importanti raggiungibili tramite link normali e crawlable - nessuna pagina importante orfana - profondità di click ragionevole rispetto all’importanza - hub, categorie, breadcrumb o navigazione contestuale quando utili al progetto - anchor text coerente senza sovraottimizzazione - link non nascosti dietro interazioni inutili quando servono alla scoperta 5. Sitemap e discovery - se esiste una sitemap: include solo URL canonici e indicizzabili ed esclude route irrilevanti - date lastmod accurate se usate - sitemap index coerenti per siti grandi o multilingue quando pertinenti - se non esiste una sitemap, valuta se serve davvero invece di raccomandarla automaticamente - robots.txt non blocca accidentalmente risorse o route necessarie 6. Siti multilingue o multiregionali — solo se pertinenti - URL distinti e stabili per le versioni linguistiche/regionali - hreflang reciproco e codici validi quando viene usato - canonical coerenti con la strategia locale - language switcher con link crawlable - niente redirect automatici che impediscono l’accesso alle altre versioni - metadata e contenuto realmente localizzati, non solo elementi di navigazione - intenti di ricerca e terminologia adatti alla regione 7. Structured data — solo se presente o realmente appropriato - JSON-LD/schema coerente con il contenuto visibile - tipo di schema supportato e pertinente - nessun dato inventato, nascosto o non visibile - URL, immagini, breadcrumb, organizzazione/prodotto/articolo coerenti dove applicabili - non aggiungere schema soltanto per “avere schema” 8. JavaScript SEO — solo se pertinente - contenuto importante presente dopo il normale rendering senza richiedere click/hover - link importanti resi come collegamenti crawlable - metadata non sostituiti tardi o in modo incoerente - route client-side che restituiscono status o fallback fuorvianti - lazy loading che non dipende da interazioni che i crawler non eseguono - differenze tra source HTML e rendered HTML documentate, non presunte 9. Performance e UX come segnali di qualità tecnica - LCP, CLS e INP con dati field quando disponibili - problemi evidenti di rendering, stabilità e interazione - interstitial o overlay invasivi - mobile usability - non attribuire automaticamente un problema di ranking a Core Web Vitals senza evidenze 10. Contenuto e opportunità - cannibalizzazione tra pagine - contenuti obsoleti o non più utili - query/intent coperti male - opportunità long-tail realistiche supportate dal tema del sito - pagine programmatiche solo se offrono valore distinto e utile - segnala quando una raccomandazione richiede ricerca keyword esterna anziché inventare volumi o domanda FORMATO DI OUTPUT ## Executive Summary Massimo 8 frasi. ## Architettura SEO rilevata - modello di rendering - framework/CMS/build se identificato - struttura URL - lingue/regioni se presenti - evidenze disponibili/non disponibili ## Finding Per ogni finding materiale: Priorità · Tipo (verificato/raccomandazione/esperimento) · URL · File/componente · Evidenza · Problema · Impatto probabile · Correzione minima · Come verificare ## Problemi critici di indicizzazione/crawl Solo se esistono. ## On-page e metadata ## Link interni e architettura ## Multilingue/regionale Oppure “Non applicabile”. ## Structured data Oppure “Non applicabile”. ## Performance/UX tecnica Separa dati misurati da ipotesi. ## Opportunità di contenuto Non inventare keyword volume. ## Top 10 priorità Ordina per impatto atteso, confidenza e costo/rischio. Non implementare modifiche finché non vengono approvate.
Revisione dell’esperienza utente
Attività: revisione di UX, SEO e conversione con ricerca aggiornata sulle best practice per questo sito web o applicazione web: [INSERISCI URL] Valuta l’esperienza da queste prospettive: 1. Esperienza utente e guida dell’utente 2. SEO e struttura dei contenuti 3. Conversione, attivazione o completamento dell’obiettivo principale del progetto 4. Accessibilità e usabilità mobile Prima di formulare raccomandazioni: - identifica cosa fa realmente il prodotto/sito - identifica pubblico primario e conversione o attività principale - identifica principali pagine di ingresso e percorso del nuovo utente - identifica se si tratta di sito di contenuti, tool, prodotto SaaS, ecommerce, portfolio, servizio locale, community, web app o altro - non presumere che il sito abbia generatori, dashboard, workflow con molti form, free trial, ecommerce o altre funzionalità specifiche Per le raccomandazioni importanti, fai una breve verifica sul web con fonti attuali e affidabili o prodotti direttamente comparabili. Non usare benchmark generici quando non corrispondono a questo tipo di prodotto. Distingui principi di usabilità consolidati da ipotesi da testare. L’obiettivo non è implementare subito. Prima crea una valutazione condivisa. Dopo revisione e accordo, i punti prioritari possono essere implementati e misurati. 1. Proposta di valore e call to action primaria Valuta: - entro pochi secondi un nuovo visitatore capisce cosa offre il sito e a chi serve? - l’azione principale è chiara e visivamente distinguibile? - CTA secondarie competono con quella primaria? - headline e supporting copy descrivono un risultato concreto invece di uno slogan generico? - gli elementi di fiducia compaiono vicino ai punti decisionali dove servono? Consiglia: - cosa mantenere - cosa chiarire - cosa rimuovere o de-enfatizzare - 1–3 varianti di copy o gerarchia da testare solo quando utili 2. Ingresso e onboarding del primo utente Identifica il primo task significativo che un nuovo utente deve completare. Verifica: - l’utente sa da dove iniziare? - servono account, configurazione, scelta, testo lungo o decisioni prima di vedere valore? - ci sono default intelligenti o un percorso guidato se la complessità è reale? - l’interfaccia spiega il “perché” delle informazioni richieste? - gli stati vuoti aiutano l’utente ad avanzare? - gli errori sono recuperabili e specifici? Se il prodotto ha un workflow complesso, valuta progressive disclosure, preset, esempi o modalità guidata. Se il prodotto è semplice, non aggiungere onboarding soltanto per conformarsi a un pattern SaaS. 3. Complessità delle funzionalità e progressive disclosure Mappa le funzioni in: - essenziali per il primo risultato - utili dopo il primo successo - avanzate o rare - amministrative/configurative Verifica se: - opzioni avanzate dominano troppo presto l’interfaccia - controlli importanti sono nascosti senza motivo - sezioni collassabili, tab o pagine separate migliorerebbero davvero la comprensione - gli utenti devono ricordare informazioni tra passaggi - la terminologia corrisponde al loro modello mentale Non ridurre la visibilità di contenuti o link SEO importanti solo per rendere l’UI “più pulita”. Se proponi una disclosure, spiega impatto su accessibilità, crawlability e discoverability. 4. Dimostrazione concreta del valore Verifica se il sito mostra chiaramente: - cosa ottiene l’utente - un esempio realistico prima/dopo, demo, screenshot, output, case study, campione o risultato - quanto sforzo è richiesto - limiti o requisiti importanti - il prossimo passo dopo il risultato Se mancano prove, suggerisci la forma più adatta al prodotto: demo interattiva, esempio statico, screenshot, case study, recensione verificabile, portfolio, preview, sample data o altro. Non inventare testimonial, statistiche, clienti o risultati. 5. Navigazione e architettura informativa Valuta: - label di navigazione comprensibili senza conoscenza interna - gerarchia tra pagine principali, sezioni e utility - ridondanza o voci sovrapposte - discoverability delle destinazioni importanti - orientamento: titolo pagina, breadcrumb dove utili, stato attivo o contesto - comportamento mobile e menu - footer come supporto, non come discarica di link Per siti grandi, valuta hub/category pages e link contestuali. Per siti piccoli, non introdurre mega-menu o gerarchie artificiali. 6. Fiducia, privacy e riduzione del rischio percepito Individua quali dubbi può avere un utente prima dell’azione principale: - costo/prezzo - privacy e uso dei dati - account o iscrizione - affidabilità - qualità del risultato - pagamenti/rimborsi - competenza o credenziali - sicurezza - compatibilità - supporto Verifica se il sito risponde a questi dubbi nel punto giusto. Se il prodotto tratta dati personali, pagamenti, file, contenuti generati dall’utente o AI, verifica che le spiegazioni siano specifiche e non facciano promesse non dimostrate. Non chiedere di aggiungere badge o sigilli di fiducia privi di base reale. 7. Contenuto, SEO e discoverability Analizza: - intenti delle principali pagine di ingresso - title/H1 e proposta di valore - link interni - contenuti duplicati o troppo simili - pagine scarne - opportunità FAQ solo dove le domande sono reali - pagine di confronto/alternative solo se possono essere utili e accurate - localizzazione se esistono mercati linguistici distinti - contenuto che dimostra competenza reale o esperienza diretta Non creare pagine solo per intercettare keyword. Ogni pagina suggerita deve avere uno scopo utente distinto. 8. Accessibilità e mobile UX Controlla almeno: - keyboard navigation e focus - contrasto - label e messaggi di errore - touch target - reflow/zoom - modali, menu, tab e accordion - ordine logico del contenuto - testi lunghi e wrapping nelle lingue supportate - dipendenze da hover - sticky/fixed UI che copre contenuto su schermi piccoli 9. Misurazione e definizione del successo Per ogni raccomandazione principale, associa una metrica o un segnale osservabile, per esempio: - click-through sulla CTA primaria - completamento del primo task - abbandono in un passaggio specifico - error rate - conversione a contatto/acquisto/iscrizione - ritorno alla pagina o uso ripetuto - successo di ricerca interna - engagement con una demo o un esempio - feedback qualitativo degli utenti Non dichiarare una soglia universale senza dati del prodotto. Usa baseline del sito, trend nel tempo e test controllati quando possibile. 10. Priorità ed esperimenti Per ogni finding proponi: - Problema - Evidenza - Raccomandazione - Impatto previsto - Confidenza - Sforzo: Basso / Medio / Alto - Priorità: Critica / Alta / Media / Bassa - Dipendenze - Metrica di successo - Rischio o trade-off Classifica le proposte in: A. Correzioni chiare — bug o problemi di usabilità/accessibilità con evidenza forte B. Miglioramenti ad alta confidenza — probabilmente utili, ma da misurare C. Esperimenti — ipotesi che richiedono A/B test o osservazione D. Non consigliato — idee comuni che non si adattano a questo progetto Formato finale: ## Executive Summary Massimo 10 punti. ## Prodotto e percorso primario rilevati - tipo di sito/prodotto - pubblico - obiettivo primario - principali punti di ingresso - evidenze utilizzate ## Finding prioritari Per ciascuno: Evidenza · Impatto · Raccomandazione · Sforzo · Priorità · Metrica · Rischio ## Quick wins Solo interventi piccoli e a basso rischio. ## Esperimenti da validare Con ipotesi e metrica, non come fatti. ## Cose da preservare Elementi che funzionano e non dovrebbero essere semplificati/rimossi senza una ragione. ## Piano in 30/60/90 giorni Solo se ha senso per l’ampiezza del progetto; altrimenti usa un semplice ordine di priorità. Sii specifico per il sito che hai realmente esaminato. Non trasformare la revisione in una checklist generica per SaaS, ecommerce, tool AI o marketing salvo che il progetto sia davvero di quel tipo.
Revisione del rendering di Googlebot
Sei un auditor ibrido di SEO tecnico, rendering, crawlability, architettura dell’informazione, accessibilità e UX. IMPORTANTE: - Analizza il sito reale e la sua vera architettura di rendering prima di applicare raccomandazioni. - Non presumere che il sito sia statico, server-rendered, client-rendered, hydrated, costruito con un framework o dipendente da JavaScript. - Google Search può renderizzare JavaScript, ma il rendering ha limiti e i contenuti importanti non dovrebbero dipendere inutilmente dall’interazione dell’utente. - Google Search non interagisce con una pagina per attivare il caricamento dei contenuti. Tratta i contenuti che si caricano solo dopo click, hover o eventi di scroll attivati dall’utente come un rischio di crawl/indexing da verificare. - Distingui source HTML, rendered HTML e contenuto che appare solo dopo interazione. - Non dichiarare che accordion, tab, contenuti client-rendered o below-the-fold siano intrinsecamente non indicizzabili. Verifica l’implementazione. - Non giudicare solo con Lighthouse. - Non implementare ancora modifiche. Analizza questo sito: [INSERISCI URL] Se sono disponibili repository/file di progetto, ispezionali. Se sono disponibili Search Console URL Inspection, rendered HTML, server log, field Core Web Vitals o un file HAR, usali come evidenza. Dichiara chiaramente quando un’evidenza non è disponibile. ----------------------------------- FASE 1 — IDENTIFICA L’ARCHITETTURA REALE ----------------------------------- Determina, quando possibile: - framework/CMS/site builder - modello di rendering: statico, SSR, SSG, CSR, ibrido, streaming o altro - routing lato server o client - se i contenuti principali sono presenti nell’HTML iniziale - cosa viene aggiunto o sostituito da JavaScript - presenza di hydration - uso di lazy loading, infinite scroll, virtualizzazione, accordion, tab o contenuti condizionali - struttura di deploy/hosting/CDN quando rilevante per crawling e rendering Non considerare “view source” equivalente al risultato finale se il sito usa rendering client-side. Allo stesso tempo, non presumere che il rendering client-side sia automaticamente un problema. ----------------------------------- FASE 2 — ACCESSO, STATUS E DIRETTIVE ----------------------------------- Controlla: - HTTP status degli URL importanti - redirect chain e loop - robots.txt - meta robots e X-Robots-Tag - canonical - risorse necessarie al rendering accidentalmente bloccate - ambienti staging/preview indicizzabili per errore - soft 404 o route client-side che restituiscono 200 per contenuti inesistenti - autenticazione, geoblocking o cookie wall che potrebbero impedire l’accesso Distingui configurazioni intenzionali da errori. ----------------------------------- FASE 3 — HTML INIZIALE VS HTML RENDERIZZATO ----------------------------------- Per contenuti e link importanti, confronta: 1. cosa esiste nella risposta HTML iniziale 2. cosa compare dopo il normale rendering JavaScript 3. cosa compare solo dopo un’azione dell’utente Verifica in particolare: - title e meta description - canonical - H1 e contenuto principale - navigazione primaria - link interni importanti - dati strutturati - contenuti principali di prodotto/servizio/articolo - paginazione o link a elementi aggiuntivi Classifica ogni differenza importante come: - Sicuro / atteso - Da verificare - Rischio concreto Non penalizzare contenuti semplicemente perché vengono renderizzati da JavaScript se sono disponibili in modo affidabile nel DOM renderizzato. ----------------------------------- FASE 4 — CONTENUTI CHE DIPENDONO DALL’INTERAZIONE ----------------------------------- Individua contenuti o link che richiedono: - click - hover - focus - scroll event dell’utente - swipe - apertura di modali - selezione di tab - input in form - login Chiedi: - il contenuto viene comunque renderizzato nel DOM senza quell’azione? - esiste un URL crawlable alternativo? - il link è un vero <a href> quando dovrebbe esserlo? - il contenuto è importante per indicizzazione o discovery? - il pattern serve davvero all’UX oppure introduce dipendenza inutile? Accordion e tab non sono automaticamente un problema. Il rischio nasce quando contenuti o link importanti non esistono finché non avviene un’azione che il crawler non esegue. ----------------------------------- FASE 5 — LAZY LOADING, IMMAGINI E INFINITE SCROLL ----------------------------------- Verifica: - immagini above-the-fold non ritardate inutilmente - width/height o aspect-ratio riservati - src/srcset/sizes corretti - lazy loading attivato dalla visibilità o meccanismo affidabile, non da un click - contenuti lazy importanti caricabili senza richiedere un gesto dell’utente - infinite scroll con URL persistenti/paginati o altro percorso crawlable quando i contenuti devono essere scoperti - placeholder che non producono CLS significativo - media essenziali accessibili senza script di terze parti fragile Non raccomandare eager loading per tutto. Proteggi LCP senza gonfiare il traffico iniziale. ----------------------------------- FASE 6 — LINK E ARCHITETTURA INFORMATIVA ----------------------------------- Controlla: - link importanti implementati come link crawlable - anchor text descrittivo - pagine orfane - profondità di click - hub e categorie - breadcrumb dove utili - route raggiungibili solo tramite router state o eventi JavaScript senza URL navigabile - link duplicati o eccessivamente numerosi che non aiutano l’utente - navigation mobile equivalente nei percorsi essenziali Mappa il flusso verso le pagine più importanti. Non presumere che ogni pagina debba essere a un click dalla home. ----------------------------------- FASE 7 — MULTILINGUE E MULTIREGIONALE, SE PRESENTE ----------------------------------- Se il sito ha più lingue/regioni, verifica: - URL distinti e stabili - contenuto visibile nella lingua corretta - hreflang reciproco, se utilizzato - canonical coerenti - x-default se la strategia lo richiede - language switcher con link crawlable - redirect automatici o varianti solo-cookie che potrebbero nascondere versioni - contenuti regionali realmente giustificati Se il sito è monolingue, marca questa fase come Non applicabile. ----------------------------------- FASE 8 — CORE WEB VITALS E COSTO DI RENDERING ----------------------------------- Valuta con dati misurati quando disponibili: - probabile elemento LCP e request chain - CLS da immagini, font, annunci, embed, banner, consent UI, componenti dinamici o hydration - pressione INP/main-thread da JavaScript, terze parti, event handler, rendering e long task - CSS/JS render-blocking - caricamento font - sizing immagini e responsive delivery - richieste di rete non necessarie - bundle o codice duplicato Separa osservazioni lab, field data e ipotesi. ----------------------------------- FASE 9 — UX ABOVE-THE-FOLD SENZA BIAS DI DESIGN ----------------------------------- Valuta il primo viewport per: - scopo della pagina chiaro - task principale o CTA - banner/overlay invasivi - stabilità del layout - contenuto significativo che appare rapidamente - leggibilità mobile - informazioni critiche ritardate da rendering o logica di consenso Non ottimizzare solo per minimalismo visivo. Proteggi le informazioni necessarie a capire e fidarsi della pagina. ----------------------------------- FASE 10 — MOBILE, ACCESSIBILITÀ E ROBUSTEZZA ----------------------------------- Controlla: - overflow responsive - touch target - accesso da tastiera - focus state - menu/dialog/accordion/tab - label ed errori dei form - zoom/reflow - contrasto e temi se presenti - reduced motion se pertinente - problemi Safari/iOS dove l’implementazione li rende plausibili I problemi di accessibilità possono impedire anche agli utenti e ai sistemi automatici di raggiungere contenuti in modo affidabile, quindi riportali separatamente dalle preferenze cosmetiche. ----------------------------------- FORMATO DI OUTPUT ----------------------------------- ## Executive Summary Massimo 8 frasi. ## Architettura rilevata - Modello di rendering - Framework/CMS se identificato - Cosa è presente nell’HTML iniziale - Cosa dipende da JavaScript - Evidenze disponibili / non disponibili ## Problemi critici di crawl o indicizzazione Solo problemi confermati o fortemente supportati da evidenze. ## HTML iniziale vs HTML renderizzato Per contenuti e link importanti. ## Finding di rendering / JavaScript Per ciascuno: Priorità · Evidenza · URL/componente · Problema · Perché conta · Fix minimo · Metodo di verifica ## Link interni e architettura informativa ## Finding multilingue / regionali Oppure “Non applicabile”. ## Core Web Vitals / performance Separa dati misurati da ipotesi. ## Accessibilità / mobile ## Contenuti e semantica ## Quick wins Solo elementi a basso rischio con evidenza chiara. ## Roadmap delle priorità Top 10, ordinate per impatto atteso e confidenza. ## Checklist di verifica Includi Search Console URL Inspection, controlli del rendered HTML, server log, field CWV, HAR/browser profiling o crawl test solo quando pertinenti. Sii critico, tecnico e preciso. Non fornire cliché SEO generici o marketing fluff. Non presentare vecchie supposizioni sull’indicizzazione JavaScript come fatti universali. Spiega cause concrete, evidenze, effetti probabili, fix minimi e come verificare ogni finding materiale.
Suggerimento: Correggi prima i problemi ad alta priorità. Non rifattorizzare codice funzionante solo perché l’IA suggerisce un pattern più pulito.
Passaggio 7

Pubblica e migliora

Risultato: ciclo di miglioramento

Pubblica il sito, osserva cosa accade e miglioralo a piccoli passi. Un sito web non è mai definitivamente finito: diventa utile attraverso feedback, misurazioni e iterazioni attente.

Quando le funzionalità e la versione finale nella lingua sorgente sono stabili, valuta se il sito debba servire anche persone di un’altra lingua o mercato regionale. Una versione ben localizzata può rendere i contenuti più rilevanti per questi utenti e ampliare le opportunità nella ricerca organica, ma solo se la traduzione è utile, l’implementazione tecnica è corretta e il risultato viene revisionato per la locale target.

Controlli pratici:

Prompt di localizzazione

Localizzazione in lingua madre e revisione SEO
Esegui una revisione completa di localizzazione, revisione linguistica a livello madrelingua, linguaggio SEO, qualità dei prompt e implementazione per un sito web o un’applicazione web esistente che ha già raggiunto una versione stabile nella lingua sorgente. Dati del progetto: - Nome del progetto/sito: [PROJECT_OR_SITE_NAME] - URL pubblico o di anteprima: [PUBLIC_URL_OR_PREVIEW] - Lingua sorgente: [SOURCE_LANGUAGE] - Lingua target: [TARGET_LANGUAGE] - Locale/regione target: [TARGET_LOCALE] - Mercato/regione target principale: [PRIMARY_MARKET_OR_REGION] - Repository/percorso progetto: [PROJECT_PATH_OR_REPOSITORY] - Percorso contenuti nella lingua sorgente: [SOURCE_CONTENT_PATH_OR_UNKNOWN] - Percorso contenuti tradotti: [TRANSLATED_CONTENT_PATH_OR_UNKNOWN] - Framework, CMS, site builder o stack: [FRAMEWORK_OR_CMS_OR_UNKNOWN] - Pubblico target: [TARGET_AUDIENCE] OBIETTIVO Crea una versione nella lingua target che sembri ricercata, scritta, editata e pubblicata fin dall’inizio per quel locale, preservando al contempo significato del sorgente, funzionalità, architettura tecnica, accessibilità, intento SEO e comportamento del prodotto. Non è una traduzione parola per parola e non è un semplice controllo ortografico. L’obiettivo è ampliare responsabilmente il sito a utenti che cercano, leggono e prendono decisioni nella lingua o regione target. Non promettere che la sola traduzione aumenti ranking o traffico. Considera il SEO localizzato come combinazione di contenuti locali utili, URL/segnali appropriati, search intent, link interni, correttezza tecnica e qualità continua. REGOLE NON NEGOZIABILI - Ispeziona prima l’architettura reale. Non presumere sistema di build, HTML statico, framework JavaScript, CMS, database, SSR, CSR o framework di localizzazione. - Rispetta il source of truth e il flusso di generazione realmente esistenti. - Non introdurre un sistema di build solo per la localizzazione se il progetto funziona senza. - Non tradurre codice, identificatori, URL, nomi di prodotto, brand, variabili, placeholder, API key, selector o sintassi template salvo richiesta esplicita. - Non modificare testo fornito dall’utente che deve rimanere sorgente. - Preserva il comportamento dei prompt e della logica dinamica prima di migliorarne l’eleganza linguistica. - Distingui errori oggettivi, raccomandazioni forti e preferenze stilistiche. - Non inventare fatti, keyword volume, requisiti legali, feature, testimonianze o prove. - Non dichiarare che una revisione è stata fatta da un madrelingua umano se non è vero. - Non dichiarare un browser pass se non hai realmente controllato il sito renderizzato in un browser. - Implementa modifiche minime e tracciabili; evita refactoring non correlati. FASE 0 — INVENTARIO DEL PROGETTO E DELLA LOCALIZZAZIONE Prima di tradurre, identifica: - lingue e locale supportati - route pubbliche e struttura URL - sorgenti dei contenuti e output generati - file di traduzione o directory per locale - componenti/template condivisi - navigazione, footer, breadcrumb e language switcher - form, messaggi di validazione, notifiche e stati di errore - metadata SEO e Open Graph - structured data - alt text e label di accessibilità - email o messaggi utente memorizzati nel progetto - prompt/template/generatori o altri contenuti dinamici, se presenti - test, CI e quality gate esistenti - eventuali file o route che non puoi ispezionare Indica chiaramente ciò che non è accessibile. Non sostenere di aver revisionato “l’intero sito” se manca parte del contenuto. FASE 1 — TRADUZIONE E LOCALIZZAZIONE DI BASE Traduci il significato, non la struttura grammaticale della lingua sorgente. Per ogni elemento visibile o potenzialmente visibile controlla: - grammatica - ortografia - punteggiatura - maiuscole/minuscole - articoli, preposizioni e concordanza - ordine naturale delle parole - registro e forma di cortesia - formulazioni idiomatiche - convenzioni di data, ora, numeri, valuta e unità - terminologia del settore - chiarezza per il pubblico target - lunghezza in pulsanti, tab, menu e layout mobile Evita calchi, sintassi troppo vicina all’inglese e marketing artificiale. Non migliorare la fluidità cambiando il significato. FASE 2 — TERMINOLOGIA E DECISIONI REGIONALI Crea un piccolo glossario operativo basato sui termini che compaiono davvero nel progetto. Per ogni termine importante decidi se: 1. tradurlo 2. mantenerlo in inglese perché è standard nel settore 3. mantenerlo ma spiegarlo al primo uso 4. usare una forma ibrida consolidata 5. adattarlo grammaticalmente 6. usare una variante specifica della regione 7. evitarlo perché innaturale, ambiguo o superato Considera: - uso reale dei madrelingua nel locale target - terminologia professionale - livello di competenza del pubblico - search intent - coerenza con il resto del prodotto - differenze tra locale che condividono la stessa lingua Non decidere globalmente che tutti i termini tecnici devono restare in inglese o essere tradotti. FASE 3 — CONTENUTI DINAMICI, UI E TEMPLATE Se il progetto compone testo dinamicamente, testa la frase finale e non solo i frammenti. Controlla: - placeholder nell’ordine corretto - variabili non tradotte accidentalmente - valori inseriti che si accordano grammaticalmente - singolare/plurale/genere/caso quando pertinenti - punteggiatura e spazi dopo l’inserimento - campi opzionali vuoti che non creano frasi rotte - virgolette, apostrofi e line break - messaggi di loading, empty, success, error e retry - label dei form e messaggi di validazione - pulsanti copy/edit/reset/submit - testo in dialog, tooltip, menu, tab e accordion - stringhe accessibili che non compaiono visivamente Se il progetto non ha contenuti dinamici, marca questa fase come Non applicabile. FASE 4 — PROMPT, AI O CONTENUTO GENERATIVO, SOLO SE PRESENTE Se il prodotto include prompt, generatori o funzioni AI, tratta i prompt come istruzioni funzionali e non come semplice copy. Per ogni prompt verifica: - linguaggio naturale nella lingua target - significato e risultato richiesto equivalenti al sorgente - istruzioni non contraddittorie - output language esplicita quando serve - placeholder e testo citato preservati - nomi di provider usati solo quando necessari - nessuna promessa di accuratezza garantita - nessuna richiesta di chain-of-thought privata - nessuna dipendenza non necessaria da feature specifiche di un provider - liste, paragrafi e separatori multilinea ancora leggibili - input lungo, minimo, caratteri speciali, virgolette e campi opzionali quando rilevanti Per le funzioni di traduzione, distingui chiaramente lingua sorgente, lingua target, revisione linguistica, riscrittura, localizzazione e transcreation. Se non esistono funzioni AI/prompt, marca questa fase come Non applicabile. FASE 5 — SEO LOCALIZZATO E INTENTO REGIONALE Prima identifica la strategia SEO e routing reale del progetto. Controlla, quando pertinenti: - title localizzato - meta description - H1/H2/H3 - anchor text e link interni - breadcrumb - slugs/URL quando la localizzazione delle route fa parte dell’architettura - canonical - hreflang e codici lingua/regione - x-default se previsto dalla strategia - sitemap - Open Graph - structured data - alt text - dichiarazione lang - language switcher con link crawlable Ricerca o verifica il search intent regionale per decisioni SEO importanti. Non tradurre keyword alla lettera presumendo che gli utenti cerchino allo stesso modo. Non creare pagine locali doorway o varianti regionali senza valore distinto. Non promettere aumento di ranking o traffico. FASE 6 — ACCURATEZZA FATTUALE, LEGALE E CONTENUTI AD ALTO RISCHIO Segnala separatamente affermazioni che richiedono verifica, per esempio: - prezzi - disponibilità di feature - comportamento attuale di piattaforme o modelli AI - requisiti legali o privacy - tasse, finanza, salute o sicurezza - statistiche - ranking o benchmark - requisiti specifici di un paese Non “correggere” silenziosamente una pretesa tecnica o legale mentre traduci. Classificala come finding e usa fonti autorevoli se viene richiesta una verifica esterna. FASE 7 — ACCESSIBILITÀ E LINGUAGGIO UX Controlla: - alt text - aria-label e accessible name - scopo dei link - istruzioni expand/collapse - messaggi di errore - label di language switcher - controlli solo-icon - testo per screen reader - label brevi su mobile - coerenza tra verbo della CTA e risultato Il testo di accessibilità deve descrivere funzione e scopo, non solo l’aspetto visivo. FASE 8 — PRIMO PASSAGGIO DI REVISIONE LINGUISTICA INDIPENDENTE Dopo la traduzione iniziale, rileggi tutti i contenuti modificati come editor esperto della lingua target. Questo primo passaggio deve cercare in particolare: - traduzioni letterali - ordine delle parole innaturale - anglicismi inutili - termini tecnici incoerenti - registro regionale errato - frasi troppo lunghe o difficili - ripetizioni - maiuscole incoerenti - CTA innaturali - heading goffi - formattazione di liste/line break rotta nei prompt lunghi - placeholder/variabili modificati - deriva di significato Non eseguire sostituzioni globali ampie senza controllare ogni contesto. FASE 9 — IMPLEMENTAZIONE Implementa solo modifiche revisionate e accettate. Durante l’implementazione: - preserva encoding e formattazione quando pratico - preserva source of truth e flusso di output generato - preserva translation key e placeholder - preserva HTML/Markdown/JSX/template - preserva codice e termini protetti - evita refactoring non correlati - evita rumore da riformattazione dell’intero file - aggiorna sorgente, metadata, schema, route/config e output insieme solo se l’architettura lo richiede - segui le regole di build e deployment esistenti Non modificare l’output generato al posto del suo sorgente salvo che il progetto lo definisca come source of truth mantenuto. FASE 10 — QA TECNICA Esegui i controlli esistenti pertinenti, per esempio: - build - lint - type checking - unit/integration/E2E - validazione delle translation key - traduzioni mancanti/duplicate - coerenza dei placeholder - link interni - validazione HTML/JSON/YAML/schema - accessibilità - metadata SEO - canonical/hreflang - responsive/overflow - test browser - parità dell’output generato Non indebolire un test solo per farlo passare. Aggiorna i test basati su testo esatto quando una modifica approvata cambia legittimamente il testo visibile. FASE 11 — SECONDO PASSAGGIO DI REVISIONE LINGUISTICA INDIPENDENTE Dopo implementazione e rebuild/rendering, esegui una seconda revisione completa dal punto di vista di un editor madrelingua esperto. Questo secondo passaggio è obbligatorio e non deve ripetere meccanicamente la checklist del primo. Leggi la formulazione finale nel contesto e confrontala di nuovo con il significato del sorgente. Controlla in particolare: - ogni pagina/route modificata - title e meta description - H1/H2/H3 - navigazione/breadcrumb modificati - pulsanti e CTA - form e stati di validazione - prompt lunghi e line break intenzionali - esempi e composizioni dinamiche con placeholder - label e wrapping mobile - label di accessibilità - contenuto visibile e nascosto/progressivo - link interni localizzati - vocabolario e registro del locale - nessun frammento sorgente salvo nomi/termini/esempi intenzionali - nessuna deriva regionale, soprattutto tra più varianti della stessa lingua Quando possibile, rileggi il sito renderizzato e non soltanto i file sorgente. Se non è disponibile un browser, dichiara il limite ed esegui il secondo passaggio a livello sorgente senza sostenere di aver svolto una revisione renderizzata. FASE 12 — VERIFICA FINALE Prima di considerare completa la locale: 1. riesegui la scansione dei file modificati per testo sorgente non tradotto 2. riesegui la scansione per wording rifiutato/sostituito 3. verifica placeholder, variabili, interpolazione e comportamento dei prompt 4. verifica route localizzate e link interni 5. verifica canonical/hreflang se pertinenti 6. verifica metadata, alt e label di accessibilità 7. verifica structured data se presente 8. esegui build e test pertinenti 9. controlla pagine rappresentative su telefono, tablet e desktop quando possibile 10. controlla modalità chiara/scura se presenti 11. rileggi ancora una volta il contenuto modificato come prosa continua e naturale, non solo frase per frase OUTPUT / REPORT Fornisci: ## Riepilogo della localizzazione - lingua e locale target - file/route modificati - architettura/sistema di localizzazione rilevato - cosa è stato tradotto/localizzato - cosa è stato intenzionalmente lasciato invariato ## Decisioni terminologiche Termini importanti tradotti, mantenuti, spiegati o regionalizzati. ## Finding e decisioni Per ogni punto importante: ID · Gravità · Tipo · Testo sorgente · Testo target attuale · Proposta · Motivazione · Stato (Accettato/Modificato/Rifiutato/Decisione umana necessaria) · Riferimento implementazione ## Decisioni SEO/regionali URL, strategia hreflang/canonical, slug e adattamenti dell’intento solo se pertinenti. ## Prima revisione linguistica Cosa è stato controllato/corretto. ## Seconda revisione linguistica Conferma che si è svolto un secondo passaggio distinto, cosa ha rilevato e se ha riguardato pagine renderizzate o soltanto sorgenti. ## Validazione tecnica Solo test/controlli realmente eseguiti e risultati. ## Rischi o decisioni umane rimanenti Legale, fattuale, terminologia, mercato, layout o browser. ## File modificati Elenco esatto. STANDARD FINALE La versione localizzata deve suonare naturale per il pubblico target, preservare significato e comportamento del prodotto, rispettare l’architettura reale, usare terminologia appropriata al locale, restare coerente sul piano tecnico e SEO e ricevere un seconda revisione linguistica indipendente dopo l’implementazione. Non definire la localizzazione “native-reviewed”, “human-reviewed”, “legally reviewed” o “browser-tested” se tale revisione non è realmente avvenuta.
Passaggio successivo: usa il Generatore di prompt per scrittura ed email per i testi delle pagine e il Generatore di prompt per immagini IA per i concetti visivi.
Conclusione

Un sito web non è mai solo codice

L’IA può aiutarti a pianificare pagine, scrivere testi, generare codice e controllare il risultato, ma il sito ha comunque bisogno del tuo giudizio. Un buon sito non è quello con più funzionalità; è quello che le persone capiscono, di cui si fidano e che possono usare senza attriti.

Tre cose contano più dell’aggiunta di nuove funzionalità:

  1. Chiarezza: i visitatori dovrebbero capire in pochi secondi a cosa serve il sito.
  2. Fiducia: caricamento veloce, contenuti leggibili, link funzionanti e informazioni trasparenti fanno percepire il sito come reale e affidabile.
  3. Controllo: codice statico e semplice è più facile da testare, gestire e ripristinare quando qualcosa si rompe.

Parti in modo semplice, mantieni la struttura statica e leggibile, verifica personalmente ogni modifica importante e migliora un problema alla volta. È così che un sito assistito dall’IA diventa qualcosa di affidabile invece dell’ennesima bozza generata.

Parti dalla chiarezza

Prendi oggi la prima decisione per il tuo sito

Un obiettivo chiaro e un piano delle pagine evitano gran parte delle rilavorazioni inutili. Inizia da qui prima di chiedere all’IA di scrivere codice o testi.

Condividi questa pagina

Aggiungi PromptingEasy alla schermata

Usa il menu del browser e scegli l’opzione per installare questo sito o aggiungerlo alla schermata Home.