Começar

Vibe coding para designers: a parte que decide se funciona

Fazer um agente construir algo é fácil hoje em dia. O verdadeiro talento é fazer com que isso ainda se pareça com o seu design na décima segunda tela, e isso é decidido, em grande parte, antes de você digitar o primeiro prompt.

Atualizado 2026-07-27

A configuração é a habilidade

A experiência comum é que as duas primeiras telas são surpreendentes e a décima é uma bagunça. Isso não é o modelo piorando. É que nada no projeto definiu como a coisa deveria parecer, então cada turno decide novamente: um espaçamento ligeiramente diferente aqui, um cinza novo ali, um novo destaque quando o anterior "parecia um pouco flat".

Profissionais que entregam consistentemente descrevem o mesmo hábito: esboçam o scaffolding primeiro (tema, grid, tipografia, cor) e só então começam a pedir funcionalidades. Essa ordem é toda a diferença, e é a parte que é ignorada porque criar prompts é mais divertido.

Consistency check · Spacing off the scale

The same plan card, built two ways in Ambient Sage.

Drifting system

Pricing

Starter$19/mo

Everything a small team needs to ship a branded UI.

Consistent system

Pricing

Starter$19/mo

Everything a small team needs to ship a branded UI.

What to notice: Esquerda: o mesmo componente solicitado duas vezes, em duas sessões, sem nada fixando o espaçamento. Direita: ambos construídos com base em um único conjunto de tokens.

A primeira hora

  1. 1

    Coloque um conjunto de tokens no projeto

    Papéis de cores nomeados para light e dark, uma escala tipográfica, espaçamentos, raios. Não uma paleta: papéis, para que a resposta para "qual a cor de um botão desativado" exista antes que qualquer coisa precise dela. Um comando instala um conjunto completo se você preferir não montá-lo: npx shadcn add https://identityforge.io/r/ambient-sage.json.

  2. 2

    Escreva um arquivo de regras que proíba coisas

    Seja qual for a ferramenta que você usa: .cursor/rules/design.mdc, .devin/rules/design.md, uma linha no CLAUDE.md. Mantenha como política, não como gosto: use apenas os tokens semânticos, nunca um hex puro, nenhum segundo destaque em uma tela, nunca entregue uma alteração no light sem a contraparte no dark, e pergunte em vez de inventar quando o sistema for omisso.

  3. 3

    Tenha um preview rodando antes de construir qualquer coisa

    Você é designer; você revisa olhando. Se você não consegue ver a mudança aplicada, você está revisando código, que é a única coisa para a qual você não está preparado.

  4. 4

    Faça o primeiro commit

    Antes da primeira funcionalidade. Este é o seu baseline e, a partir daqui, cada prompt é reversível. O git é o botão de undo. O do chat não é.

Prompts são reescritos e esquecidos. Um arquivo no projeto é lido todas as vezes.

O arquivo de regras importa mais do que parece, e especificamente as proibições. Uma preferência adiciona uma opção; uma proibição remove todas as outras. "Use nosso verde" deixa qualquer padrão genérico ainda legal. "Nunca introduza uma cor que não seja um token" não deixa. Analisamos 299 documentos de design públicos escritos exatamente para esse propósito e 76% listavam apenas preferências, o que é a descrição precisa de por que eles param de funcionar por volta da quinta tela.

Trabalhando em passos revisáveis

O problema autoinfligido mais comum é pedir demais de uma vez. Um prompt que produz um diff de quarenta arquivos é um diff que ninguém lê, o que significa que o desvio entrou sem revisão e você o encontrará mais tarde como "por que esta página parece diferente".

  • Uma tela ou um componente por turno. Olhe, faça o commit, siga em frente.
  • Faça commit antes de cada prompt, não depois. Assim, o estado anterior correto está sempre a um comando de distância e você nunca precisa decidir se a última alteração valeu a pena enquanto tenta corrigi-la.
  • Diga o que não deve ser tocado. "Altere apenas este componente" evita aquela refatoração "prestativa" em três arquivos que você já havia aprovado.
  • Quando as coisas derem errado, reverta em vez de negociar. Três rodadas de "não, não é assim" resultam em um remendo que satisfaz a conversa, mas não o design. Volte para o último commit estável e peça novamente com um prompt melhor.

Peça o plano antes do código

Para qualquer alteração que envolva mais de um arquivo, pergunte o que o agente pretende mudar e em quais arquivos, e leia isso primeiro. Custa apenas um turno, é escrito em uma linguagem que você consegue avaliar e evita mal-entendidos que são caros de desfazer depois.

Revisando um diff sem ler código

Esta é a habilidade que vale a pena aprender, e é basicamente uma habilidade de revisão de design com a "roupa" do git. Você não está verificando se o código é bom. Você está verificando quatro coisas, e todas as quatro são visíveis sem entender uma única linha de lógica.

O que você vêO que significa
Um código hex ou rgb(#f5f5f4, rgb(120,113,108)Um token foi ignorado. Este valor não acompanhará a mudança de tema e não terá um correspondente no modo escuro
O nome de uma nova fontefont-family: 'Poppins'Uma segunda tipografia entrou no projeto sem que houvesse uma decisão
Números de espaçamento estranhospadding: 13px, gap: 7pxFora da escala. Individualmente invisíveis, coletivamente são o motivo de nada estar alinhado
Arquivos que você não mencionouMudanças em componentes não relacionados à solicitaçãoUma refatoração prestativa. Às vezes é bom, mas sempre vale a pena saber antes que isso se acumule
O que procurar em um diff e o que cada item significa ao ser encontrado.

Essas quatro verificações levam cerca de um minuto por diff e pegam a maioria das causas de drift. Todo o resto (se o gerenciamento de estado é sensato, se a query é eficiente) genuinamente não é seu trabalho nesta etapa, e fingir o contrário é o que faz os designers evitarem a revisão completamente.

Modos de falha que parecem sucesso

  • Aceitação condescendente. Se você perguntar "isso está seguindo o design system?", geralmente ouvirá que sim. Em vez disso, pergunte "liste cada valor de cor neste arquivo que não seja um token": uma pergunta com uma resposta verificável.
  • Hardcoding para fazer funcionar. Um valor colado no lugar de uma busca torna a tela correta, mas o sistema errado. Isso aparece na primeira vez que você altera um token e um componente não se move.
  • Remendar o resultado em vez de corrigir a causa. Uma margem adicionada para compensar um layout que estava errado dois componentes acima. Cada remendo é pequeno; o décimo é o motivo pelo qual nada pode ser alterado com segurança.
  • Melhorar o sistema no meio da tarefa. Uma nova cor introduzida "para dar contraste". Isso é drift com uma justificativa anexa, e é o tipo mais difícil de detectar porque o raciocínio faz sentido.
  • Passar no teste errado. Renderizou, então funciona. Verifique o modo escuro, um estado vazio e uma string longa em uma coluna estreita antes de acreditar.

De quanto código você realmente precisa?

Menos do que os cursos sugerem e mais do que zero. Felizmente, a quantidade necessária é específica, não geral.

  • Ler um diff. Verde adicionado, vermelho removido e as quatro verificações acima. Uma tarde.
  • Git básico. Commit, visualizar log, reverter para um commit. Meia hora, e é a meia hora de maior retorno disponível.
  • Onde as coisas ficam. Qual arquivo é o tema, qual é um componente, qual é uma página. Peça ao agente para explicar a estrutura uma vez. Ele é bom nisso.
  • Ler um erro. Não corrigi-lo. Ser capaz de colar a parte relevante em vez de um screenshot de todo o terminal.

O que você não precisa é escrever React, entender ferramentas de build ou gerenciar dependências. É exatamente para isso que o agente serve, e o tempo gasto aprendendo isso é tempo não gasto na habilidade de revisão, que nada mais pode fazer por você.

Onde parar

Vibe coding é excepcional para protótipos, ferramentas internas, sites de marketing e para provar que uma interação vale a pena ser construída. É genuinamente arriscado nos limites onde um erro não é visual: autenticação, pagamentos, qualquer coisa que toque em dados de clientes, qualquer coisa com migração. Essas falhas não aparecem no preview, que é o único canal de revisão que você tem.

Uma regra útil: se o pior resultado de estar errado é que fique feio, publique e itere. Se o pior resultado é que os dados ou o dinheiro de outra pessoa sejam afetados, isso é um handoff, não um prompt.

Comece com a estrutura, não com o prompt

Cada kit do Identity Forge instala um conjunto completo de tokens mais um arquivo DESIGN.md escrito (funções de cores em light e dark, um pairing de fontes real, motivos e proibições) em um único comando. É a configuração da primeira hora, resolvida.

FAQ

Designers precisam aprender a programar para fazer vibe coding?

Não para escrever o código. Você precisa de quatro coisas específicas: ler um diff, git básico (commit, log, revert), saber qual arquivo é o tema versus um componente e conseguir ler um erro bem o suficiente para colar a parte relevante. Isso leva aproximadamente uma tarde e é uma habilidade diferente de programar.

Por que meu app criado por IA parou de parecer consistente?

Porque nada no projeto fixou o visual, então cada turno o redefine. A solução é um artefato durável em vez de um prompt melhor: um conjunto de tokens com roles nomeadas em ambos os modos e um arquivo de regras que proíba cores puras, novas fontes e segundos acentos. Prompts são esquecidos entre os turnos; arquivos são relidos em cada um deles.

Como reviso uma alteração se não sei ler o código?

Procure por quatro coisas no diff: qualquer valor hex ou rgb() (um token ignorado), qualquer nome de fonte nova, valores de espaçamento fora da sua escala, como 13px ou 7px, e arquivos que você não solicitou. Isso leva cerca de um minuto e detecta a maior parte do que causa a deriva visual. O restante genuinamente não é sua função nesta etapa.

Quanto devo pedir em um único prompt?

Uma tela ou um componente. Um prompt que gera um diff de quarenta arquivos é um diff que ninguém lê, o que significa que a deriva não revisada entrou no projeto. Faça commit antes de cada prompt para que o último estado estável esteja sempre a um comando de distância e, quando um resultado der errado, use revert e peça novamente em vez de tentar negociar através de três rodadas de correções.

O que eu não devo fazer via vibe coding?

Qualquer coisa onde o erro não seja visível no preview: autenticação, pagamentos, qualquer coisa que toque em dados de clientes e qualquer coisa com migração de banco de dados. Se o pior resultado de um erro for apenas visual, itere livremente. Se o pior resultado afetar os dados ou o dinheiro de alguém, passe a tarefa para um desenvolvedor.