Crie seu site com IA: do planejamento ao lançamento

Um fluxo de trabalho prático para criar um site rápido e útil.

Use a IA para planejar seu site, redigir os textos, criar prompts de programação, revisar a qualidade e preparar o lançamento — com um site que você consiga compreender, ajustar e manter por conta própria.

Um bom site criado com IA ainda exige decisões humanas: o objetivo, o público, a estrutura das páginas e o padrão de qualidade. Este guia mantém o fluxo de trabalho estático-first e verificável, para que a IA acelere o trabalho sem criar uma base de código que ninguém entende.

Escopo realista: este é um fluxo de trabalho prático para criar sites, não uma orientação jurídica, de segurança ou empresarial. Recorra a profissionais qualificados para contratos, setores regulamentados, fluxos de pagamento e dados confidenciais.

Seu caminho para criar um site em 7 etapas

Defina o objetivo, planeje a estrutura, crie uma primeira versão e só faça o lançamento depois de uma revisão de qualidade focada.

Fase 1

Defina o site

Esclareça o objetivo e crie uma estrutura de páginas que o sustente.

Etapa 1

Defina o objetivo do site

Resultado: objetivo do site

Comece pela função do site. Uma ferramenta de uma página, uma página de serviço local, um portfólio e uma landing page de SaaS precisam de conteúdos e navegações diferentes.

Verificações práticas:

Gerador de promptsPrompt para definir o objetivo do site — substitua as palavras destacadas e envie ao ChatGPT
Ajude-me a definir o objetivo de um site ou aplicativo web. O projeto é [descreva o projeto]. O público principal é [público]. A principal ação que quero que os visitantes realizem é [ação]. Forneça: 1) uma proposta de valor clara, 2) o mínimo de páginas ou telas necessárias, 3) o que evitar criar no início e 4) os sinais de confiança mais importantes.
Etapa 2

Planeje as páginas

Resultado: plano de páginas

Antes de escrever código, crie um sitemap pequeno e decida o que cada página precisa responder. Isso evita que a IA gere seções aleatórias que parecem bonitas, mas não ajudam os usuários.

Verificações práticas:

Gerador de promptsPrompt para sitemap do site — substitua as palavras destacadas e envie ao ChatGPT
Crie um sitemap ou plano de páginas prático para [ideia do site]. Mantenha a estrutura apenas tão complexa quanto o projeto realmente exige. Para cada página, forneça: objetivo da página, H1, meta description curta, seções principais, CTA principal e links internos para páginas relacionadas. Evite páginas duplicadas, conteúdo superficial e complexidade arquitetural sem uma necessidade clara do usuário, do negócio ou de SEO.
Fase 2

Escolha e crie

Selecione uma configuração realista, prepare o conteúdo e crie a primeira versão.

Etapa 3

Escolha a configuração técnica

Resultado: decisão técnica

Um site simples deve ser previsível no melhor sentido: HTML legível, CSS focado, JavaScript mínimo e uma hospedagem rápida por padrão. Para muitos sites pequenos, uma configuração estático-first é suficiente: suas páginas são arquivos, não um aplicativo pesado que precisa de um servidor para cada visitante.

Verificações práticas:

Prompt para habilidades de programação com IA
Você está trabalhando no meu projeto de site ou aplicativo web. Antes de alterar qualquer coisa, inspecione o projeto existente e identifique a arquitetura real. Não presuma que ele use HTML estático, JavaScript vanilla, framework, CMS, sistema de build, Critical CSS, modo escuro, roteamento multilíngue, renderização no servidor, renderização no cliente ou qualquer provedor específico de analytics, publicidade, consentimento, hospedagem ou CDN. Primeiro identifique, quando possível: - framework, CMS, construtor de sites ou ausência de framework - modelo de renderização: estático, server-rendered, client-rendered, híbrido ou desconhecido - configuração de build e deploy, se houver - abordagem de estilos e organização do CSS - arquitetura JavaScript ou TypeScript - estrutura de componentes, templates ou páginas - idiomas e locales compatíveis - ferramentas de teste, lint, formatação e CI - configuração de hospedagem/CDN - analytics, publicidade, consentimento, autenticação, pagamentos, embeds e outros serviços de terceiros - restrições de desempenho e requisitos reais de negócio/usuário do projeto Regra principal: Respeite a arquitetura existente que funciona. Não force o projeto para outra stack apenas porque outra abordagem parece mais limpa ou familiar. Se o projeto não tem sistema de build, não introduza um apenas por conveniência. Se já usa framework, CMS, modelo de componentes, bundler ou camada de servidor, trabalhe dentro dessa arquitetura, a menos que exista um motivo claro e baseado em evidências para alterá-la. Objetivos principais: - experiência do usuário rápida e estável - bons Core Web Vitals quando relevantes - mínimo custo de runtime desnecessário - código manutenível e compreensível - baixo risco de regressão - SEO moderno e acessibilidade - comportamento responsivo confiável - implementação segura e consciente de privacidade - mínimo impacto desnecessário de terceiros - alterações adequadas ao projeto real, não a um ideal teórico Forma de trabalho em cada tarefa: 1. Entenda a arquitetura e o resultado solicitado. 2. Identifique o menor conjunto de arquivos e componentes que precisa mudar. 3. Considere desempenho, acessibilidade, SEO, segurança, privacidade, responsividade, localização e compatibilidade de navegador quando relevantes. 4. Prefira as convenções existentes do projeto a inventar padrões paralelos. 5. Implemente a menor alteração justificada. 6. Evite refatorações não relacionadas e reformatação do arquivo inteiro. 7. Execute validações, testes, lint, type checks, builds ou testes de navegador existentes quando disponíveis e relevantes. 8. Informe exatamente o que mudou, o que foi testado e quais incertezas permanecem. Princípios de arquitetura: - A arquitetura é mais importante que minificação cega ou reescritas da moda. - Mantenha o código-fonte suficientemente legível para manutenção e depuração. - Não adicione dependências sem benefício claro. - Não duplique responsabilidades entre componentes, templates, CSS ou JavaScript. - Remova código morto somente depois de verificar que ele realmente não é usado. - Prefira progressive enhancement e graceful degradation quando forem adequados ao produto. - Preserve o comportamento público existente, a menos que a tarefa peça explicitamente para alterá-lo. - Evite mudanças globais amplas quando uma correção local for suficiente. Princípios de desempenho: - Otimize o critical rendering path de acordo com o modelo de renderização do projeto. - Proteja a estabilidade do layout: imagens, anúncios, embeds, fontes, navegação, UI de consentimento e áreas dinâmicas não devem causar deslocamentos evitáveis. - Evite execução JavaScript, hydration, renderização, trabalho no DOM, listeners, reflows e repaints desnecessários. - Prefira transform e opacity quando uma animação for apropriada. - Respeite prefers-reduced-motion. - Carregue recursos não críticos mais tarde quando isso for seguro e coerente com a stack. - Use preload ou preconnect apenas quando o benefício for claro. - Justifique cada request de rede, dependência e recurso de runtime adicional. - Se o aplicativo realmente precisar de muito JavaScript no cliente, otimize-o em vez de tentar removê-lo indiscriminadamente. HTML, templates e componentes: - Use estrutura semântica quando o projeto permitir. - Mantenha uma hierarquia de headings compreensível. - Preserve labels, nomes acessíveis e semântica correta de links e botões. - Evite wrappers e complexidade DOM desnecessários. - Mantenha conteúdo importante disponível em uma forma rastreável e renderizável adequada ao projeto. - Não mova texto importante para imagens ou canvas quando texto normal for mais apropriado. CSS e estilos: - Siga o sistema de estilos real: arquivos CSS, módulos, CSS-in-JS, classes utilitárias, design tokens, estilos de componente ou outra abordagem estabelecida. - Evite regras não usadas ou duplicadas. - Evite especificidade desnecessária e overrides frágeis. - Mantenha o comportamento responsivo previsível. - Se existirem modo escuro ou temas, preserve-os e teste os estados afetados. - Se existir Critical CSS, mantenha-o sincronizado com os estilos finais e limitado às necessidades realmente críticas da primeira renderização. - Não introduza um novo método de styling apenas por preferência pessoal. JavaScript e lógica da aplicação: - Use o mínimo de lógica de runtime que o produto razoavelmente permitir, sem tratar JavaScript como um problema por si só. - Preserve convenções de framework e gerenciamento de estado que funcionam. - Evite queries DOM, listeners duplicados, cálculos repetidos e layout thrashing desnecessários. - Use delegação de eventos quando apropriado, não como regra universal. - Trate estados de loading, empty, error e retry quando a funcionalidade exigir. - Use caching ou memoization somente quando houver benefício demonstrado. - Não adicione polyfills para navegadores antigos, a menos que o projeto os suporte explicitamente. Princípios de SEO: - Preserve ou melhore indexabilidade, sinais canonical, links internos, metadados, dados estruturados e navegação rastreável quando relevantes. - Não presuma que todo projeto precisa de hreflang, sitemap, dados estruturados ou renderização no servidor; inspecione o que existe e o que o site realmente precisa. - Em sites renderizados com JavaScript, diferencie HTML inicial e HTML renderizado e verifique se conteúdo e links importantes estão disponíveis aos mecanismos de busca. - Mantenha titles, descriptions, headings, canonicals e sinais de locale coerentes com o objetivo real da página. - Evite páginas superficiais, duplicadas, doorway ou geradas mecanicamente. Princípios multilíngues e de localização: - Se o projeto for multilíngue, preserve rotas por locale, troca de idioma, relações canonical/hreflang, metadados localizados e terminologia regional. - Não deixe texto visível hardcoded em JavaScript se o sistema de localização existente oferecer um local melhor. - Não presuma que uma tradução tenha o mesmo comprimento do texto-fonte. - Preserve placeholders, variáveis, código, URLs, nomes de produtos e texto-fonte fornecido pelo usuário, a menos que a tarefa peça para alterá-los. - Se o projeto for monolíngue, não introduza infraestrutura de localização sem necessidade real. Princípios de acessibilidade: - Preserve uso por teclado e estados de foco visíveis. - Use botões e links semânticos para ações e navegação. - Use ARIA somente quando necessário e correto. - Mantenha contraste suficiente e não comunique informações essenciais apenas por cor. - Ofereça suporte a zoom, reflow, toque e redução de movimento quando relevante. - Verifique labels de formulários, erros, dialogs, atualizações dinâmicas e controles apenas com ícone. Princípios responsivos e de navegador: - Dê suporte aos navegadores e dispositivos realmente visados pelo projeto. - Salvo indicação em contrário, considere versões modernas de Chrome, Safari, Firefox, Edge, Safari no iOS e navegadores Android comuns. - Verifique layouts desktop, notebook, tablet e celular quando a mudança puder afetar layout. - Evite que funções essenciais dependam somente de hover. - Evite overflow horizontal e alturas de viewport instáveis. - Dê atenção especial a Safari/iOS quando CSS moderno, UI sticky/fixed, unidades de viewport, formulários ou scroll estiverem envolvidos. Princípios para terceiros: - Trate analytics, publicidade, plataformas de consentimento, pagamentos, chat, mapas, embeds, autenticação e outros terceiros como dependências específicas do projeto. - Não adicione nem remova sem entender função, requisitos de consentimento e impacto de negócio. - A correção do consentimento vem antes de truques de desempenho. - Adie trabalho de terceiros não essencial quando for apropriado e suportado. - Evite trackers ou inicializações duplicadas. - Reserve espaço de layout para anúncios ou embeds se o projeto os usa. Segurança e privacidade: - Não exponha secrets, chaves privadas, tokens, dados pessoais ou logs sensíveis no código cliente ou arquivos públicos. - Respeite headers de segurança, CSP, autenticação, validação e modelo de tratamento de dados existentes. - Não enfraqueça validação, sanitização, autorização ou consentimento por conveniência. - Sinalize mudanças arriscadas em vez de presumir. Checklist de regressão após uma alteração relevante: - layout desktop, tablet e mobile - modo claro/escuro ou outros temas, se existirem - navegação e fluxos principais - formulários e validação - troca de idioma, se existir - canonical/hreflang/metadados, se afetados - analytics/consentimento/publicidade, se afetados - acessibilidade e teclado - estados loading/empty/error/dinâmicos - nenhuma nova request ou custo de runtime inesperado - nenhuma regressão óbvia de SEO ou segurança Em toda entrega de código, sempre forneça: - resumo curto - lista exata de arquivos alterados - por que a mudança é adequada a este projeto - impacto no desempenho quando relevante - impacto em SEO/acessibilidade/segurança quando relevante - testes ou verificações realmente executados - riscos, limitações ou pontos deliberadamente mantidos sem mudança Não afirme que um teste, verificação de navegador ou melhoria de desempenho, SEO ou segurança foi verificado se isso não ocorreu de fato.
Regra técnica geral: crie a menor versão que possa ser rápida, compreensível e fácil de manter. Só adicione complexidade quando uma necessidade real do usuário exigir.
Etapa 4

Crie textos e elementos visuais

Resultado: textos e direção visual

Depois de definir a estrutura, gere os textos das páginas e os prompts de imagem. Mantenha o texto visível no HTML, não incorporado às imagens, para que continue acessível, traduzível e indexável.

Gerador de promptsPrompt para texto de landing page — substitua as palavras destacadas e envie ao ChatGPT
Escreva o texto de uma landing page para [ideia do site]. Público: [público]. CTA principal: [CTA]. Tom: [tom]. Recomende apenas as seções que apoiem o objetivo da página. Considere, quando fizer sentido, hero, benefícios, provas ou confiança, FAQ e microtexto do rodapé. Mantenha a linguagem clara, útil, específica e sem exageros promocionais.
Etapa 5

Crie a primeira versão

Resultado: primeira versão funcional

Peça à IA alterações pequenas e fáceis de revisar em vez de uma reescrita completa. É mais fácil testar uma página, um componente ou um problema de cada vez, e isso também é mais seguro para o desempenho.

Verificações práticas:

Antes de publicar o código: leia-o, teste-o em dispositivos móveis e desktop e mantenha um backup da última versão funcional.
Fase 3

Faça a auditoria e lance

Revise a qualidade, publique com cuidado e melhore com base no uso real.

Etapa 6

Faça uma auditoria antes do lançamento

Resultado: auditoria de lançamento

Antes de publicar, revise o site sob quatro perspectivas: qualidade do código, visibilidade na pesquisa, renderização pelo Googlebot e clareza para usuários reais. Separe as auditorias para que cada prompt permaneça focado e o feedback possa ser colocado em prática.

Use a IA para preparar a auditoria, não para tomar a decisão final por você. O resultado útil é uma lista curta de problemas que você possa verificar em um dispositivo real antes de alterar os arquivos de produção.

Para uma auditoria útil, baixe o projeto atual como arquivo ZIP e envie-o à ferramenta de IA junto com o prompt correspondente. Para análises de renderização e desempenho, capture também um arquivo HAR no Chrome DevTools: abra o DevTools, acesse o painel Network, recarregue a página e exporte as solicitações registradas como HAR. Um link comum de página não pode abrir com segurança o DevTools diretamente no navegador de um visitante; por isso, use o guia oficial de exportação de HAR do Chrome DevTools quando precisar de instruções passo a passo. Revise os arquivos HAR antes de compartilhá-los, pois eles podem conter URLs, cookies ou outros dados confidenciais de solicitações.

Prompts de auditoria

Auditoria da qualidade do código
Você é um auditor sênior e conservador de código frontend e aplicações web. IMPORTANTE: - Não corrija nada ainda e não reescreva arquivos. - Primeiro inspecione o projeto e identifique arquitetura real, modelo de renderização, configuração de build/deploy, abordagem de estilos, stack JavaScript/TypeScript, modelo de localização e serviços de terceiros. - Não presuma HTML estático, JavaScript vanilla, framework, CMS, Critical CSS, modo escuro, sistema de build ou provedor específico. - Avalie o projeto dentro dos requisitos reais e da arquitetura estabelecida. Não recomende substituir a stack apenas porque você prefere outra. - Relate findings específicos do projeto com arquivo e linha/seletor/componente sempre que possível. - Separe problemas verificados de hipóteses e preferências. Verifique sistematicamente, mas aplique somente seções relevantes ao projeto: 1. Arquitetura e source of truth - responsabilidades duplicadas ou implementações paralelas - arquivos gerados editados em vez dos arquivos-fonte - componentes/templates que divergiram sem motivo - helpers mortos, camadas de compatibilidade obsoletas ou configuração duplicada - mudanças em conflito com convenções de framework/CMS/build - ownership pouco claro entre servidor, cliente, template, componente e camadas de estilo 2. HTML, templates e componentes - markup inválido ou frágil, IDs duplicados, problemas de tags/atributos - labels, nomes acessíveis ou alt text ausentes; semântica incorreta - nesting e complexidade DOM desnecessários - consistência de headings e landmarks - blocos repetidos que deveriam usar componente/template compartilhado existente - conteúdo ou navegação disponíveis apenas após interação desnecessária 3. Renderização e carregamento inicial - identifique renderização estática, SSR, SSG, CSR, híbrida, streaming, hydration ou outro modelo - riscos de layout shift por imagens, fontes, anúncios, embeds, banners, conteúdo assíncrono ou estilos tardios - recursos bloqueantes e trabalho desnecessário no cliente - hydration mismatch, renderização dupla, flashes ou substituição tardia de conteúdo quando relevantes - se houver Critical CSS: contradições com CSS final e geometria ausente no primeiro rendering - se não houver sistema de Critical CSS, não recomende adicioná-lo sem evidência de necessidade 4. Estilos - regras duplicadas, não usadas, contraditórias ou excessivamente globais - especificidade desnecessária, abuso de !important e suposições frágeis de cascade - media queries redundantes ou breakpoints inconsistentes - espaçamento, larguras, tipografia ou variantes divergentes entre páginas similares - cobertura de temas se houver modo escuro/temas - efeitos globais acidentais originados em estilos locais - design tokens/variáveis compartilhadas contornados sem motivo 5. JavaScript/TypeScript e comportamento em runtime - código morto, helpers duplicados ou listeners registrados várias vezes - queries DOM ou renderização repetida em hot paths - reflows, repaints, leitura/escrita de layout ou observers desnecessários - listeners que poderiam ser delegados com segurança - handlers scroll/touch não passivos quando isso importa - estado duplicado entre servidor e cliente ou componentes - error handling, loading states ou cleanup incompletos - dependências grandes ou imports desnecessários para uma função pequena - hydration ou JavaScript cliente enviado onde HTML/output do servidor bastaria, se relevante 6. Desempenho e Core Web Vitals - provável elemento LCP e request chain - fontes, imagens e mídia não otimizadas - causas de CLS e dimensões não reservadas - custo INP/TBT/main-thread de scripts, renderização ou terceiros - trabalho duplicado, bundles duplicados ou recursos carregados sem uso - preload/preconnect/prefetch inúteis ou ausentes apenas quando houver evidência - caching ou compressão incompatíveis com o ambiente de deploy - melhorias que apenas deslocam custo para outro lugar 7. Responsividade e compatibilidade de navegador - overflow horizontal - min-width, width ou positioning frágeis - problemas de viewport mobile, safe area ou teclado - interações essenciais dependentes só de hover - touch targets pequenos demais - diferenças plausíveis em Safari/iOS, Firefox ou navegadores Android - features modernas sem fallback quando o alvo de navegador exige 8. Acessibilidade - navegação por teclado e ordem de foco - foco visível - labels de formulário e associação de erros - semântica de links e botões - dialogs, menus, tabs e disclosures - contraste e informação comunicada apenas por cor - reduced motion - zoom e reflow - atualizações dinâmicas que exigem anúncio acessível 9. SEO técnico e semântica - indexabilidade, canonical, robots e status codes - metadados ausentes, duplicados ou inconsistentes - headings e landmarks - links internos não rastreáveis ou dependentes de interação desnecessária - source HTML versus rendered HTML em sites JavaScript-heavy - hreflang somente se o site for realmente multilíngue - sitemap e structured data somente se presentes ou adequados - páginas duplicadas/superficiais/doorway geradas pelo sistema 10. Localização, conteúdo e metadados - strings hardcoded que ignoram o sistema de localização existente - placeholders ou variáveis traduzidos acidentalmente - texto que quebra layout ou componentes por comprimento - desalinhamento entre conteúdo visível, title, description, OG/schema e locale - rotas ou links levando ao idioma errado - fallbacks silenciosos escondendo traduções ausentes 11. Terceiros, privacidade e segurança no cliente - analytics, ads, CMP, chat, mapas, embeds ou widgets duplicados - scripts carregados antes do consentimento quando não deveriam - layout shifts causados por terceiros - secrets/tokens/dados sensíveis expostos - dependências desnecessárias ou desatualizadas - inicializações globais em páginas que não usam o recurso 12. Manutenibilidade e risco de regressão - fix local preferível a refatoração ampla - componentes compartilhados que exigem testes em várias rotas - testes existentes que precisam ser atualizados - ausência de testes para comportamento de alto risco - contratos implícitos entre arquivos que a mudança pode quebrar FORMATO DE SAÍDA Para cada finding use: - Prioridade: Crítica / Alta / Média / Baixa - Status: Problema verificado / Risco provável / Sugestão - Área - Arquivo + linha/seletor/componente - Problema - Por que importa - Correção mínima recomendada - Risco de regressão - Como verificar Depois adicione: 1. Resumo executivo — no máximo 10 pontos 2. Quick wins — apenas mudanças de baixo risco e alto valor 3. O que não mudar — partes que funcionam e seriam arriscadas de reescrever sem benefício 4. Plano de validação — testes/build/browser/métricas relevantes Não invente problemas para preencher categorias. Não chame preferência pessoal de “best practice”. Ainda não implemente nada.
Revisão de SEO
Você é um auditor sênior de SEO técnico para um site ou aplicativo web. IMPORTANTE: - Não altere nada ainda. - Não dê dicas genéricas. - Primeiro identifique o modelo real de renderização, roteamento, configuração de localização, CMS/framework/build e estrutura pública de URLs do projeto. - Relate apenas findings concretos no projeto existente, com evidências de arquivo/componente e página/URL quando possível. - Aplique verificações de forma condicional. Não presuma que o projeto seja estático, multilíngue, server-rendered, tenha sitemap, use structured data ou precise de hreflang. - Separe problemas verificados de recomendações e experimentos. Verifique sistematicamente: 1. Acessibilidade para busca e renderização - mecanismos de busca conseguem acessar URLs importantes sem autenticação ou recursos bloqueados? - diferencie source HTML, rendered HTML e conteúdo que exige interação do usuário - identifique conteúdo ou links importantes que dependem desnecessariamente de execução no cliente - em sites JavaScript-heavy, verifique se texto significativo, metadados e links rastreáveis aparecem no HTML renderizado - identifique conflitos acidentais de noindex, robots, canonical, redirect, status code ou renderização 2. SEO on-page - title único e alinhado à intenção - meta description útil e específica - um H1 principal claro e hierarquia de headings compreensível - conteúdo que atende à intenção real da página - anchor text descritivo - imagens informativas com alt text adequado - evitar keyword stuffing, boilerplate e páginas superficiais 3. Canonical e duplicação - canonical alinhado ao URL que deve ser indexado - trailing slash, protocolo, host, parâmetros e variantes normalizados conforme a arquitetura - páginas duplicadas ou quase duplicadas sem propósito - filtros, busca interna, paginação ou rotas paramétricas criando espaços de URL desnecessários, se presentes - ambientes de preview/staging corretamente excluídos do índice público 4. Links internos e arquitetura da informação - páginas importantes alcançáveis por links normais e rastreáveis - nenhuma página importante órfã - profundidade de clique razoável conforme a importância - hubs, categorias, breadcrumbs ou navegação contextual quando úteis ao projeto - anchor text consistente sem superotimização - links não escondidos atrás de interação desnecessária quando necessários para descoberta 5. Sitemap e descoberta - se houver sitemap: contém apenas URLs canônicos/indexáveis e exclui rotas irrelevantes - datas lastmod corretas quando usadas - sitemap indexes coerentes em sites grandes ou multilíngues quando relevantes - se não houver sitemap, avalie se ele realmente é necessário em vez de recomendar automaticamente - robots.txt não bloqueia acidentalmente recursos ou rotas necessárias 6. Sites multilíngues ou multirregionais — somente se relevante - URLs separados e estáveis por idioma/região - hreflang recíproco e códigos válidos quando usado - canonicals coerentes com a estratégia local - seletor de idioma com links rastreáveis - ausência de redirects automáticos que impeçam acesso a outras versões - metadados e conteúdo realmente localizados, não apenas navegação - intenção de busca e terminologia adequadas à região 7. Structured data — somente se presente ou realmente adequado - JSON-LD/schema consistente com conteúdo visível - tipo de schema suportado e relevante - nenhum dado inventado, oculto ou não visível - URLs, imagens, breadcrumbs, organização/produto/artigo consistentes quando aplicável - não adicionar schema só para “ter schema” 8. JavaScript SEO — somente se relevante - conteúdo importante disponível após renderização normal sem exigir clique/hover - links importantes renderizados como links rastreáveis - metadados não substituídos tardiamente ou de forma inconsistente - rotas client-side não devolvem status/fallback enganoso - lazy loading não depende de interações que crawlers não executam - diferenças entre source HTML e rendered HTML documentadas, não presumidas 9. Desempenho e UX como sinais de qualidade técnica - LCP, CLS e INP com field data quando disponível - problemas claros de renderização, estabilidade e interação - interstitials ou overlays intrusivos - usabilidade mobile - não atribua automaticamente problema de ranking a Core Web Vitals sem evidência 10. Conteúdo e oportunidades - canibalização entre páginas - conteúdo desatualizado ou sem utilidade - queries/intents mal atendidos - oportunidades long-tail realistas apoiadas pelo tema do site - páginas programáticas somente se oferecem valor distinto e útil - indique quando uma recomendação exige pesquisa externa de keywords em vez de inventar volume ou demanda FORMATO DE SAÍDA ## Resumo executivo No máximo 8 frases. ## Arquitetura de SEO detectada - modelo de renderização - framework/CMS/build, se identificado - estrutura de URL - idiomas/regiões, se presentes - evidências disponíveis/não disponíveis ## Findings Para cada finding material: Prioridade · Tipo (verificado/recomendação/experimento) · URL · Arquivo/componente · Evidência · Problema · Impacto provável · Correção mínima · Como verificar ## Problemas críticos de indexação/rastreamento Somente se existirem. ## On-page e metadados ## Links internos e arquitetura ## Multilíngue/regional Ou “Não se aplica”. ## Structured data Ou “Não se aplica”. ## Desempenho técnico/UX Separe dados medidos de hipóteses. ## Oportunidades de conteúdo Não invente volume de busca. ## Top 10 prioridades Ordene por impacto esperado, confiança e custo/risco. Não implemente mudanças até que sejam aprovadas.
Revisão da experiência do usuário
Tarefa: revisão de UX, SEO e conversão com pesquisa atual de boas práticas para este site ou aplicativo web: [INSIRA A URL] Avalie a experiência a partir destas perspectivas: 1. Experiência e orientação do usuário 2. SEO e estrutura de conteúdo 3. Conversão, ativação ou conclusão do objetivo principal do projeto 4. Acessibilidade e usabilidade mobile Antes de fazer recomendações: - identifique o que o produto/site realmente faz - identifique o público principal e a conversão ou tarefa principal - identifique as principais páginas de entrada e o caminho do usuário de primeira visita - identifique se é site de conteúdo, ferramenta, produto SaaS, ecommerce, portfólio, serviço local, comunidade, web app ou outro tipo - não presuma que o site tenha geradores, dashboard, fluxo com muitos formulários, teste grátis, ecommerce ou qualquer recurso específico Para recomendações materiais, faça uma breve verificação na web usando fontes atuais e confiáveis ou produtos diretamente comparáveis. Não use benchmarks genéricos quando não correspondem a esse tipo de produto. Diferencie princípios estabelecidos de usabilidade de hipóteses que precisam ser testadas. O objetivo não é implementar imediatamente. Primeiro crie uma avaliação compartilhada. Depois de revisão e concordância, pontos priorizados podem ser implementados e medidos. 1. Proposta de valor e call to action principal Avalie: - um novo visitante entende em poucos segundos o que o site oferece e para quem? - a ação principal é clara e visualmente distinta? - CTAs secundárias competem com a principal? - headline e texto de apoio descrevem um resultado concreto em vez de um slogan genérico? - elementos de confiança aparecem perto dos pontos de decisão quando necessários? Recomende: - o que manter - o que esclarecer - o que remover ou reduzir em destaque - 1–3 variações de texto ou hierarquia para testar apenas quando úteis 2. Entrada e onboarding do primeiro usuário Identifique a primeira tarefa significativa que um novo usuário deve concluir. Verifique: - o usuário sabe por onde começar? - precisa de conta, configuração, escolha, texto longo ou decisões antes de perceber valor? - há defaults inteligentes ou caminho guiado quando a complexidade é real? - a interface explica por que uma informação é necessária? - empty states ajudam o usuário a avançar? - erros são específicos e recuperáveis? Se o produto tiver um fluxo de trabalho complexo, avalie progressive disclosure, presets, exemplos ou modo guiado. Se for simples, não adicione onboarding apenas para imitar um padrão de SaaS. 3. Complexidade de recursos e progressive disclosure Classifique recursos como: - essenciais para o primeiro resultado - úteis depois do primeiro sucesso - avançados ou raros - administrativos/de configuração Verifique se: - opções avançadas dominam a interface cedo demais - controles importantes ficam escondidos sem motivo - seções recolhíveis, tabs ou páginas separadas melhorariam realmente a compreensão - usuários precisam memorizar informações entre etapas - a terminologia corresponde ao modelo mental do público Não reduza visibilidade de conteúdo ou links importantes para SEO apenas para deixar a UI “mais limpa”. Ao sugerir disclosure, explique impactos em acessibilidade, rastreabilidade e descoberta. 4. Demonstração concreta de valor Verifique se o site mostra claramente: - o que o usuário recebe - exemplo realista de antes/depois, demonstração, captura de tela, resultado gerado, estudo de caso, amostra ou resultado - quanto esforço é necessário - limitações ou requisitos importantes - próximo passo depois do resultado Se faltarem provas, recomende a forma mais adequada ao produto: demonstração interativa, exemplo estático, captura de tela, estudo de caso, avaliação verificável, portfólio, prévia, dados de exemplo ou outra. Não invente depoimentos, estatísticas, clientes ou resultados. 5. Navegação e arquitetura da informação Avalie: - labels de navegação compreensíveis sem conhecimento interno - hierarquia entre páginas principais, seções e utilitários - redundância ou itens sobrepostos - facilidade de descobrir destinos importantes - orientação: título da página, breadcrumbs quando úteis, estado ativo ou contexto - comportamento e menu mobile - footer como apoio, não como depósito de links Em sites grandes, avalie hubs/category pages e links contextuais. Em sites pequenos, não introduza mega menu ou hierarquia artificial. 6. Confiança, privacidade e redução de risco percebido Identifique dúvidas que o usuário pode ter antes da ação principal: - custo/preço - privacidade e uso de dados - conta ou cadastro - confiabilidade - qualidade do resultado - pagamentos/reembolsos - conhecimento ou credenciais - segurança - compatibilidade - suporte Verifique se o site responde a essas dúvidas no momento adequado. Se o produto lida com dados pessoais, pagamentos, arquivos, conteúdo do usuário ou IA, verifique se as explicações são específicas e não fazem promessas sem evidência. Não sugira selos ou badges de confiança sem base real. 7. Conteúdo, SEO e descoberta Analise: - intenção das principais páginas de entrada - title/H1 e proposta de valor - links internos - conteúdo duplicado ou muito semelhante - páginas superficiais - oportunidades de FAQ apenas quando há perguntas reais - páginas de comparação/alternativas somente se puderem ser úteis e precisas - localização se houver mercados linguísticos distintos - conteúdo que demonstre conhecimento real ou experiência direta Não crie páginas apenas para capturar keywords. Cada página sugerida deve ter um objetivo de usuário distinto. 8. Acessibilidade e UX mobile Verifique no mínimo: - navegação por teclado e foco - contraste - labels e mensagens de erro - touch targets - reflow/zoom - modais, menus, tabs e accordions - ordem lógica do conteúdo - textos longos e wrapping nos idiomas suportados - dependência de hover - UI sticky/fixed cobrindo conteúdo em telas pequenas 9. Medição e definição de sucesso Associe a cada recomendação principal uma métrica ou sinal observável, por exemplo: - click-through na CTA principal - conclusão da primeira tarefa - abandono em etapa específica - taxa de erro - conversão para contato/compra/cadastro - retorno à página ou uso repetido - sucesso da busca interna - engajamento com demo ou exemplo - feedback qualitativo de usuários Não defina limite universal sem dados do produto. Use baseline do próprio site, tendências e testes controlados quando possível. 10. Priorização e experimentos Para cada finding, forneça: - Problema - Evidência - Recomendação - Impacto esperado - Confiança - Esforço: Baixo / Médio / Alto - Prioridade: Crítica / Alta / Média / Baixa - Dependências - Métrica de sucesso - Risco ou trade-off Classifique propostas em: A. Correções claras — bugs ou problemas de usabilidade/acessibilidade com evidência forte B. Melhorias de alta confiança — provavelmente úteis, mas devem ser medidas C. Experimentos — hipóteses que exigem A/B test ou observação D. Não recomendado — ideias comuns que não se adequam a este projeto Formato final: ## Resumo executivo No máximo 10 pontos. ## Produto e caminho principal detectados - tipo de site/produto - público - objetivo principal - principais pontos de entrada - evidências utilizadas ## Findings prioritários Para cada um: Evidência · Impacto · Recomendação · Esforço · Prioridade · Métrica · Risco ## Quick wins Somente mudanças pequenas e de baixo risco. ## Experimentos a validar Com hipótese e métrica, não como fatos. ## O que preservar Elementos que funcionam e não devem ser simplificados/removidos sem motivo. ## Plano de 30/60/90 dias Somente se fizer sentido para o tamanho do projeto; caso contrário, use uma ordem simples de prioridade. Seja específico para o site realmente analisado. Não transforme a revisão em checklist genérica de SaaS, ecommerce, ferramenta de IA ou marketing, a menos que o projeto realmente seja desse tipo.
Revisão da renderização pelo Googlebot
Você é um auditor híbrido de SEO técnico, renderização, rastreabilidade, arquitetura da informação, acessibilidade e UX. IMPORTANTE: - Analise o site real e sua verdadeira arquitetura de renderização antes de aplicar recomendações. - Não presuma que o site seja estático, server-rendered, client-rendered, hydrated, feito com framework ou dependente de JavaScript. - O Google Search consegue renderizar JavaScript, mas a renderização tem limitações e conteúdo importante não deve depender desnecessariamente da interação do usuário. - O Google Search não interage com uma página para acionar carregamento de conteúdo. Trate conteúdo que só carrega após clique, hover ou evento de scroll acionado pelo usuário como risco de rastreamento/indexação que precisa ser verificado. - Diferencie source HTML, rendered HTML e conteúdo que aparece apenas após interação. - Não afirme que accordions, tabs, conteúdo renderizado no cliente ou conteúdo below-the-fold sejam inerentemente não indexáveis. Verifique a implementação. - Não avalie apenas pelo Lighthouse. - Não implemente mudanças ainda. Analise este site: [INSIRA A URL] Se arquivos do repositório/projeto estiverem disponíveis, inspecione-os também. Se Search Console URL Inspection, HTML renderizado, logs do servidor, Core Web Vitals de campo ou arquivo HAR estiverem disponíveis, use-os como evidência. Informe claramente quando a evidência não estiver disponível. ----------------------------------- FASE 1 — IDENTIFIQUE A ARQUITETURA REAL ----------------------------------- Determine, quando possível: - framework/CMS/construtor do site - modelo de renderização: estático, SSR, SSG, CSR, híbrido, streaming ou outro - roteamento no servidor ou cliente - se o conteúdo principal está no HTML inicial - o que JavaScript adiciona ou substitui - se há hydration - uso de lazy loading, infinite scroll, virtualização, accordions, tabs ou conteúdo condicional - estrutura de deploy/hospedagem/CDN quando relevante para rastreamento e renderização Não trate “view source” como equivalente ao resultado final se o site usa renderização no cliente. Ao mesmo tempo, não presuma que renderização no cliente seja automaticamente um problema. ----------------------------------- FASE 2 — ACESSO, STATUS E DIRETIVAS ----------------------------------- Verifique: - status HTTP de URLs importantes - cadeias e loops de redirect - robots.txt - meta robots e X-Robots-Tag - canonical - recursos necessários para renderização bloqueados por engano - ambientes staging/preview indexáveis acidentalmente - soft 404 ou rotas client-side que retornam 200 para conteúdo inexistente - autenticação, geoblocking ou cookie wall que possa impedir acesso Diferencie configurações intencionais de erros. ----------------------------------- FASE 3 — HTML INICIAL VS HTML RENDERIZADO ----------------------------------- Para conteúdo e links importantes, compare: 1. o que existe na resposta HTML inicial 2. o que aparece após renderização JavaScript normal 3. o que aparece apenas após ação do usuário Verifique especialmente: - title e meta description - canonical - H1 e conteúdo principal - navegação principal - links internos importantes - structured data - conteúdo principal de produto/serviço/artigo - paginação ou links para itens adicionais Classifique cada diferença importante como: - Seguro / esperado - Precisa ser verificado - Risco concreto Não penalize conteúdo apenas porque é renderizado por JavaScript se estiver disponível de forma confiável no DOM renderizado. ----------------------------------- FASE 4 — CONTEÚDO DEPENDENTE DE INTERAÇÃO ----------------------------------- Identifique conteúdo ou links que exigem: - clique - hover - foco - evento de scroll do usuário - swipe - abertura de modal - seleção de tab - input em formulário - login Pergunte: - o conteúdo ainda é renderizado no DOM sem essa ação? - existe um caminho de URL rastreável alternativo? - o link é um verdadeiro <a href> quando deveria ser? - o conteúdo é importante para indexação ou descoberta? - o padrão realmente atende à UX ou introduz dependência desnecessária? Accordions e tabs não são automaticamente um problema. O risco surge quando conteúdo ou links importantes não existem até ocorrer uma ação que o crawler não executa. ----------------------------------- FASE 5 — LAZY LOADING, IMAGENS E INFINITE SCROLL ----------------------------------- Verifique: - imagens above-the-fold não atrasadas desnecessariamente - width/height ou aspect-ratio reservados - src/srcset/sizes corretos - lazy loading acionado por visibilidade ou mecanismo confiável, não por clique - conteúdo lazy importante pode carregar sem gesto do usuário - infinite scroll oferece URLs persistentes/paginadas ou outro caminho rastreável quando o conteúdo deve ser descoberto - placeholders não causam CLS significativo - mídia essencial acessível sem scripts frágeis de terceiros Não recomende eager loading para tudo. Proteja LCP sem inflar o tráfego inicial. ----------------------------------- FASE 6 — LINKS E ARQUITETURA DA INFORMAÇÃO ----------------------------------- Verifique: - links importantes implementados como links rastreáveis - anchor text descritivo - páginas órfãs - profundidade de clique - hubs e categorias - breadcrumbs quando úteis - rotas alcançáveis apenas por estado do router ou eventos JavaScript sem URL navegável - links duplicados ou excessivamente numerosos que não ajudam o usuário - navegação mobile oferece caminhos essenciais equivalentes Mapeie o fluxo para as páginas mais importantes. Não presuma que toda página precise ficar a um clique da home. ----------------------------------- FASE 7 — MULTILÍNGUE E MULTIRREGIONAL, SE PRESENTE ----------------------------------- Se o site tiver vários idiomas/regiões, verifique: - URLs separados e estáveis - conteúdo visível no idioma correto - hreflang recíproco, se usado - canonicals coerentes - x-default se a estratégia exigir - seletor de idioma com links rastreáveis - redirects automáticos ou variantes apenas por cookie que possam esconder versões - conteúdo regional realmente justificado Se o site for monolíngue, marque esta fase como Não se aplica. ----------------------------------- FASE 8 — CORE WEB VITALS E CUSTO DE RENDERIZAÇÃO ----------------------------------- Avalie com dados medidos quando disponíveis: - provável elemento LCP e request chain - CLS por imagens, fontes, anúncios, embeds, banners, UI de consentimento, componentes dinâmicos ou hydration - pressão de INP/main-thread por JavaScript, terceiros, event handlers, renderização e long tasks - CSS/JS render-blocking - carregamento de fontes - dimensionamento de imagens e entrega responsiva - requests de rede desnecessárias - bundles ou código duplicados Separe observações de laboratório, dados de campo e hipóteses. ----------------------------------- FASE 9 — UX ABOVE-THE-FOLD SEM VIÉS DE DESIGN ----------------------------------- Avalie o primeiro viewport quanto a: - objetivo da página claro - tarefa principal ou CTA - banners/overlays intrusivos - estabilidade do layout - conteúdo significativo aparecendo rapidamente - legibilidade mobile - informações críticas atrasadas por renderização ou lógica de consentimento Não otimize apenas por minimalismo visual. Proteja as informações que o usuário precisa para entender e confiar na página. ----------------------------------- FASE 10 — MOBILE, ACESSIBILIDADE E ROBUSTEZ ----------------------------------- Verifique: - overflow responsivo - touch targets - acesso por teclado - estados de foco - menus/dialogs/accordions/tabs - labels e erros de formulário - zoom/reflow - contraste e temas, se presentes - reduced motion, se relevante - problemas de Safari/iOS onde a implementação os torna plausíveis Problemas de acessibilidade também podem impedir usuários e sistemas automatizados de alcançar conteúdo de forma confiável, por isso relate-os separadamente de preferências cosméticas. ----------------------------------- FORMATO DE SAÍDA ----------------------------------- ## Resumo executivo No máximo 8 frases. ## Arquitetura detectada - Modelo de renderização - Framework/CMS, se identificado - O que está presente no HTML inicial - O que depende de JavaScript - Evidências disponíveis / indisponíveis ## Problemas críticos de rastreamento ou indexação Somente problemas confirmados ou fortemente apoiados por evidência. ## HTML inicial vs HTML renderizado Para conteúdo e links importantes. ## Findings de renderização / JavaScript Para cada um: Prioridade · Evidência · URL/componente · Problema · Por que importa · Correção mínima · Método de verificação ## Links internos e arquitetura da informação ## Findings multilíngues / regionais Ou “Não se aplica”. ## Core Web Vitals / desempenho Separe dados medidos de hipóteses. ## Acessibilidade / mobile ## Conteúdo e semântica ## Quick wins Somente itens de baixo risco com evidência clara. ## Roadmap de prioridades Top 10, ordenado por impacto esperado e confiança. ## Checklist de verificação Inclua Search Console URL Inspection, verificações do HTML renderizado, logs de servidor, CWV de campo, HAR/perfil de navegador ou testes de crawl somente quando relevantes. Seja crítico, técnico e preciso. Não forneça clichês genéricos de SEO ou linguagem de marketing. Não apresente suposições antigas sobre indexação de JavaScript como fatos universais. Explique causas concretas, evidências, efeitos prováveis, correções mínimas e como verificar cada finding material.
Dica: Corrija primeiro os problemas de prioridade alta. Não refatore código funcional apenas porque a IA sugere um padrão mais limpo.
Etapa 7

Publique e melhore

Resultado: ciclo de melhoria

Publique o site, observe o que acontece e melhore em pequenos passos. Um site nunca está definitivamente pronto; ele se torna útil por meio de feedback, medição e iteração cuidadosa.

Quando as funcionalidades e a versão final no idioma-fonte estiverem estáveis, avalie se o site também deve atender pessoas em outro idioma ou mercado regional. Uma versão bem localizada pode tornar o conteúdo mais relevante para esses usuários e ampliar oportunidades na busca orgânica, mas somente quando a tradução é útil, a implementação técnica está correta e o resultado é revisado para o locale-alvo.

Verificações práticas:

Prompt de localização

Localização para o idioma de destino & revisão de SEO
Faça uma revisão completa de localização, revisão linguística em nível de falante nativo, linguagem de SEO, qualidade de prompts e implementação para um site ou aplicativo web existente que já tenha uma versão estável no idioma-fonte. Dados do projeto: - Nome do projeto/site: [PROJECT_OR_SITE_NAME] - URL pública ou de preview: [PUBLIC_URL_OR_PREVIEW] - Idioma-fonte: [SOURCE_LANGUAGE] - Idioma-alvo: [TARGET_LANGUAGE] - Locale/região-alvo: [TARGET_LOCALE] - Mercado/região principal: [PRIMARY_MARKET_OR_REGION] - Repositório/caminho do projeto: [PROJECT_PATH_OR_REPOSITORY] - Caminho do conteúdo no idioma-fonte: [SOURCE_CONTENT_PATH_OR_UNKNOWN] - Caminho do conteúdo traduzido: [TRANSLATED_CONTENT_PATH_OR_UNKNOWN] - Framework, CMS, construtor ou stack: [FRAMEWORK_OR_CMS_OR_UNKNOWN] - Público-alvo: [TARGET_AUDIENCE] OBJETIVO Crie uma versão no idioma-alvo que pareça ter sido originalmente pesquisada, escrita, editada e publicada para esse locale, preservando significado do fonte, funcionalidade, arquitetura técnica, acessibilidade, intenção de SEO e comportamento do produto. Isto não é uma tradução palavra por palavra nem apenas uma revisão ortográfica. O objetivo é expandir o site de forma responsável para usuários que pesquisam, leem e tomam decisões no idioma ou região-alvo. Não prometa que tradução sozinha aumentará rankings ou tráfego. Trate SEO localizado como combinação de conteúdo local útil, URLs/sinais adequados, intenção de busca, links internos, correção técnica e qualidade contínua. REGRAS INEGOCIÁVEIS - Primeiro inspecione a arquitetura real. Não presuma sistema de build, HTML estático, framework JavaScript, CMS, banco de dados, SSR, CSR ou framework de localização. - Respeite o source of truth e o fluxo real de geração existentes. - Não introduza sistema de build apenas para localização se o projeto funciona sem um. - Não traduza código, identificadores, URLs, nomes de produto, marcas, variáveis, placeholders, API keys, seletores ou sintaxe de template, salvo solicitação explícita. - Não altere texto-fonte fornecido pelo usuário que deve continuar como fonte. - Preserve comportamento dos prompts e lógica dinâmica antes de melhorar elegância linguística. - Diferencie erros objetivos, recomendações fortes e preferências de estilo. - Não invente fatos, volume de keywords, requisitos legais, features, depoimentos ou evidências. - Não alegue revisão por falante nativo humano se isso não aconteceu. - Não alegue browser pass se o site renderizado não foi realmente verificado em navegador. - Implemente alterações pequenas e rastreáveis; evite refatorações não relacionadas. FASE 0 — INVENTÁRIO DO PROJETO E DA LOCALIZAÇÃO Antes de traduzir, identifique: - idiomas e locales suportados - rotas públicas e estrutura de URLs - fontes de conteúdo e outputs gerados - arquivos de tradução ou diretórios por locale - componentes/templates compartilhados - navegação, rodapé, breadcrumbs e seletor de idioma - formulários, mensagens de validação, notificações e estados de erro - metadados de SEO e Open Graph - structured data - alt text e labels de acessibilidade - emails ou mensagens ao usuário armazenados no projeto - prompts/templates/geradores ou outro conteúdo dinâmico, se presente - testes, CI e quality gates existentes - arquivos ou rotas que não podem ser inspecionados Registre claramente o que não está acessível. Não afirme ter revisado “o site inteiro” se parte do conteúdo não pôde ser analisada. FASE 1 — TRADUÇÃO E LOCALIZAÇÃO BÁSICA Traduza significado, não a estrutura gramatical do idioma-fonte. Para todo texto visível ou potencialmente visível, verifique: - gramática - ortografia - pontuação - uso de maiúsculas - artigos, preposições e concordância - ordem natural das palavras - registro e forma de tratamento - formulação idiomática - convenções de data, hora, números, moeda e unidades - terminologia do setor - clareza para o público-alvo - comprimento em botões, tabs, menus e layout mobile Evite traduções literais, estruturas inglesas pouco naturais e linguagem de marketing artificial. Não melhore fluidez mudando o significado. FASE 2 — TERMINOLOGIA E DECISÕES REGIONAIS Crie um pequeno glossário de trabalho baseado nos termos que realmente aparecem no projeto. Para cada termo importante, decida se deve: 1. ser traduzido 2. permanecer em inglês por ser padrão do setor 3. permanecer em inglês, mas receber explicação no primeiro uso 4. usar forma híbrida estabelecida 5. ser adaptado gramaticalmente 6. usar variante específica da região 7. ser evitado por ser pouco natural, ambíguo ou ultrapassado Considere: - uso real entre falantes nativos do locale-alvo - terminologia profissional - nível de conhecimento do público - intenção de busca - consistência com o restante do produto - diferenças entre locales que compartilham o mesmo idioma Não adote como regra global que todos os termos técnicos devem ficar em inglês ou ser traduzidos. FASE 3 — CONTEÚDO DINÂMICO, UI E TEMPLATES Se o projeto compõe texto dinamicamente, teste a frase final, não apenas fragmentos. Verifique: - placeholders na ordem correta - variáveis não traduzidas por engano - valores inseridos com concordância gramatical - singular/plural/gênero/caso quando relevantes - pontuação e espaços depois da inserção - campos opcionais vazios não criam frases quebradas - aspas, apóstrofos e quebras de linha - mensagens loading, empty, success, error e retry - labels de formulário e mensagens de validação - botões para copiar/editar/redefinir/enviar - texto em dialogs, tooltips, menus, tabs e accordions - strings acessíveis que não aparecem visualmente Se não houver conteúdo dinâmico, marque esta fase como Não se aplica. FASE 4 — PROMPTS, IA OU CONTEÚDO GENERATIVO, SOMENTE SE PRESENTE Se o produto incluir prompts, geradores ou recursos de IA, trate os prompts como instruções funcionais, não como simples texto de site. Para cada prompt, verifique: - linguagem natural no idioma-alvo - significado e resultado solicitado equivalentes ao fonte - instruções sem contradições - idioma de saída explícito quando necessário - placeholders e texto citado preservados - nomes de provedores apenas quando necessários - nenhuma promessa de precisão garantida - nenhuma solicitação de chain-of-thought privado - nenhuma dependência desnecessária de features específicas de fornecedor - listas, parágrafos e separadores multilinha continuam legíveis - entrada longa, mínima, caracteres especiais, aspas e campos opcionais quando relevantes Para funções de tradução, diferencie claramente idioma-fonte, idioma-alvo, revisão linguística, reescrita, localização e transcriação. Se não houver recursos de IA/prompt, marque esta fase como Não se aplica. FASE 5 — SEO LOCALIZADO E INTENÇÃO REGIONAL Primeiro identifique a estratégia real de SEO e roteamento do projeto. Verifique, quando relevante: - title localizado - meta description - H1/H2/H3 - anchor text e links internos - breadcrumbs - slugs/URLs quando localização de rotas faz parte da arquitetura - canonical - hreflang e códigos de idioma/região - x-default se usado na estratégia - sitemap - Open Graph - structured data - alt text - declaração lang - seletor de idioma com links rastreáveis Pesquise ou verifique intenção de busca regional para decisões importantes de SEO. Não traduza keywords literalmente presumindo que usuários pesquisam da mesma forma. Não crie doorway pages locais ou variantes regionais sem valor distinto. Não prometa aumento de ranking ou tráfego. FASE 6 — PRECISÃO FACTUAL, JURÍDICA E DE ALTO RISCO Sinalize separadamente afirmações que exigem verificação, por exemplo: - preços - disponibilidade de features - comportamento atual de plataformas ou modelos de IA - requisitos legais ou de privacidade - impostos, finanças, saúde ou segurança - estatísticas - rankings ou benchmarks - requisitos específicos de país Não “corrija” silenciosamente uma afirmação técnica ou jurídica questionável durante a tradução. Classifique-a como finding e use fontes oficiais quando a verificação externa for solicitada. FASE 7 — ACESSIBILIDADE E LINGUAGEM DE UX Verifique: - alt text - aria-labels e accessible names - finalidade dos links - instruções de expandir/recolher - mensagens de erro - labels do seletor de idioma - controles apenas com ícone - texto para leitor de tela - labels curtos em mobile - consistência entre o verbo da CTA e o resultado Texto de acessibilidade deve descrever função e propósito, não apenas aparência visual. FASE 8 — PRIMEIRO PASSE INDEPENDENTE DE REVISÃO LINGUÍSTICA Depois da tradução inicial, releia todo conteúdo alterado como editor experiente do idioma-alvo. Neste primeiro passe procure especialmente: - traduções literais - ordem de palavras pouco natural - anglicismos desnecessários - termos técnicos inconsistentes - registro regional incorreto - frases longas ou difíceis demais - repetição - uso inconsistente de maiúsculas - CTAs pouco naturais - headings estranhos - listas/quebras de linha quebradas em prompts longos - placeholders/variáveis alterados - desvio de significado Não faça substituições globais amplas sem verificar cada contexto. FASE 9 — IMPLEMENTAÇÃO Implemente apenas mudanças revisadas e aceitas. Durante a implementação: - preserve encoding e formatação quando prático - preserve source of truth e fluxo de output gerado - preserve translation keys e placeholders - preserve HTML/Markdown/JSX/templates - preserve código e termos protegidos - evite refatorações não relacionadas - evite ruído de reformatação no arquivo inteiro - atualize fonte, metadados, schema, rota/config e output em conjunto somente se a arquitetura exigir - siga regras existentes de build e deploy Não edite output gerado no lugar do fonte, a menos que o projeto defina esse output como source of truth mantido. FASE 10 — QA TÉCNICA Execute verificações existentes relevantes, por exemplo: - build - lint - type checking - unit/integration/E2E - validação de translation keys - traduções ausentes/duplicadas - consistência de placeholders - links internos - validação HTML/JSON/YAML/schema - acessibilidade - metadados de SEO - canonical/hreflang - responsividade/overflow - testes de navegador - paridade do output gerado Não enfraqueça um teste apenas para fazê-lo passar. Atualize testes de texto exato quando uma mudança aprovada legitimamente altera texto visível. FASE 11 — SEGUNDO PASSE INDEPENDENTE DE REVISÃO LINGUÍSTICA Após implementação e rebuild/renderização, faça uma segunda revisão completa do ponto de vista de um editor experiente do idioma-alvo. Esse segundo passe é obrigatório e não deve repetir mecanicamente a checklist do primeiro. Leia a redação final em contexto e compare novamente com o significado da fonte. Verifique especialmente: - cada página/rota alterada - title e meta description - H1/H2/H3 - navegação/breadcrumbs alterados - botões e CTAs - formulários e estados de validação - prompts longos e quebras de linha intencionais - exemplos e composições dinâmicas de placeholders - labels e wrapping mobile - labels de acessibilidade - conteúdo visível e oculto/progressivo - links internos localizados - vocabulário e registro do locale - nenhum fragmento do fonte, exceto nomes/termos/exemplos intencionais - nenhum desvio regional, especialmente entre variantes do mesmo idioma Quando possível, revise o site renderizado, não apenas arquivos-fonte. Se nenhum navegador estiver disponível, declare essa limitação e faça o segundo passe em nível de fonte sem alegar revisão de páginas renderizadas. FASE 12 — VERIFICAÇÃO FINAL Antes de considerar o locale concluído: 1. escaneie novamente arquivos alterados em busca de texto visível não traduzido 2. escaneie novamente redação rejeitada/substituída 3. verifique placeholders, variáveis, interpolação e comportamento dos prompts 4. verifique rotas localizadas e links internos 5. verifique canonical/hreflang quando aplicável 6. verifique metadados, alt e labels de acessibilidade 7. verifique structured data se presente 8. execute build e testes relevantes 9. verifique páginas representativas em celular, tablet e desktop quando possível 10. verifique modo claro/escuro se presentes 11. releia todo conteúdo alterado mais uma vez como prosa natural contínua, não apenas frase por frase SAÍDA / RELATÓRIO Forneça: ## Resumo da localização - idioma e locale-alvo - arquivos/rotas alterados - arquitetura/sistema de localização detectado - o que foi traduzido/localizado - o que foi deliberadamente mantido sem mudança ## Decisões terminológicas Termos importantes traduzidos, mantidos, explicados ou regionalizados. ## Findings e decisões Para cada item importante: ID · Severidade · Tipo · Texto-fonte · Texto-alvo atual · Proposta · Justificativa · Status (Aceito/Modificado/Rejeitado/Decisão humana necessária) · Referência de implementação ## Decisões de SEO/região URLs, estratégia hreflang/canonical, slugs e adaptações de intenção somente quando relevantes. ## Primeira revisão linguística O que foi verificado/corrigido. ## Segunda revisão linguística Confirme que ocorreu um segundo passe separado, o que ele encontrou e se analisou páginas renderizadas ou apenas fontes. ## Validação técnica Somente testes/verificações realmente executados e resultados. ## Riscos ou decisões humanas restantes Jurídico, factual, terminologia, mercado, layout ou navegador. ## Arquivos alterados Lista exata. PADRÃO FINAL A versão localizada deve soar natural para o público-alvo, preservar significado e comportamento do produto, respeitar a arquitetura real, usar terminologia adequada ao locale, permanecer coerente técnica e semanticamente para SEO e receber um segundo passe independente de revisão linguística após a implementação. Não descreva a localização como “native-reviewed”, “human-reviewed”, “legally reviewed” ou “browser-tested” se essa revisão não ocorreu de fato.
Próximo passo: use o Gerador de prompts para textos e e-mails para os textos da página e o Gerador de prompts para imagens com IA para conceitos visuais.
Conclusão

Um site nunca é apenas código

A IA pode ajudar você a planejar páginas, escrever textos, gerar código e auditar o resultado, mas o site ainda precisa do seu julgamento. Um bom site não é o que tem mais recursos; é aquele que as pessoas entendem, confiam e conseguem usar sem atrito.

Três fatores importam mais do que adicionar recursos:

  1. Clareza: os visitantes devem entender em poucos segundos para que serve o site.
  2. Confiança: carregamento rápido, conteúdo legível, links funcionais e informações transparentes fazem o site parecer real.
  3. Controle: código estático e simples é mais fácil de testar, manter e reverter quando algo quebra.

Comece de forma simples, mantenha a estrutura estática e legível, verifique por conta própria cada alteração importante e melhore um problema de cada vez. É assim que um site criado com auxílio da IA se torna confiável, em vez de ser apenas mais um rascunho gerado.

Comece pela clareza

Tome hoje a primeira decisão sobre o site

Um objetivo e um plano de páginas claros evitam a maior parte do retrabalho. Comece por eles antes de pedir à IA que escreva código ou textos.

Compartilhar esta página

Adicionar o PromptingEasy à sua tela

Use o menu do navegador e escolha a opção para instalar este site ou adicioná-lo à tela inicial.