Créer votre site web avec l’IA : du plan au lancement

Un flux de travail pratique pour un site web rapide et utile.

Utilisez l’IA pour planifier votre site, rédiger ses textes, créer des prompts de code, vérifier la qualité et préparer le lancement — tout en gardant un site que vous pouvez comprendre, adapter et maintenir vous-même.

Un bon site construit avec l’IA nécessite toujours des décisions humaines : l’objectif, le public, la structure des pages et le niveau de qualité. Ce guide maintient un flux de travail static-first et vérifiable, afin que l’IA accélère le travail sans créer une base de code que personne ne comprend.

Périmètre honnête : il s’agit d’un flux de travail pratique pour créer un site web, et non de conseils juridiques, de sécurité ou commerciaux. Faites appel à des professionnels qualifiés pour les contrats, les secteurs réglementés, les flux de paiement et les données sensibles.

Votre parcours de création de site en 7 étapes

Définissez l’objectif, planifiez la structure, construisez une première version et ne lancez qu’après une revue qualité ciblée.

Phase 1

Définir le site web

Clarifiez l’objectif et créez une structure de pages qui le soutient.

Étape 1

Définissez l’objectif du site

Résultat : objectif du site

Commencez par la fonction du site. Un outil d’une page, une page de service local, un portfolio et une page de destination SaaS nécessitent des contenus et une navigation différents.

Vérifications pratiques :

Générateur de promptsPrompt d’objectif du site — remplacez les mots surlignés, puis envoyez-le à ChatGPT
Aide-moi à définir l’objectif d’un site web ou d’une application web. Le projet est [décrire le projet]. Le public principal est [public]. L’action principale que je veux que les visiteurs accomplissent est [action]. Donne-moi : 1) une proposition de valeur claire, 2) le minimum de pages ou d’écrans nécessaires, 3) ce qu’il vaut mieux éviter de construire au départ et 4) les signaux de confiance les plus importants.
Étape 2

Planifiez les pages

Résultat : plan des pages

Avant d’écrire du code, créez un petit plan du site et décidez à quelles questions chaque page doit répondre. Cela évite que l’IA génère des sections aléatoires qui semblent jolies mais n’aident pas les utilisateurs.

Vérifications pratiques :

Générateur de promptsPrompt de plan de site — remplacez les mots surlignés, puis envoyez-le à ChatGPT
Crée un plan de site ou un plan de pages pratique pour [idée de site web]. Garde la structure aussi simple que le projet le permet réellement. Pour chaque page, donne-moi : objectif, H1, courte méta-description, sections clés, CTA principal et liens internes vers les pages associées. Évite les pages en double, le contenu pauvre et la complexité architecturale sans besoin clair pour l’utilisateur, l’activité ou le SEO.
Phase 2

Choisir et construire

Sélectionnez une configuration réaliste, préparez le contenu et créez la première version.

Étape 3

Choisissez la configuration technique

Résultat : décision technique

Un site web simple devrait être ennuyeux au meilleur sens du terme : HTML lisible, CSS ciblé, JavaScript minimal et hébergement rapide par défaut. Pour de nombreux petits sites, une configuration static-first suffit : vos pages sont des fichiers, pas une application lourde qui nécessite un serveur pour chaque visiteur.

Vérifications pratiques :

Prompt pour compétences de programmation IA
Vous travaillez sur mon projet de site web ou d’application web. Avant toute modification, inspectez le projet existant et identifiez son architecture réelle. Ne partez pas du principe qu’il utilise du HTML statique, du JavaScript vanilla, un framework, un CMS, un système de build, du Critical CSS, un mode sombre, un routage multilingue, un rendu serveur, un rendu client, ni un fournisseur particulier d’analytics, de publicité, de consentement, d’hébergement ou de CDN. Identifiez d’abord, lorsque c’est possible : - framework, CMS, constructeur de site ou absence de framework - modèle de rendu : statique, serveur, client, hybride ou inconnu - configuration de build et de déploiement, si elle existe - approche de style et organisation du CSS - architecture JavaScript ou TypeScript - structure des composants, templates ou pages - langues et locales prises en charge - outils de test, linting, formatage et CI - hébergement/CDN - analytics, publicité, consentement, authentification, paiements, embeds et autres services tiers - contraintes de performance et besoins réels des utilisateurs et de l’activité Règle principale : Respectez l’architecture existante qui fonctionne. Ne forcez pas le projet vers un autre stack simplement parce qu’une autre approche vous paraît plus propre ou plus familière. Si le projet n’a pas de système de build, n’en introduisez pas un uniquement par commodité. S’il utilise déjà un framework, un CMS, un modèle de composants, un bundler ou une couche serveur, travaillez dans cette architecture sauf raison claire et étayée de la modifier. Objectifs principaux : - expérience utilisateur rapide et stable - bons Core Web Vitals lorsqu’ils sont pertinents - coût d’exécution inutile aussi faible que possible - code maintenable et compréhensible - faible risque de régression - SEO moderne et accessibilité - comportement responsive fiable - mise en œuvre sûre et respectueuse de la vie privée - impact tiers inutile minimal - modifications adaptées au projet réel plutôt qu’à un idéal théorique Méthode de travail pour chaque tâche : 1. Comprenez l’architecture et le résultat demandé. 2. Identifiez l’ensemble minimal de fichiers et composants à modifier. 3. Tenez compte de la performance, de l’accessibilité, du SEO, de la sécurité, de la confidentialité, du responsive, de la localisation et de la compatibilité navigateur lorsque c’est pertinent. 4. Préférez les conventions existantes du projet à l’invention de schémas parallèles. 5. Implémentez le plus petit changement justifié. 6. Évitez les refactorings sans rapport et le reformatage complet de fichiers. 7. Exécutez les validations, tests, lint, type checks, builds ou tests navigateur existants lorsqu’ils sont disponibles et pertinents. 8. Indiquez précisément ce qui a changé, ce qui a été testé et les incertitudes restantes. Principes d’architecture : - L’architecture compte plus que la minification aveugle ou les réécritures à la mode. - Gardez le code source suffisamment lisible pour la maintenance et le débogage. - N’ajoutez pas de dépendance sans bénéfice clair. - Ne dupliquez pas les responsabilités entre composants, templates, CSS ou JavaScript. - Supprimez du code mort uniquement après avoir vérifié qu’il est réellement inutilisé. - Préférez l’amélioration progressive et la dégradation élégante lorsqu’elles conviennent au produit. - Préservez le comportement public existant sauf si la tâche demande explicitement de le changer. - Évitez les modifications globales larges lorsqu’un correctif local suffit. Principes de performance : - Optimisez le chemin critique de rendu selon le modèle de rendu du projet. - Protégez la stabilité de la mise en page : images, annonces, embeds, polices, navigation, UI de consentement et zones dynamiques ne doivent pas provoquer de décalages évitables. - Évitez l’exécution JavaScript, l’hydratation, les rendus, le travail DOM, les écouteurs, reflows et repaints inutiles. - Préférez transform et opacity lorsque l’animation est appropriée. - Respectez prefers-reduced-motion. - Chargez plus tard les ressources non critiques lorsque c’est sûr et cohérent avec le stack. - Utilisez preload ou preconnect uniquement lorsque leur bénéfice est clair. - Justifiez chaque requête réseau, dépendance et fonctionnalité runtime supplémentaire. - Si l’application a réellement besoin de beaucoup de JavaScript côté client, optimisez-le au lieu d’essayer de le supprimer aveuglément. HTML, templates et composants : - Utilisez une structure sémantique lorsque le projet le permet. - Gardez une hiérarchie de titres compréhensible. - Préservez les labels, noms accessibles et la sémantique correcte des liens/boutons. - Évitez les wrappers et la complexité DOM inutiles. - Gardez le contenu important disponible sous une forme explorable et rendable adaptée au projet. - Ne déplacez pas du texte important dans des images ou canvas lorsque du texte normal convient mieux. CSS et styles : - Suivez le système de style réel : fichiers CSS, modules, CSS-in-JS, classes utilitaires, design tokens, styles de composants ou autre approche établie. - Évitez les règles inutilisées ou dupliquées. - Évitez la spécificité inutile et les surcharges fragiles. - Gardez un comportement responsive prévisible. - Si un mode sombre ou des thèmes existent, préservez-les et testez les états concernés. - Si du Critical CSS existe, gardez-le synchronisé avec le style final et limitez-le aux besoins réellement critiques du premier rendu. - N’introduisez pas une nouvelle méthode de style uniquement par préférence personnelle. JavaScript et logique applicative : - Utilisez aussi peu de logique runtime que le produit le permet raisonnablement, sans considérer JavaScript comme un défaut en soi. - Préservez les conventions de framework et de gestion d’état qui fonctionnent. - Évitez les requêtes DOM, écouteurs dupliqués, calculs répétés et layout thrashing inutiles. - Utilisez la délégation d’événements lorsqu’elle est appropriée, pas comme règle universelle. - Gérez les états de chargement, vide, erreur et réessai lorsque la fonctionnalité en a besoin. - Utilisez cache ou mémoïsation uniquement si un bénéfice est démontré. - N’ajoutez pas de polyfills pour d’anciens navigateurs sauf si le projet les prend explicitement en charge. Principes SEO : - Préservez ou améliorez l’indexabilité, les signaux canonical, les liens internes, les métadonnées, les données structurées et la navigation explorable lorsque c’est pertinent. - Ne supposez pas que chaque projet a besoin de hreflang, d’un sitemap, de données structurées ou d’un rendu serveur ; inspectez ce qui existe et ce dont le site a réellement besoin. - Pour les sites rendus avec JavaScript, distinguez HTML initial et HTML rendu et vérifiez que le contenu et les liens importants sont disponibles pour les moteurs de recherche. - Gardez titres, descriptions, headings, canonicals et signaux de locale cohérents avec l’objectif réel de la page. - Évitez les pages pauvres, dupliquées, doorway ou générées mécaniquement. Principes multilingues et de localisation : - Si le projet est multilingue, préservez les routes par locale, le changement de langue, les relations canonical/hreflang, les métadonnées localisées et la terminologie régionale. - Ne hardcodez pas de texte visible en JavaScript si le système de localisation existant offre un meilleur emplacement. - Ne supposez pas qu’une traduction a la même longueur que le texte source. - Préservez placeholders, variables, code, URLs, noms de produits et texte source fourni par l’utilisateur sauf si la tâche demande de les modifier. - Si le projet est monolingue, n’introduisez pas d’infrastructure de localisation sans besoin réel. Principes d’accessibilité : - Préservez l’utilisation au clavier et les états de focus visibles. - Utilisez des boutons et liens sémantiques pour actions et navigation. - Utilisez ARIA uniquement lorsque c’est nécessaire et correct. - Maintenez un contraste suffisant et ne transmettez pas une information essentielle uniquement par la couleur. - Prenez en charge zoom, reflow, interaction tactile et réduction des animations lorsque pertinent. - Vérifiez labels de formulaires, erreurs, dialogues, mises à jour dynamiques et contrôles uniquement par icône. Principes responsive et navigateur : - Prenez en charge les navigateurs et appareils réellement ciblés par le projet. - Sauf indication contraire, considérez les versions actuelles de Chrome, Safari, Firefox, Edge, Safari iOS et les navigateurs Android courants. - Vérifiez les layouts desktop, ordinateur portable, tablette et téléphone lorsque le changement peut affecter la mise en page. - Évitez que des fonctions essentielles dépendent uniquement du hover. - Évitez le débordement horizontal et les hauteurs de viewport instables. - Portez une attention particulière à Safari/iOS lorsque CSS moderne, UI sticky/fixed, unités de viewport, formulaires ou scroll sont concernés. Principes pour les tiers : - Traitez analytics, publicité, plateformes de consentement, paiements, chat, cartes, embeds, authentification et autres tiers comme des dépendances propres au projet. - Ne les ajoutez ni ne les retirez sans comprendre leur rôle, leurs exigences de consentement et leur impact métier. - La conformité du consentement passe avant les astuces de performance. - Retardez le travail tiers non essentiel lorsque c’est approprié et supporté. - Évitez trackers ou initialisations en double. - Réservez l’espace de mise en page pour annonces ou embeds si le projet les utilise. Sécurité et confidentialité : - N’exposez pas secrets, clés privées, tokens, données personnelles ou logs sensibles dans le code client ou les fichiers publics. - Respectez les headers de sécurité, CSP, authentification, validation et modèle de traitement des données existants. - N’affaiblissez pas validation, assainissement, autorisation ou consentement par commodité. - Signalez les changements à risque au lieu de deviner. Checklist de régression après un changement pertinent : - layout desktop, tablette et mobile - mode clair/sombre ou autres thèmes s’ils existent - navigation et parcours principaux - formulaires et validation - changement de langue s’il existe - canonical/hreflang/métadonnées si concernés - analytics/consentement/publicité si concernés - accessibilité et clavier - états chargement/vide/erreur/dynamiques - aucune nouvelle requête ou coût runtime inattendu - aucune régression SEO ou sécurité évidente Pour toute livraison de code, fournissez toujours : - résumé court - liste exacte des fichiers modifiés - pourquoi le changement convient à ce projet - impact performance lorsque pertinent - impact SEO/accessibilité/sécurité lorsque pertinent - tests ou checks réellement exécutés - risques, limites ou points volontairement laissés inchangés Ne prétendez pas qu’un test, un passage navigateur, une amélioration de performance, SEO ou sécurité a été vérifié s’il ne l’a pas réellement été.
Règle technique pratique : construisez la version la plus petite qui puisse être rapide, compréhensible et maintenable. N’ajoutez de la complexité que lorsqu’un besoin réel des utilisateurs l’exige.
Étape 4

Créez les textes et les visuels

Résultat : brief de textes et de visuels

Une fois la structure claire, générez les textes de la page et les prompts d’images. Conservez le texte visible en HTML, et non intégré dans les images, afin qu’il reste accessible, traduisible et indexable.

Générateur de promptsPrompt de texte pour page de destination — remplacez les mots surlignés, puis envoyez-le à ChatGPT
Rédige le texte d’une page de destination pour [idée de site web]. Public : [public]. CTA principal : [CTA]. Ton : [ton]. Recommande uniquement les sections qui servent l’objectif de la page. Selon le besoin, envisage un hero, des bénéfices, des preuves ou éléments de confiance, une FAQ et le microtexte du pied de page. Garde un langage clair, utile, précis et sans exagération.
Étape 5

Construisez la première version

Résultat : première version fonctionnelle

Demandez à l’IA de petites modifications faciles à relire plutôt qu’une réécriture complète. Une page, un composant ou un problème à la fois est plus facile à tester et plus sûr pour les performances.

Vérifications pratiques :

Avant de mettre du code en production : lisez-le, testez-le sur mobile et ordinateur, et conservez une sauvegarde de la dernière version fonctionnelle.
Phase 3

Auditer et lancer

Vérifiez la qualité, publiez avec prudence et améliorez à partir de l’usage réel.

Étape 6

Auditez avant le lancement

Résultat : audit de lancement

Avant la mise en ligne, examinez le site sous quatre angles : qualité du code, visibilité dans la recherche, rendu par Googlebot et clarté pour les vrais utilisateurs. Séparez les audits afin que chaque prompt reste ciblé et que les retours soient exploitables.

Utilisez l’IA pour préparer l’audit, pas pour prendre la décision finale à votre place. Le résultat utile est une courte liste de problèmes que vous pouvez vérifier vous-même sur un appareil réel avant de modifier les fichiers de production.

Pour un audit utile, téléchargez votre projet actuel sous forme de fichier ZIP et importez-le dans l’outil d’IA avec le prompt correspondant. Pour les revues de rendu et de performances, capturez également un fichier HAR depuis Chrome DevTools : ouvrez DevTools, passez au panneau Network, rechargez la page, puis exportez les requêtes enregistrées au format HAR. Un lien de page web normal ne peut pas ouvrir directement DevTools de manière sûre dans le navigateur d’un visiteur ; utilisez donc le guide officiel d’export HAR de Chrome DevTools lorsque vous avez besoin d’instructions étape par étape. Examinez les fichiers HAR avant de les partager, car ils peuvent contenir des URL, des cookies ou d’autres données sensibles liées aux requêtes.

Prompts d’audit

Audit de la qualité du code
Vous êtes un auditeur senior, conservateur, du code frontend et des applications web. IMPORTANT : - Ne corrigez rien pour l’instant et ne réécrivez aucun fichier. - Inspectez d’abord le projet et identifiez son architecture réelle, son modèle de rendu, son build/déploiement, son système de styles, son stack JavaScript/TypeScript, son modèle de localisation et ses services tiers. - Ne supposez pas HTML statique, JavaScript vanilla, framework, CMS, Critical CSS, mode sombre, système de build ou fournisseur particulier. - Évaluez le projet dans ses besoins réels et son architecture établie. Ne recommandez pas de remplacer le stack simplement parce que vous en préférez un autre. - Signalez des findings spécifiques avec fichier et ligne/sélecteur/composant lorsque possible. - Séparez problèmes vérifiés, hypothèses et préférences. Vérifiez systématiquement, mais appliquez uniquement les sections pertinentes : 1. Architecture et source de vérité - responsabilités dupliquées ou implémentations parallèles - fichiers générés modifiés au lieu de leurs sources - composants/templates qui divergent sans raison - helpers morts, couches de compatibilité obsolètes ou configuration dupliquée - changements incompatibles avec les conventions framework/CMS/build - responsabilités floues entre serveur, client, template, composant et styles 2. HTML, templates et composants - markup invalide ou fragile, IDs dupliqués, problèmes de balises/attributs - labels, noms accessibles ou alt text manquants ; mauvaise sémantique - imbrication et complexité DOM inutiles - cohérence des headings et landmarks - blocs répétés qui devraient utiliser un composant/template partagé existant - contenu ou navigation disponible seulement après une interaction inutile 3. Rendu et premier affichage - identifiez statique, SSR, SSG, CSR, hybride, streaming, hydratation ou autre modèle - risques de layout shift via images, polices, annonces, embeds, bannières, contenu asynchrone ou styles tardifs - ressources bloquantes et travail client inutile - mismatches d’hydratation, double rendu, flash ou remplacement tardif de contenu lorsque pertinent - si Critical CSS existe : contradictions avec CSS final et géométrie de premier rendu manquante - si aucun système de Critical CSS n’existe, ne recommandez pas d’en ajouter sans preuve de besoin 4. Styles - règles dupliquées, inutilisées, contradictoires ou trop globales - spécificité inutile, abus de !important et hypothèses fragiles de cascade - media queries redondantes ou breakpoints incohérents - espacements, largeurs, typographie ou variantes divergentes entre pages similaires - couverture des thèmes si mode sombre/thèmes existent - effets globaux accidentels provenant de styles locaux - design tokens/variables partagés contournés sans raison 5. JavaScript / TypeScript / logique framework - bugs probables, code mort, logique dupliquée et problèmes d’état global - écouteurs, requêtes DOM, rendus, effects, subscriptions ou observers inutiles - reflow/layout thrashing - état périmé, race conditions, nettoyage ou memory leaks - états de chargement, erreur, vide, annulation et réessai manquants si nécessaires - logique de layout en JS que CSS résoudrait plus fiablement - hydratation ou client components inutiles dans les frameworks - anti-patterns du framework uniquement s’ils sont réellement présents 6. Build, dépendances et déploiement - dépendances inutiles ou paquets dupliqués - étapes de build fragiles, dérive de output généré, hypothèses d’environnement - source maps, debug, secrets ou artefacts internes exposés publiquement - cache/versioning - règles de déploiement pouvant servir des assets obsolètes ou incohérents - s’il n’y a pas de build, n’en introduisez pas un uniquement pour l’audit 7. Tiers et confidentialité - analytics, ads, CMP/consentement, embeds, cartes, chat, paiements, authentification et autres tiers uniquement s’ils existent - initialisation dupliquée, requêtes inutiles, blocage, ordre de consentement incorrect ou layout shifts - preconnect/preload sans bénéfice clair - données sensibles exposées au client ou à des services externes 8. UX et responsive - overflow mobile, layouts instables, touch targets, collisions fixed/sticky - navigation et parcours principaux sur les types de page concernés - fonctions essentielles uniquement au hover - états cassés aux largeurs téléphone, tablette et desktop courantes - risques Safari/iOS lorsque l’implémentation les rend plausibles 9. Accessibilité - clavier et gestion du focus - formulaires, labels, erreurs, dialogues, menus, accordions, tabs et contrôles uniquement par icône - contraste et thèmes si pertinent - ARIA inutile ou incorrect - reduced motion, zoom, reflow et problèmes de lecteur d’écran 10. SEO et crawlabilité - titles, descriptions, headings, canonicals, indexabilité, liens internes, données structurées, sitemap, hreflang et robots uniquement lorsque applicable - contenu ou liens importants absents du HTML initial/rendu - navigation JavaScript-only non crawlable de façon fiable - pages dupliquées/pauvres et conflits canonical accidentels Focus cohérence : - Des pages/composants similaires diffèrent-ils sans raison en largeur, espacement, typographie, comportement ou structure ? - Existe-t-il des copies qui doivent rester synchronisées manuellement ? - Plusieurs sessions IA/développement ont-elles probablement créé des patterns concurrents ? - Existe-t-il un correctif plus petit qui préserve mieux l’architecture ? Format de sortie : ## Résumé exécutif (5 phrases max.) ## Architecture détectée Indiquez ce qui est vérifié et ce qui reste inconnu. ## Findings Pour chaque problème : Priorité (Critical/High/Medium/Low) · Statut de preuve (Vérifié/Probable/À vérifier) · Fichier:ligne/composant · Zone · Problème · Pourquoi c’est important · Risque du changement · Correctif minimal ## Incohérences entre pages/composants ## Copies ou sources générées à garder synchronisées ## Gains rapides (moins de 10 min) ## Ordre de correction sûr (le plus sûr d’abord) ## Éléments non applicables Listez les grandes zones volontairement ignorées parce que le projet ne les utilise pas.
Revue SEO
Vous êtes un auditeur senior en SEO technique pour un site web ou une application web. IMPORTANT : - Ne modifiez rien pour l’instant. - Ne donnez pas de conseils génériques. - Identifiez d’abord le modèle de rendu réel, le routing, la localisation, le CMS/framework/build et la structure publique des URLs. - Signalez uniquement des findings concrets du projet existant, avec preuve fichier/composant et page/URL lorsque possible. - Appliquez les contrôles de façon conditionnelle. Ne supposez pas que le projet est statique, multilingue, rendu côté serveur, dispose d’un sitemap, utilise des données structurées ou a besoin de hreflang. - Séparez problèmes vérifiés, recommandations et expériences. Vérifiez systématiquement : 1. Accès des moteurs et rendu - les moteurs peuvent-ils accéder aux URLs importantes sans authentification ou ressources bloquées ? - distinguez HTML source, HTML rendu et contenu nécessitant une interaction - identifiez contenu/liens importants dépendant inutilement de l’exécution côté client - sur les sites JavaScript, vérifiez que texte, métadonnées et liens crawlables apparaissent dans le HTML rendu - identifiez conflits noindex, robots, canonical, redirection, code HTTP ou rendu accidentels 2. SEO on-page - title concis, descriptif et unique pour chaque page importante ; ne traitez pas 50–60 caractères comme une limite Google rigide - méta-description utile et propre à la page ; Google peut la tronquer ou générer un autre extrait - titles/descriptions dupliqués et problèmes liés aux templates - sujet, intention de recherche et hiérarchie de contenu clairs - contenu visible soutenant réellement l’objectif de la page 3. Headings et sémantique - sujet principal sans ambiguïté et structure de headings logique - pas de sauts de niveau ni de faux headings visuels sans raison - landmarks et structure sémantique utiles lorsque pertinent 4. Canonicalisation et URLs - signaux canonical valides et cohérents quand des doublons/quasi-doublons existent - les canonicals autoréférentiels peuvent être une bonne convention, pas une obligation universelle - URLs propres, stables et crawlables - chaînes de redirection, paramètres dupliqués, incohérences slash, host/protocole mélangés ou URLs de staging accidentelles 5. SEO multilingue/multirégional, uniquement si applicable - URLs séparées et crawlables pour variantes langue/région quand l’architecture le permet - hreflang réciproque avec codes valides et x-default approprié lorsqu’utilisé - canonical et hreflang sans contradiction - pages localisées avec contenu principal, navigation, métadonnées et liens internes réellement localisés - changement langue/région crawlable, pas uniquement redirections automatiques ou cookies - variantes régionales justifiées par public/intention, pas dupliquées mécaniquement 6. Découverte et maillage interne - liens HTML crawlables avec href réel - pages orphelines ou inutilement profondes - navigation, breadcrumbs, liens associés et ancres contextuelles - distribution des liens internes correspondant à l’importance des pages - pagination/infinite scroll avec URLs persistantes et crawlables lorsque nécessaire 7. Sitemap et robots, uniquement s’ils existent ou sont nécessaires - URLs du sitemap correspondant à des pages canoniques, indexables et avec bon statut - URLs obsolètes, redirigées, dupliquées, bloquées ou importantes manquantes - robots.txt ne bloque pas accidentellement contenu ou ressources nécessaires - ne recommandez pas un sitemap à un petit site uniquement parce qu’il n’en a pas si la découverte est déjà claire 8. Qualité du contenu et intention - contenu pauvre, dupliqué, doorway ou généré mécaniquement - manque de contexte, expertise floue, claims non étayés ou contenu ne répondant pas à l’intention - cannibalisation entre pages proches - opportunités utiles de couverture et maillage sans keyword stuffing 9. Images et médias - alt text utile quand l’image porte du sens - URLs d’images descriptives et stables lorsque pratique - tailles/formats adaptés - dimensions/aspect-ratio réservés pour réduire les layout shifts - ne pas lazy-loader le probable LCP sans justification - le contenu lazy-loaded doit devenir disponible sans interaction utilisateur 10. Social et données structurées, lorsque pertinent - cohérence Open Graph et métadonnées sociales - Schema.org JSON-LD syntaxiquement valide, cohérent avec contenu visible et @type adapté - BreadcrumbList cohérent avec navigation visible lorsque utilisé - n’ajoutez pas du schema simplement parce que le type existe ; recommandez uniquement un markup utile et justifié 11. Core Web Vitals et impact SEO - probable élément LCP et facteurs de retard - risques CLS par images, polices, ads, embeds, bannières ou UI injectée - risques INP/TBT/main thread liés à JavaScript et tiers - CSS/JS render-blocking seulement lorsqu’ils affectent matériellement l’expérience ou le crawl - séparez problèmes mesurés et risques théoriques Format de sortie : ## Score SEO exécutif (1–10) ## Architecture et modèle de rendu détectés ## Problèmes critiques ayant un impact recherche/indexation uniquement ## Tous les findings Pour chaque problème : Priorité · Preuve · Fichier/composant · Page/URL · Problème · Impact SEO · Correctif minimal · Bénéfice attendu ## Findings multilingues/régionaux (ou Non applicable) ## Findings rendu/JavaScript (ou Non applicable) ## Quick Wins ## Roadmap prioritaire (Top 10 par ROI) ## À vérifier Listez ce qui exige Search Console, logs serveur, analytics, Field Core Web Vitals ou crawl live avant d’être qualifié de problème confirmé.
Revue de l’expérience utilisateur
Tâche : revue UX, SEO et conversion avec recherche actuelle des bonnes pratiques pour ce site web ou cette application web : [INSÉRER L’URL] Examinez l’expérience selon : 1. expérience utilisateur et guidage 2. SEO et structure du contenu 3. conversion, activation ou accomplissement de l’objectif principal du projet 4. accessibilité et usage mobile Avant de recommander : - identifiez ce que fait réellement le produit/site - identifiez le public principal et la conversion/tâche principale - identifiez les pages d’entrée et le parcours d’un nouvel utilisateur - déterminez s’il s’agit d’un site de contenu, outil, SaaS, e-commerce, portfolio, service local, communauté, application web ou autre - ne supposez pas la présence de générateurs, dashboard, formulaire complexe, essai gratuit, e-commerce ou autre fonctionnalité précise Pour les recommandations importantes, effectuez une courte vérification web des bonnes pratiques avec des sources actuelles et fiables ou des produits directement comparables. N’utilisez pas de benchmarks génériques s’ils ne correspondent pas au type de produit. Distinguez principes d’utilisabilité établis et hypothèses à tester. Le but n’est pas d’implémenter immédiatement. Créez d’abord une évaluation partagée. Après revue et accord, les points prioritaires pourront être implémentés et mesurés. 1. Proposition de valeur et CTA principal Vérifiez si un nouveau visiteur peut répondre rapidement : - Qu’est-ce que c’est ? - Pour qui ? - Que puis-je faire ici ? - Pourquoi faire confiance ? - Quelle est l’action suivante ? - Que se passe-t-il après ? Recherchez : - bonnes pratiques hero/premier écran pour ce type précis de produit - patterns de CTA principal/secondaire - exemples de sites comparables avec objectif utilisateur similaire Recommandez : - proposition de valeur assez claire ? - action principale assez visible et précise ? - concurrence inutile entre CTA ? - quelle formulation ou hiérarchie tester si nécessaire ? 2. Entrée guidée et information scent Vérifiez si les nouveaux utilisateurs ont besoin d’un chemin plus clair vers produit ou contenu. Ne prescrivez pas automatiquement tuiles, catégories, recherche, onboarding ou wizard. Décidez selon l’architecture de l’information existante. Considérez : - entrées par tâche - entrées par public - navigation produit/catégorie - recherche ou filtres - exemples ou templates - onboarding progressif - maintenir visible la navigation existante plutôt que la remplacer sans nécessité Recommandez : - principales intentions d’un nouvel utilisateur ? - combien de choix avant surcharge cognitive ? - où placer le guidage ? - que conserver dans la navigation normale pour discoverability et SEO ? 3. Complexité et progressive disclosure Identifiez l’interaction, le formulaire, le configurateur, l’éditeur, le checkout, le tableau de bord ou le flux de travail principal s’il existe. Vérifiez si un débutant voit trop de complexité avant de comprendre la valeur. Recherchez : - progressive disclosure - utilisabilité des formulaires et task flows - friction d’achèvement - produits comparables avec modes simples et avancés Recommandez : - quelles entrées/actions sont vraiment nécessaires au début ? - quelles options peuvent être facultatives, repliables, différées ou avancées ? - les masquer créerait-il des problèmes de découvrabilité ou pour power users ? - comment garder la puissance sans submerger les nouveaux utilisateurs ? S’il n’existe pas de flux de travail interactif complexe, marquez cette section Non applicable plutôt que d’en inventer un. 4. Démonstration concrète de la valeur Vérifiez si l’utilisateur peut voir un résultat réaliste avant d’investir beaucoup de temps ou d’informations. Formats possibles selon le produit : - avant/après - exemple de résultat - capture annotée - mini-démo - étude de cas - aperçu produit - résultat représentatif Recherchez des exemples actuels du même type de produit/site. Recommandez : - une démonstration est-elle nécessaire ? - quel exemple correspond à l’intention la plus importante ? - statique, interactif, vidéo ou aucun ? - où l’afficher sans dégrader la performance ni distraire de l’objectif principal ? 5. Navigation et architecture de l’information Vérifiez : - labels dans le langage utilisateur plutôt que jargon interne - facilité à trouver pages/tâches importantes - profondeur de navigation adaptée - navigation mobile conservant les parcours essentiels - breadcrumbs, liens associés, recherche, filtres ou footer lorsque utiles - pages SEO importantes crawlables et découvrables Recommandez : - ce qui doit être promu, rétrogradé, renommé, regroupé ou laissé tel quel - où une simplification UX pourrait réduire découvrabilité ou valeur SEO 6. Confiance, risque et assurance de décision Identifiez les signaux de confiance pertinents pour ce produit. Exemples : - propriétaire/contact clairs - prix transparents - confidentialité/utilisation des données - retours/remboursements - sécurité - exemples ou preuves réels - expertise de l’auteur - avis/témoignages crédibles - limites et périmètre honnêtes - attentes de support Ne recommandez pas de badges génériques non justifiés. Recommandez : - quelles questions de confiance restent sans réponse au moment d’agir - quels signaux rapprocher du point de décision - quels contenus existants suffisent déjà 7. Contenu et opportunité SEO Vérifiez si la structure correspond à la façon dont les utilisateurs réels cherchent et décident. Analysez : - intention de recherche - objectif de page et clarté des headings - pages pauvres ou chevauchantes - maillage interne - FAQ uniquement pour de vraies questions - comparaisons, tutoriels, use cases, contenu local ou support uniquement si adapté au business Ne créez pas du contenu uniquement pour cibler des mots-clés. Recommandez : - principaux manques de contenu - pages à consolider plutôt qu’étendre - opportunités utiles à la fois aux utilisateurs et à la découverte organique 8. Accessibilité et friction mobile Revoyez des parcours représentatifs : - clavier - visibilité et ordre du focus - labels, erreurs, dialogues, menus et mises à jour dynamiques - taille/espacement des touch targets - zoom/reflow et overflow horizontal - comportement viewport mobile - contraste et thèmes s’ils existent - motion/reduced motion si présent Séparez défauts d’accessibilité et préférences visuelles subjectives. 9. Plan de mesure et d’expérimentation Ne supposez pas l’existence d’analytics ni d’une plateforme particulière. Si la mesure est disponible, proposez le plus petit ensemble utile d’événements/métriques lié au parcours principal. Exemples : - démarrage et accomplissement du CTA principal - formulaire/checkout terminé - utilisation recherche/filtres - onboarding terminé - transition contenu → produit - erreurs/abandons Pour chaque expérience : - hypothèse - métrique principale - métrique garde-fou - changement comportemental attendu - complexité minimale d’implémentation - risque de mauvaise interprétation Format de sortie : ## Résumé exécutif ## Ce que semble être le site et à qui il s’adresse ## Top 5 findings Pour chacun : Preuve · Impact utilisateur · Impact business/SEO · Recommandation · Effort · Priorité · Mesure ## Revue détaillée sections 1–9 ## Ce qui fonctionne déjà et ne devrait pas changer ## Hypothèses à tester plutôt qu’implémenter immédiatement ## Quick Wins ## Roadmap prioritaire ## Plan de mesure ## Sources / exemples comparables utilisés pour les recommandations importantes Soyez spécifique au site réellement examiné. Ne transformez pas ceci en checklist SaaS, e-commerce, outil IA ou marketing générique sauf si le projet est réellement de ce type.
Revue du rendu Googlebot
Vous êtes un auditeur hybride de SEO technique, rendu, crawlabilité, architecture de l’information, accessibilité et UX. IMPORTANT : - Analysez d’abord le site réel et son architecture de rendu. - Ne supposez pas qu’il est statique, SSR, CSR, hydraté, construit avec un framework ou dépendant de JavaScript. - Google Search peut rendre JavaScript, mais le rendu a des limites et le contenu important ne doit pas dépendre inutilement d’une interaction utilisateur. - Google Search n’interagit pas avec une page pour déclencher le chargement de contenu. Considérez le contenu chargé uniquement après clic, hover ou événement de scroll déclenché par l’utilisateur comme un risque de crawl/indexation à vérifier. - Distinguez HTML source, HTML rendu et contenu apparaissant seulement après interaction. - N’affirmez pas que accordions, tabs, contenu rendu côté client ou contenu below-the-fold sont intrinsèquement non indexables. Vérifiez l’implémentation. - Ne jugez pas uniquement avec Lighthouse. - N’implémentez aucun changement pour l’instant. Analysez ce site : [INSÉRER L’URL] Si le repository ou les fichiers projet sont disponibles, examinez-les aussi. Si URL Inspection Search Console, HTML rendu, logs serveur, Field Core Web Vitals ou HAR sont disponibles, utilisez-les comme preuves. Indiquez clairement les preuves manquantes. ----------------------------------- PHASE 1 — IDENTIFIER L’ARCHITECTURE RÉELLE ----------------------------------- Déterminez, lorsque possible : - modèle de rendu : statique, SSG, SSR, CSR, hybride, streaming, hydraté ou inconnu - framework/CMS/constructeur s’il existe - modèle de routing - présence du contenu clé dans le HTML initial - ce que JavaScript ajoute ou modifie après chargement - lazy-loading et infinite scroll - génération des liens internes - architecture canonical, robots, sitemap et locales - principaux tiers influençant rendu/performance Ne recommandez pas un autre modèle de rendu sauf si le modèle actuel cause un problème vérifié impossible à résoudre plus simplement. ----------------------------------- PHASE 2 — CRAWL ET INDEXABILITÉ ----------------------------------- Vérifiez : - statut HTTP et redirections - robots.txt et meta robots si présents - signaux canonical - URLs crawlables - liens internes crawlables, de préférence de vrais éléments <a> avec href - pages orphelines et profondeur excessive - scripts/styles/ressources bloqués nécessaires au rendu - variantes staging, host dupliqué, paramètres ou protocole - contenu uniquement après authentification ou interaction non prise en charge Séparez pour chaque problème : - blocage confirmé - risque probable - recommandation de vérification ----------------------------------- PHASE 3 — HTML INITIAL VS HTML RENDU ----------------------------------- Comparez, lorsque possible : 1. HTML source/initial 2. DOM rendu après chargement normal 3. contenu nécessitant une action utilisateur Identifiez : - texte principal absent avant exécution JavaScript - métadonnées créées/remplacées trop tard - liens non crawlables dans le DOM rendu - erreurs d’hydratation/rendu - shells vides ou placeholders de chargement non résolus - contenu dupliqué entre serveur et client - contenu important dépendant de clics, tabs, hover ou loaders liés au scroll Ne signale pas du contenu normal below-the-fold uniquement parce qu’il est sous le premier viewport. ----------------------------------- PHASE 4 — LAZY LOADING ET CONTENU INFINI ----------------------------------- Vérifiez images, iframes, composants, listes, feeds et pagination. Assurez-vous que : - le contenu lazy pertinent se charge lorsqu’il devient visible sans action que Google Search n’effectue pas - le probable LCP n’est pas lazy-loadé inutilement - images/vidéos utilisent des URLs découvrables et attributs appropriés - l’infinite scroll indexable possède URLs persistantes/crawlables et liens/pagination normaux lorsque pertinent - le chargement ne masque pas de contenu unique dans le HTML rendu ----------------------------------- PHASE 5 — ARCHITECTURE DE L’INFORMATION ET LIENS INTERNES ----------------------------------- Évaluez : - hiérarchie depuis accueil/hubs vers pages importantes - profondeur de crawl - liens contextuels - navigation et footer - breadcrumbs lorsque utiles - clarté des anchor texts - pages dupliquées ou concurrentes - distribution du PageRank comme concept qualitatif de maillage, pas comme score directement mesuré Identifiez les pages importantes pour utilisateurs/business mais faiblement reliées en interne. ----------------------------------- PHASE 6 — SÉMANTIQUE ET CLARTÉ DU CONTENU ----------------------------------- Vérifiez : - title et sujet principal - hiérarchie de headings - landmarks sémantiques - contenu principal versus navigation/support - boilerplate dupliqué masquant le contenu unique - sections pauvres ou générées mécaniquement - données structurées uniquement si présentes ou appropriées - informations auteur/entreprise/produit/confiance uniquement si pertinentes Ne traitez pas E-E-A-T comme un facteur de ranking unique et mesurable. Utilisez expérience, expertise et confiance comme considérations de qualité et de confiance utilisateur lorsqu’elles s’appliquent. ----------------------------------- PHASE 7 — SEO MULTILINGUE/MULTIRÉGIONAL, SI APPLICABLE ----------------------------------- Si plusieurs versions langue/région existent, vérifiez : - URLs distinctes et crawlables - hreflang réciproque et codes valides lorsqu’utilisé - cohérence canonical - contenu principal et navigation localisés - sélecteur de langue avec liens crawlables - redirections automatiques ou variantes cookie-only pouvant masquer des versions - contenu régional réellement justifié Si le site est monolingue, marquez Non applicable. ----------------------------------- PHASE 8 — CORE WEB VITALS ET COÛT DE RENDU ----------------------------------- Évaluez avec des données mesurées si disponibles : - probable LCP et chaîne de requêtes - CLS causé par images, polices, ads, embeds, bannières, consentement, composants dynamiques ou hydratation - pression INP/main thread liée à JavaScript, tiers, handlers, rendu et long tasks - CSS/JS render-blocking - chargement des polices - dimensions et livraison responsive des images - requêtes inutiles - bundles/code dupliqués Séparez observations de laboratoire, données terrain et hypothèses. ----------------------------------- PHASE 9 — UX ABOVE THE FOLD SANS BIAIS DESIGN ----------------------------------- Évaluez le premier viewport : - objectif clair de la page - tâche/CTA principal - bannières/overlays intrusifs - stabilité du layout - contenu utile apparaissant rapidement - lisibilité mobile - information critique retardée par rendu ou consentement N’optimisez pas uniquement pour le minimalisme visuel. Préservez l’information dont l’utilisateur a besoin pour comprendre et faire confiance. ----------------------------------- PHASE 10 — MOBILE, ACCESSIBILITÉ ET ROBUSTESSE ----------------------------------- Vérifiez : - overflow responsive - touch targets - clavier - focus states - menus/dialogues/accordions/tabs - labels et erreurs de formulaires - zoom/reflow - contraste et thèmes si présents - reduced motion si pertinent - problèmes Safari/iOS lorsque l’implémentation les rend plausibles Les problèmes d’accessibilité peuvent aussi empêcher utilisateurs et systèmes automatisés d’atteindre correctement le contenu ; signale-les séparément des préférences cosmétiques. ----------------------------------- FORMAT DE SORTIE ----------------------------------- ## Résumé exécutif 8 phrases maximum. ## Architecture détectée - Modèle de rendu - Framework/CMS si identifié - Ce qui est présent dans le HTML initial - Ce qui dépend de JavaScript - Preuves disponibles / indisponibles ## Problèmes critiques de crawl ou d’indexation Uniquement confirmés ou fortement étayés. ## HTML initial vs HTML rendu Pour contenu et liens importants. ## Findings rendu/JavaScript Pour chacun : Priorité · Preuve · URL/composant · Problème · Pourquoi c’est important · Correctif minimal · Méthode de vérification ## Maillage interne et architecture de l’information ## Findings multilingues/régionaux Ou « Non applicable ». ## Core Web Vitals / performance Séparez mesures et hypothèses. ## Accessibilité / mobile ## Contenu et sémantique ## Quick Wins Uniquement éléments à faible risque et preuve claire. ## Roadmap prioritaire Top 10 par impact attendu et niveau de confiance. ## Checklist de vérification Incluez URL Inspection, HTML rendu, logs, Field CWV, HAR/profil navigateur ou crawl tests seulement si pertinents. Soyez critique, technique et précis. Pas de clichés SEO ni de marketing superficiel. Ne présentez pas d’anciennes suppositions sur l’indexation JavaScript comme des faits universels. Expliquez causes concrètes, preuves, effets probables, correctifs minimaux et méthode de vérification de chaque finding important.
Conseil : Corrigez d’abord les problèmes de priorité haute (High). Ne refactorisez pas du code fonctionnel simplement parce que l’IA suggère un schéma plus propre.
Étape 7

Lancez et améliorez

Résultat : boucle d’amélioration

Publiez le site, observez ce qui se passe et améliorez-le par petites étapes. Un site web n’est jamais terminé ; il devient utile grâce aux retours, aux mesures et à une itération prudente.

Lorsque les fonctionnalités et la version finale dans la langue source sont stables, demandez-vous si le site doit aussi servir des personnes d’une autre langue ou région. Une version correctement localisée peut rendre le contenu plus pertinent pour ces utilisateurs et élargir les possibilités de recherche organique, mais seulement si la traduction est utile, l’implémentation technique correcte et le résultat relu pour la locale cible.

Vérifications pratiques :

Prompt de localisation

Localisation en langue cible & revue SEO
Réalisez une revue complète de localisation, relecture linguistique, SEO par langue, qualité des prompts et implémentation pour un site web ou une application web existante dont la version dans la langue source est déjà stable. Données du projet : - Nom du projet/site : [NOM_PROJET_OU_SITE] - URL publique ou de prévisualisation : [URL_PUBLIQUE_OU_PREVIEW] - Langue source : [LANGUE_SOURCE] - Langue cible : [LANGUE_CIBLE] - Locale/région cible : [LOCALE_CIBLE] - Marché principal : [MARCHE_OU_REGION_PRINCIPALE] - Chemin repository/projet : [CHEMIN_PROJET_OU_REPOSITORY] - Chemin du contenu source : [CHEMIN_CONTENU_SOURCE_OU_INCONNU] - Chemin du contenu traduit : [CHEMIN_CONTENU_TRADUIT_OU_INCONNU] - Framework, CMS, constructeur ou stack : [FRAMEWORK_CMS_OU_INCONNU] - Public cible : [PUBLIC_CIBLE] OBJECTIF Créer une version dans la langue cible qui donne l’impression d’avoir été recherchée, écrite, éditée et publiée directement pour cette locale, tout en préservant le sens, les fonctionnalités, l’architecture technique, l’accessibilité, l’intention SEO et le comportement produit. Il ne s’agit pas d’une traduction mot à mot ni d’une simple correction orthographique. Le but est d’étendre le site de manière responsable à des personnes qui recherchent, lisent et décident dans la langue ou la région cible. Ne promettez pas que la traduction seule augmentera le classement ou le trafic. Considérez le SEO localisé comme un ensemble : contenu utile localisé, URLs/signaux adaptés, intention de recherche, maillage interne, correction technique et qualité continue. RÈGLES NON NÉGOCIABLES - Traitez la version actuelle en langue source comme source sémantique de vérité sauf indication contraire du projet. - Inspectez d’abord l’architecture réelle. Ne supposez pas système de build, HTML statique, framework JavaScript, CMS, base de données, SSR, CSR ou framework de localisation. - Préservez l’architecture et le modèle source-of-truth existants. - N’inventez pas un système de traduction parallèle si un système existe déjà. - N’introduisez pas un build uniquement pour la localisation si le projet fonctionne sans. - Ne traduisez pas identifiants de code, variables, translation keys, paramètres API, chemins de fichiers, classes CSS, clés JSON/YAML, syntaxe de templates, URLs, emails, marques, noms d’entreprise/produit ou texte source fourni par l’utilisateur sauf demande explicite. - Préservez placeholders, interpolation, pluralisation, markup et comportement dynamique des prompts. - Ne modifiez pas silencieusement faits, garanties, sens juridique, prix, capacités, dates ou claims de fournisseurs. - Ne prétendez pas avoir revu, rendu ou testé ce qui ne l’a pas été réellement. - Notez l’incertitude au lieu de deviner. - Ne demandez pas de chain-of-thought cachée ; demandez plutôt justification concise, preuves, hypothèses et étapes de vérification. PHASE 0 — INVENTAIRE DU PROJET ET DE LA LOCALISATION Avant de traduire des phrases, identifiez : - toutes les routes publiques et preview - routes source et cible - fichiers source/contenu - templates/composants/partials - champs CMS ou contenu base de données si applicable - fichiers de traduction et dictionnaires de locale - navigation, footer, breadcrumbs, menus, formulaires, dialogues, notifications, erreurs et états vides - métadonnées SEO - implémentation canonical et hreflang - données structurées - alt text et labels d’accessibilité - messages de validation client/serveur - emails/notifications stockés - modèles de prompts ou flux de travail IA, s’ils sont présents - tests, build, lint, type checks, CI, preview et déploiement - changement de langue et détection de locale - analytics/consentement/ads uniquement lorsque la locale modifie texte visible ou comportement Classez le contenu utilisateur en catégories utiles : 1. UI partagée 2. navigation et structure 3. landing/marketing 4. UI produit/application 5. aide/tutoriel/éducation 6. formulaires/validation 7. prompts/templates générés si applicable 8. flux de travail/cas d’usage 9. FAQ 10. juridique/disclaimer/confidentialité 11. métadonnées SEO 12. accessibilité 13. données structurées 14. messages transactionnels/système 15. autre contenu visible Notez tout contenu inaccessible ou non vérifiable. PHASE 1 — PREMIÈRE TRADUCTION ET LOCALISATION Traduisez directement depuis la version source actuelle. Vérifiez pour chaque élément : - sens et intention - grammaire, orthographe, syntaxe, ponctuation, capitalisation - ordre des mots et rythme naturels - registre et forme d’adresse - terminologie adaptée au public - vocabulaire et conventions de la locale - dates, heures, nombres, monnaie, unités, adresses et guillemets si pertinent - clarté des CTA et conventions d’interface - longueur du texte et adaptation UI - hypothèses culturelles à adapter - si une traduction littérale affaiblit l’exemple ou la tâche Préférez une rédaction naturelle dans la langue cible à la copie de la structure source. N’améliorez pas le style en changeant le sens. Ne simplifiez pas le contenu expert jusqu’à l’inexactitude. Ne rendez pas le contenu débutant inutilement technique. PHASE 2 — DÉCISIONS TERMINOLOGIQUES Créez ou suivez un glossaire par locale. Pour les termes importants, décidez s’ils doivent : 1. être traduits 2. rester en langue source car établis 3. rester mais être expliqués à la première occurrence 4. utiliser une forme hybride établie 5. être adaptés grammaticalement 6. être abrégés après introduction complète 7. être évités car trompeurs, obsolètes ou inutiles Basez les décisions sur : - usage réel des locuteurs de la locale - usage du secteur - familiarité du public - précision technique - intention de recherche - cohérence produit - existence d’un équivalent naturel et établi Ne supposez pas que tous les termes techniques doivent rester en anglais. Ne supposez pas que chaque terme anglais doit être traduit. Noms de produits et marques restent inchangés. PHASE 3 — UI DYNAMIQUE, FORMULAIRES ET TEMPLATES Pour chaque chaîne dynamique/template : - valeurs insérées grammaticalement correctes - singulier/pluriel, genre, articles et accords lorsque pertinent - variables/placeholders conservés exactement - valeurs optionnelles ne cassent pas les phrases - ponctuation/guillemets autour des valeurs dynamiques corrects - états vides, erreurs, confirmations, tooltips et aide - boutons et noms accessibles compréhensibles - labels courts adaptés au mobile Ne testez pas le contenu dynamique uniquement en lisant des fragments source. Rendez des états représentatifs lorsque possible. PHASE 4 — PROMPTS GÉNÉRÉS OU FONCTIONS IA, UNIQUEMENT SI PRÉSENTS Si le produit génère prompts/instructions IA, traitez-les comme contenu fonctionnel. Vérifiez : - grammaire naturelle dans la langue cible - instruction claire sur la langue de sortie si nécessaire - placeholders dans le bon ordre - texte utilisateur non traduit accidentellement - noms, URLs, code et termes protégés inchangés - champs optionnels sans phrases cassées - formatage, listes, titres et retours à la ligne lisibles - instructions non contradictoires - output, ton, public et contraintes préservés - instructions modèle/fournisseur seulement si nécessaires - aucune garantie d’exactitude ou certitude impossible - aucune demande de chain-of-thought cachée Pour les fonctions de traduction, distinguez clairement langue source, langue cible, relecture linguistique, réécriture, localisation et transcréation. S’il n’y a pas de fonction IA de prompts, marquez Non applicable. PHASE 5 — SEO LOCALISÉ ET INTENTION RÉGIONALE Vérifiez dans la langue cible : - titles - méta-descriptions - headings - contenu visible - texte des liens internes - breadcrumbs - alt text - Open Graph/social si utilisé - texte des données structurées si utilisé - slugs/URLs lorsque la localisation des routes fait partie de l’architecture Ne traduisez pas les mots-clés mécaniquement. Recherchez comment le public cible formule réellement ses recherches lorsque les décisions de mots-clés/intention sont importantes. Gardez une rédaction naturelle, sans insertion artificielle de mots-clés. Pour les sites multilingues/multirégionaux : - préférez des URLs séparées et crawlables par langue si cela correspond à l’architecture - utilisez hreflang réciproque avec codes valides lorsque des variantes existent et que le projet l’utilise - gardez canonical cohérent avec l’architecture langue/région - chaque page localisée doit réellement localiser contenu principal et navigation - fournissez des liens crawlables pour changer de langue - ne dépendez pas uniquement de cookies, langue navigateur ou redirections automatiques pour exposer les variantes - gardez chaque page principalement dans une langue sauf exemples, noms, code ou texte source volontairement conservé - ne supposez pas que deux locales partageant une langue doivent employer exactement les mêmes formulations Si le site n’a qu’une langue et aucune variante, n’ajoutez pas hreflang uniquement parce que ce prompt le mentionne. PHASE 6 — CONTENU FACTUEL, JURIDIQUE ET À RISQUE Identifiez les changements linguistiques pouvant modifier une affirmation importante. Attention particulière à : - prix - capacités produit - fonctionnalités actuelles de modèles/fournisseurs - affirmations de performance ou SEO - déclarations juridiques/réglementaires - confidentialité/cookies/consentement - médical, financier, emploi, sécurité ou autre high-stakes - garanties, pourcentages, classements, benchmarks, dates et limites Classez les affirmations importantes en : - fait établi - fait dépendant de l’implémentation - fait sensible au temps - heuristique pratique - recommandation éditoriale - opinion - exemple - affirmation non étayée Ne « corrigez » pas silencieusement une affirmation douteuse comme simple problème de traduction. Notez-la séparément et vérifiez les corrections importantes avec des sources autoritatives lorsque possible. Pour le juridique, préservez sens et portée. Ne prétendez pas à une revue juridique sans personne qualifiée. PHASE 7 — LANGAGE UX ET ACCESSIBILITÉ Vérifiez : - objectif des liens - labels de boutons - labels de formulaires et association des erreurs - aria-label et noms accessibles - texte screen-reader-only - instructions ouvrir/fermer - labels dialogues/menus - noms du sélecteur de langue - liens répétés et contrôles uniquement par icône Le texte d’accessibilité doit décrire fonction/objectif, pas seulement apparence. Une traduction littérale peut être correcte mais mauvaise comme label ; utilisez la convention naturelle de la locale sans changer le sens. PHASE 8 — PREMIÈRE RELECTURE LINGUISTIQUE Après la traduction initiale, effectuez une revue éditoriale complète. Recherchez : - structures calquées sur la langue source - traductions littérales - rythme de traduction automatique - terminologie incohérente - tutoiement/vouvoiement incohérent - mêmes phrases traduites différemment sans raison - fragments non traduits - mélange de langues accidentel - erreurs de ponctuation/typographie - capitalisation incohérente - CTA non naturels - headings maladroits - formatage listes/retours cassé dans prompts longs - placeholders/variables modifiés - dérive de sens Ne faites pas de remplacement global large sans vérifier chaque contexte. PHASE 9 — IMPLÉMENTATION Implémentez uniquement les changements revus et acceptés. Pendant l’implémentation : - préservez encodage et formatage lorsque pratique - préservez source-of-truth et flux de output généré - préservez translation keys et placeholders - préservez HTML/Markdown/JSX/templates - préservez code et termes protégés - évitez refactorings sans rapport - évitez bruit de formatage fichier entier - mettez à jour source, métadonnées, schema, route/config et output ensemble uniquement si l’architecture l’exige - suivez les règles de build/déploiement existantes N’éditez pas le output généré à la place de sa source sauf si le projet le définit comme source maintenue. PHASE 10 — QA TECHNIQUE Exécutez les checks existants pertinents, par exemple : - build - lint - type checking - unit/integration/E2E - validation translation keys - traductions manquantes/dupliquées - cohérence placeholders - liens internes - validation HTML/JSON/YAML/schema - accessibilité - métadonnées SEO - canonical/hreflang - responsive/overflow - tests navigateur - parité du output généré N’affaiblissez pas un test uniquement pour le faire passer. Mettez à jour les tests de texte exact lorsque le changement approuvé modifie légitimement du texte visible. PHASE 11 — DEUXIÈME RELECTURE LINGUISTIQUE INDÉPENDANTE Après implémentation et reconstruction/rendu, effectuez une deuxième revue complète du point de vue d’un éditeur natif expérimenté. Cette deuxième passe est obligatoire et ne doit pas répéter mécaniquement la première checklist. Lisez le wording final dans son contexte et comparez-le de nouveau au sens de la source. Vérifiez particulièrement : - chaque page/route modifiée - title et méta-description - H1/H2/H3 - navigation/breadcrumbs modifiés - boutons et CTA - formulaires et états de validation - prompts longs et retours à la ligne intentionnels - exemples et combinaisons dynamiques de placeholders - labels et wrapping mobile - labels d’accessibilité - contenu visible et caché/progressif - liens internes localisés - vocabulaire/registe de la locale - aucun fragment source sauf noms/termes/exemples volontaires - aucune dérive régionale, surtout entre plusieurs variantes de la même langue Lorsque possible, relisez le site rendu plutôt que seulement les sources. Si aucun navigateur n’est disponible, déclarez cette limite et faites une deuxième passe au niveau source sans prétendre à une revue rendue. PHASE 12 — VÉRIFICATION FINALE Avant de considérer la locale terminée : 1. rescanner les fichiers modifiés pour du texte source non traduit 2. rescanner wording rejeté/remplacé 3. vérifier placeholders, variables, interpolation et comportement des prompts 4. vérifier routes localisées et liens internes 5. vérifier canonical/hreflang si applicable 6. vérifier métadonnées, alt et labels d’accessibilité 7. vérifier données structurées si présentes 8. exécuter build et tests pertinents 9. vérifier des pages représentatives sur téléphone, tablette, desktop lorsque possible 10. vérifier modes clair/sombre si présents 11. relire encore une fois le contenu modifié comme prose continue naturelle, pas seulement phrase par phrase SORTIE / RAPPORT Fournissez : ## Résumé de localisation - langue et locale cible - fichiers/routes modifiés - architecture/système de localisation détecté - ce qui a été traduit/localisé - ce qui a été volontairement laissé inchangé ## Décisions terminologiques Termes importants traduits, conservés, expliqués ou régionaux. ## Findings et décisions Pour chaque point important : ID · Sévérité · Type · Texte source · Texte cible actuel · Proposition · Justification · Statut (Accepté/Modifié/Rejeté/Décision humaine nécessaire) · Référence d’implémentation ## Décisions SEO/régionales URLs, stratégie hreflang/canonical, slugs et adaptations d’intention uniquement si pertinentes. ## Première relecture Ce qui a été vérifié/corrigé. ## Deuxième relecture Confirmez qu’une deuxième passe distincte a eu lieu, ce qu’elle a trouvé et si elle a porté sur pages rendues ou sources seulement. ## Validation technique Uniquement tests/checks réellement exécutés et résultats. ## Risques ou décisions humaines restantes Juridique, factuel, terminologie, marché, layout ou navigateur. ## Fichiers modifiés Liste exacte. STANDARD FINAL La version localisée doit sonner naturellement pour le public cible, préserver sens et comportement produit, respecter l’architecture réelle, utiliser la terminologie de la locale, rester cohérente techniquement et pour le SEO, et faire l’objet d’une deuxième relecture indépendante après implémentation. Ne qualifiez pas la localisation de « native-reviewed », « human-reviewed », « legally reviewed » ou « browser-tested » si cette revue n’a pas réellement eu lieu.
Ensuite : utilisez le Générateur de prompts pour rédaction et e-mails pour les textes de page et le Générateur de prompts d’images IA pour les concepts visuels.
Conclusion

Un site web n’est jamais seulement du code

L’IA peut vous aider à planifier les pages, rédiger les textes, générer du code et auditer le résultat, mais le site a toujours besoin de votre jugement. Un bon site n’est pas celui qui possède le plus de fonctionnalités ; c’est celui que les gens comprennent, auquel ils font confiance et qu’ils peuvent utiliser sans friction.

Trois choses comptent davantage que l’ajout de fonctionnalités :

  1. Clarté : les visiteurs doivent comprendre en quelques secondes à quoi sert le site.
  2. Confiance : un chargement rapide, un contenu lisible, des liens fonctionnels et des informations transparentes donnent au site une apparence crédible.
  3. Contrôle : un code statique et simple est plus facile à tester, maintenir et restaurer en cas de problème.

Commencez simplement, gardez la structure statique et lisible, vérifiez vous-même chaque modification importante et améliorez un problème à la fois. C’est ainsi qu’un site assisté par l’IA devient fiable au lieu de rester un simple brouillon généré.

Commencez par la clarté

Prenez aujourd’hui la première décision pour votre site

Un objectif clair et un plan de pages évitent la plupart des reprises inutiles. Commencez par là avant de demander à l’IA d’écrire du code ou des textes.

Partager cette page

Ajouter PromptingEasy à votre écran

Utilisez le menu de votre navigateur et choisissez l’option permettant d’installer ce site ou de l’ajouter à votre écran d’accueil.