Processo · novembro de 2026

Frontend com o Claude Code

O processo e o método que usei em mais de 30 PRs de design system e dark mode em produção, e o que aprendi fazendo. Eu decido produto e visual; o Claude atua como dev sênior; a engenharia revisa e faz o merge.

Ver o método Material completo
Fluxo
10 passos em 4 fases
Pontos de parada
Plano e evidência
Aprendizados
8, com o que mudou por causa deles
Nesta página
    A ideia01

    O método em uma frase

    Cada card vira uma sessão do Claude, numa worktree própria, com um prompt de entrada claro e dois pontos de parada: o plano e a evidência. O resto (código, validação, prints, testes, PR) o Claude executa e me mostra. Commit e PR, só quando eu peço.

    O que mais mudou o resultado foi deixar explícita a fronteira de decisão: o Claude resolve sozinho o que é técnico e reversível, e me consulta quando a decisão é de produto, de visual, envolve outra pessoa ou não tem volta.

    • EscopoDesignerEscopo do card e o que fica de foraClaudeOrganização técnica: arquivos, commits, ordem
    • VisualDesignerVisual, padrão, comportamento que o usuário vêClaudeQual componente do design system usar, tokens, refactor seguro
    • PlanoDesignerAprovar o plano antes de editarClaudeValidações: lint, tipos, testes, E2E, performance
    • EvidênciaDesignerAprovar a evidência (prints antes e depois)ClaudePrints, comparativos, registro da evidência
    • EntregaDesignerPedir commit e PRClaudeAbrir a PR no padrão do time e mover o card
    • RevisãoDesignerConduzir a conversa com quem revisa e decidir o que mudaClaudeCorrigir os apontamentos do bot de revisão e aplicar o que for combinado
    Como uma PR anda02

    O fluxo de uma PR

    Dez passos em quatro fases. Escolha um passo na linha do tempo ou use as setas do teclado. Em amarelo, os pontos de parada: o Claude para e espera a minha decisão.

    PrepararDesigner

    Card pequeno

    Título curto (uns 40 caracteres), escopo claro e uma lista do que não mexer. Uma PR por card. Se o escopo crescer no meio, vira outro card.

    Na prática

    Um card que cresceu no meio virou dois: duas PRs menores, revisadas mais rápido.

    PrepararClaude

    Sessão e worktree próprias

    Uma sessão por card, renomeada com o ID e o título, para cada uma ser achada na barra lateral. E uma worktree nova, saindo da branch principal atualizada. Nunca uma branch velha: ela mostra telas que não existem mais.

    O Claude roda o setup do time: dependências, bibliotecas internas, variáveis de ambiente e banco.

    Exemplo

    DS-14 PR 3: campos do cadastro

    Atenção

    Antes de qualquer print, conferir de onde o ambiente está rodando.

    PrepararDesigner

    Prompt de entrada

    Em vez de explicar a tarefa de cabeça a cada vez, um prompt com o objetivo, a referência visual, o que fica de fora, as regras e os pontos de parada. Com a skill instalada, ele fica curto.

    No material completo

    O gerador de prompt monta o de uma PR e o da orquestradora.

    PrepararDesigner aprova

    O plano Ponto de parada

    Antes de editar qualquer arquivo, o Claude manda o plano: arquivos, componentes que vai usar, o que fica igual e riscos. Eu aprovo ou corrijo. É o passo que mais evita retrabalho.

    O Claude manda algo assim

    “Plano do DS-14: 3 arquivos na tela de Pedidos. Troco o fundo fixo da lista pelo token de superfície e os selos pelo Badge do design system; validação e payload ficam iguais. Risco: o aviso amarelo pode perder contraste no claro, vou conferir nos prints. Posso seguir?”

    ConstruirClaude

    Construção, com regras fixas

    • Design system primeiro. Biblioteca alternativa só quando ele não tem o componente; nunca componente marcado como rascunho.
    • Não reconstruir o que já existe. Com uma tela de referência, o Claude usa o mesmo componente e ajusta só por props e classes.
    • Tokens semânticos, claro e escuro. Nada de cor fixa.
    • Troca visual não muda comportamento. Validação, texto, payload e data-testid ficam iguais.
    • Escada da preguiça. Precisa existir? Já existe no repo? Só então escreve o mínimo.
    • Bug: corrigir a causa. Uma vez, na origem, e não em cada tela.
    Enquanto isso

    Acompanho pelo navegador do app e confiro a tela nos dois temas. Ajuste visual é decisão minha.

    ProvarDesigner aprova

    Evidência Ponto de parada

    • Prints antes e depois, claro e escuro, com estado de erro e desabilitado.
    • E2E da área nas duas branches. Falha que já existe na principal não é culpa da PR.
    • Performance: LCP, CLS e long tasks, medidos em sequência, na mesma janela de tempo.
    • Registro num arquivo de evidência, no card e no corpo da PR.
    Veja

    O esquema do comparativo e o critério de performance.

    ProvarClaude

    Validação e docs

    Validações do time só nos pacotes tocados: lint, tipos, testes, código morto. Se o time exige documentação para mudança visível, ela entra na mesma PR.

    Atenção

    Checagem global e builds grandes com o ambiente no ar sobrecarregam a máquina. O que é pesado roda com o ambiente parado.

    ProvarClaude

    Revisão independente

    Um revisor separado (um subagente ou outra sessão no papel de revisor) olha só o diff, procurando bug. Quando há ajuste depois, roda de novo.

    Sacada

    A segunda rodada costuma pegar efeito colateral criado pela correção da primeira.

    EntregarDesigner pede

    Commit e PR só quando eu peço

    • Stage só dos arquivos do escopo; o diff contra a branch principal não pode ter nada além deles.
    • PR no padrão do time e card movido para “em revisão”, com o link.
    • Pedido de revisão escrito no formato do time, para eu enviar.
    EntregarClaude e designer

    Depois de aberta

    Apontamentos do bot de revisão: o Claude corrige o que é do escopo e responde na thread.

    Comentário de pessoa: a conversa é minha. O Claude traz o contexto técnico de cada ponto quando eu peço e aplica o que for combinado.

    O que aprendi fazendo03

    Aprendizados

    O método acima não nasceu pronto. Cada regra dele veio de algo que deu errado ou que funcionou melhor do que o esperado.

    1. 01

      Antes e depois é o entregável

      Sem o comparativo, um trabalho de correção passa despercebido: quem revisa não vê o que mudou, e quem usa nunca soube do problema. Por isso a evidência é um ponto de parada, e não um anexo.

    2. 02

      O placar fica no código, não em planilha

      Um script conta, a cada merge, quantos usos do componente antigo ainda existem, e uma regra de lint impede usos novos. Sem a trava, cinco arquivos novos com o componente antigo apareceram em quatro dias.

    3. 03

      Medir em sequência, na mesma janela

      Uma rodada de performance feita com horas de intervalo mostrou uma piora de 21% que não existia. Medindo as duas branches uma depois da outra, a diferença sumiu.

    4. 04

      Trocar componente é auditoria

      Os bugs mais sérios estavam em telas que ninguém tinha pedido para olhar. Abrir cada tela para trocar o componente revela o que já estava quebrado em volta.

    5. 05

      A IA executa; o critério de design decide

      A IA reescreveu um conjunto de abas para deixá-las “mais limpas” e quebrou a identidade da plataforma. Isso virou regra: não reconstruir o que já existe, e reusar o componente da tela de referência.

    6. 06

      Revisão independente pega o que o autor não vê

      Uma segunda sessão, olhando só o diff, encontrou um bug que já estava em produção. Desde então, a revisão roda de novo sempre que há ajuste depois dela.

    7. 07

      Medir antes de prometer, uma área por PR

      O número vem antes do compromisso. E cada PR mexe numa área só, para poder voltar atrás sem desfazer o resto.

    8. 08

      Erro corrigido vira memória

      Quando o Claude erra algo que não pode se repetir, a correção vai para a memória do projeto, com o porquê. Com o tempo, o processo mora nas memórias e nos arquivos de regras, e os prompts ficam curtos.

    Prova, não promessa04

    Evidência

    O comparativo é sempre a mesma grade: antes à esquerda, depois à direita; claro em cima, escuro embaixo. Quem revisa encontra a diferença sem ler nada.

    Exemplo: no escuro, a lista ficava com fundo claro fixo e os selos sumiam. Depois, usa o token de superfície; o claro não muda. Se a troca é invisível para quem usa, como uma biblioteca de formulários, o comparativo mostra o estado de erro: as mesmas mensagens, no mesmo lugar.

    Critério de performance

    LCP
    Sem piora acima de 10%
    CLS
    Não sobe
    Long tasks
    Nenhuma nova acima de 50 ms
    Várias PRs ao mesmo tempo05

    A sessão orquestradora

    Cada PR roda na sua sessão e worktree, mas o ambiente local costuma ser um só: portas fixas, um banco. Só uma worktree fica no ar por vez. A orquestradora é a única dona dele e decide quem usa.

    Por que existe

    Trocar o ambiente à mão, PR por PR, não escalou: cada troca dependia de alguém disponível naquela hora, e as PRs ficavam esperando. Com a orquestradora dona do ambiente, a fila anda sozinha.

    Ela faz

    • Sobe, troca e para o ambiente
    • Mantém a fila de quem vai usar
    • Confere a carga da máquina antes de subir
    • Mantém o STATUS.md, o quadro de todas as PRs
    • Avisa as PRs que dependem umas das outras
    • Prepara o card e o prompt da próxima PR

    Ela não faz

    • Não escreve o código das PRs
    • Não decide visual nem produto
    • Não faz commit nem PR pelas outras sessões
    • Não conversa com quem revisa pelas PRs

    Decisões de design, commit e PR continuam vindo direto para mim.

    Organização no app

    • Orquestradora fixada no topo. É a sessão que mais abro.
    • Um grupo por frente, com todas as sessões de PR dentro.
    • Toda sessão com o nome do card, com o número da PR na frente.
    • Sessão entregue sai da frente: concluída e, com o meu ok, arquivada.

    Simulador: a troca do ambiente

    Uma tarde com duas PRs e a orquestradora. Avance passo a passo e leia, embaixo, por que cada coisa acontece.

    Ambiente
    Fila
    STATUS.md

    Cuidados

    • Um ambiente por vez, sempre. Subir um pode derrubar qualquer servidor extra, inclusive o da branch principal usado nos prints de “antes”. Esse sobe depois.
    • Nada pesado com o ambiente no ar. Checagem de tipos global e builds grandes sobrecarregam a máquina.
    • Infraestrutura é uma só. Banco e filas não sobem de dentro de uma worktree: isso pode criar um banco novo e vazio.
    • Duas PRs andando no máximo: uma constrói, outra prova e documenta. Mais que isso só gera fila e conflito.
    • Avisar o time antes de mexer numa área, principalmente quem está mudando as mesmas telas.
    O que já deu errado06

    Armadilhas conhecidas

    Cada uma com o jeito de evitar. A skill avisa o Claude de todas.

    • AconteceuTela com tema inesperado: o ambiente estava rodando de uma branch desatualizadaComo evitarWorktree nova da principal por card; conferir de onde o ambiente roda antes de tirar print.
    • AconteceuWorktree nova com dezenas de erros de “módulo não encontrado”Como evitarRodar o setup (install e build das bibliotecas internas) antes de validar.
    • AconteceuUm arquivo regerado pelo servidor local entrou na PRComo evitarNunca git add -A com o ambiente no ar; stage só do escopo e conferir o diff antes do push.
    • AconteceuChecagem global com o ambiente no ar travou a máquinaComo evitarValidar só os pacotes tocados; o que é pesado roda com o ambiente parado.
    • AconteceuFrontend escrito para um endpoint que o backend ainda não tinha entregadoComo evitarConfirmar no contrato da API ou nos tipos gerados que ele existe antes de começar.
    • AconteceuComponente reescrito do zero fugiu da identidade visualComo evitarReusar o componente da tela de referência e ajustar só por props e classes.
    • AconteceuPerformance medida em horários diferentes deu piora falsa de 21%Como evitarAs duas branches em sequência, na mesma janela de tempo.
    • AconteceuTroca manual do ambiente virou fila de esperaComo evitarA orquestradora assume a troca, com a máquina acordada enquanto há trabalho.
    Para adotar07

    Como começar: dois caminhos

    Comece pelo A. Quando a entrega for maior que uma PR, passe para o B.

    Uma PR, uma pessoa conduzindo a sessão. Não precisa de orquestração, pasta de evidência nem scripts.

    1. Instalar a skill e preencher a configuração do time.
    2. Escolher um card pequeno e visual: um bug de tema escuro numa tela só é perfeito.
    3. Abrir uma sessão nova no app, na pasta do repositório, e colar o prompt de entrada.
    4. Aprovar o plano antes de qualquer edição.
    5. Acompanhar pelo navegador do app, no claro e no escuro.
    6. Aprovar a evidência: prints antes e depois, E2E e revisão independente.
    7. Só então pedir commit e PR.

    A primeira configuração do ambiente local é a parte mais trabalhosa: vale fazer com alguém da engenharia.

    Para levar08

    Material completo

    Grátis · sem cadastro

    Leve o método para o seu time

    A skill faz o Claude seguir o processo sozinho; o guia explica cada passo em texto corrido. Copie, baixe e adapte ao seu time.

    Baixar a skill Baixar o guia

    Ou instale com um comando, no terminal onde roda o Claude Code:

    Depois, preencha a configuração do time no topo do arquivo (o que ficar vazio, o Claude pergunta na primeira vez) e chame pelo nome numa sessão nova: “use o processo-frontend no card DS-14” ou /processo-frontend.

    Ver o conteúdo da skill
    Carregando…

    Opcional: quer aviso quando sair uma versão nova? Só isso, sem newsletter.

    Modelos de prompt

    Preencha e copie. O que falta aparece em amarelo. Os campos ficam salvos só neste navegador.

    Do seu time preencha uma vez
    Branch:
    
                    
                  

    Modelo de evidência

    evidencias-<card>.md
    # Evidência · <ID> <título>
    
    ## Prints
    Antes (principal) à esquerda, depois (branch) à direita; claro em cima, escuro embaixo.
    - <tela>: padrão, erro, desabilitado
    
    ## E2E da área
    - Principal: <x de y> · Branch: <x de y>
    - Pré-existentes (já falham na principal): <teste e motivo>
    
    ## Performance (as duas em sequência, na mesma janela)
    | Tela | LCP antes | LCP depois | Diferença | CLS antes | CLS depois | Long tasks novas |
    |-|-|-|-|-|-|-|
    
    ## Comportamento
    - Validação, textos, payload e data-testid iguais: <como foi conferido>
    
    ## Validações
    - <lint, tipos, testes>: <resultado>
    - Não rodou, e por quê: <...>
    
    ## Revisão independente
    - Rodada 1: <achados e o que mudou>
    - Rodada 2: <se houve ajuste depois>
    Sem jargão09

    Glossário

    Os termos técnicos desta página. No texto, eles aparecem com sublinhado pontilhado: clique para ver.

    Sessão
    Uma conversa do Claude Code com contexto próprio. Cada card ganha a sua.
    Orquestradora
    A sessão que coordena as outras e é a única dona do ambiente local.
    Branch principal
    O ramo principal do código, o que vai para produção. Toda mudança nova sai dele atualizado.
    Branch
    Uma linha paralela do código onde a mudança acontece, até virar PR e entrar na principal.
    Worktree
    Uma segunda pasta do mesmo repositório com outra branch aberta. Permite várias PRs ao mesmo tempo sem uma mexer na outra.
    Design system
    O conjunto de componentes e tokens que o produto usa. É a primeira fonte de qualquer tela.
    Token semântico
    Cor com nome de função (superfície, texto secundário) em vez de um código fixo. Troca sozinha entre claro e escuro.
    E2E
    Teste automatizado que abre o navegador e usa a tela como uma pessoa: clica, digita, salva.
    data-testid
    Etiqueta invisível que os testes usam para achar botões e campos. Não pode mudar numa troca visual.
    LCP
    Quanto tempo o maior elemento da tela leva para aparecer. Mede carregamento.
    CLS
    Quanto o layout “pula” enquanto carrega. Quanto menor, melhor.
    Long task
    Um travamento do navegador acima de 50 ms; a pessoa sente como engasgo ao digitar.
    Payload
    Os dados que a tela envia para a API ao salvar. Tem que sair igual antes e depois.
    Bot de revisão
    Um revisor automático que comenta nas PRs. O Claude corrige o que ele aponta dentro do escopo.