Como parei de me perder diante de uma tarefa grande

Antes, quando eu precisava fazer uma tela grande do app ou uma integração desconhecida, eu travava. Abria o editor, olhava para o arquivo vazio e não sabia por onde começar. Daí havia dois cenários. Ou um código caótico que depois dá vergonha de reler, ou duas horas no YouTube com a desculpa de que "preciso entender isso". Hoje eu trabalho de outro jeito. A mudança era simples, mas demorei para chegar nela.
Sintomas
Se você se reconhece aqui, o caso é familiar:
- Você abre o arquivo, escreve a primeira linha, apaga
- Cinco ou seis idas ao Google em cinco minutos
- Depois de uma hora codando, a sensação de "nada está certo, vou começar de novo"
- Por dentro, a vontade é que alguém diga exatamente o que fazer
- Cada pequena decisão trava o ritmo. Onde colocar o arquivo, como nomear a variável, usar ou não uma biblioteca
Não é preguiça. É sobrecarga cognitiva. A cabeça tenta manter em foco ao mesmo tempo o objetivo, a arquitetura, a sintaxe, os nomes, os casos extremos. Cada um desses itens consome recursos e, quando tudo vem junto, o cérebro simplesmente desiste.
A citação que me pegou
Ilya Krasinsky disse uma vez: "Não podemos nos dar ao luxo de lançamentos longos, eles custam infinitamente caro". Na época eu estava trabalhando no meu primeiro produto, e essa frase acertou em cheio.
Lançamentos longos não são só lentos. Quando passo duas semanas numa única tarefa, perco o gás que tinha nos primeiros dois dias. Decisões que no começo pareciam óbvias no fim geram dúvida. O contexto se dilui, e você gasta um quarto do dia de trabalho só para voltar ao ponto em que parou ontem.
Daí nasceu minha regra pessoal. Se o fundador sabe colocar a mão na massa, testar uma hipótese custa a ele muito menos. Não porque ele não gaste com um desenvolvedor. Mas porque entre "tive a ideia" e "vi a reação do usuário" passam dias, não meses.
Para colocar a mão na massa com rapidez, é preciso parar de travar. É aí que entra a decomposição.
O método
Parece banal, por isso eu ignorei por muito tempo.
Antes de abrir o editor, abro uma nota e escrevo os passos.
Não um plano no Notion com tags e estimativas. Não um ticket no Jira. Só uma lista com marcadores no primeiro lugar que aparecer. O objetivo é tirar da cabeça aquilo que o cérebro tenta segurar em paralelo com a escrita do código.
Escrevo os passos até o ponto em que eles ficam óbvios demais. Esse é o critério de parada. Se o próximo passo soa como "chamar a função X com tais parâmetros", não precisa detalhar mais. Daí em diante começa o trabalho no código.
Enquanto escrevo os passos, acontece o principal. As incógnitas aparecem. Me pego pensando "como exatamente esse servidor devolve os dados?", "será que precisa de animação aqui?", "e se o usuário estiver sem internet?". Cada uma dessas perguntas vira um item separado ou uma tarefa do tipo "confirmar com o cliente, procurar na documentação".
Depois de 15-30 minutos de decomposição, entendo a tarefa muito melhor. E chego ao código já com um primeiro passo concreto, e não com a pergunta "por onde começar".
Exemplo de um projeto real
Vou mostrar com uma tarefa do projeto do cliente No Sugar Challenge. Era preciso fazer um sistema de onboarding personalizado com pontuação. Ou seja, o usuário passa por quatro grupos de perguntas, os parâmetros pessoais são calculados a partir das respostas e, depois, o app monta tarefas diárias para ele.
No começo, eu teria aberto um novo arquivo OnboardingViewModel.swift e começado a escrever a classe. E travado na segunda linha.
Em vez disso, abri a nota e escrevi:
- Descrever a estrutura: um grupo de perguntas, um conjunto de
Question, cada pergunta com tipo de resposta e peso - Decidir como armazenar a resposta intermediária. Na memória da ViewModel ou no Core Data
- Os parâmetros do usuário que calculamos a partir das respostas: necessidade calórica, rotina típica, nível de motivação. Onde essas fórmulas estão descritas?
- Pontuação. Cada resposta tem um peso, no fim do grupo somamos e vinculamos ao parâmetro
- Bloqueadores dinâmicos. Algumas respostas devem bloquear as perguntas seguintes (exemplo: "sem alergias", pulamos o bloco sobre alérgenos)
- Saída do onboarding. Para onde vamos, o que salvamos
- Persistência. O que fica no Firestore (event-driven, ver a arquitetura do projeto), o que fica local
- Testes. Quais edge cases importam: pular uma resposta, resposta de exceção, voltar ao passo anterior
Quando terminei de escrever, três coisas ficaram claras:
- A estrutura
Questioné melhor como enumeração (enum) com associated values por tipo de resposta - Não sei as fórmulas de pontuação: essa é uma pergunta para o cliente, não é meu papel inventá-las
- Os bloqueadores dinâmicos são uma tarefa separada, com lógica independente, e é melhor isolá-los em um serviço separado
Depois disso, fiz duas coisas. Enviei a pergunta sobre as fórmulas ao cliente e sentei para escrever código. As primeiras duas horas voaram com a estrutura de Question e Answer mais um roteamento simples entre as perguntas. No fim do primeiro dia, eu tinha um onboarding funcionando com dados de teste estáticos. Sem bloqueadores, sem pontuação, mas um esqueleto funcionando.
Se eu tivesse começado "como sempre", teria passado as primeiras duas horas só pensando, depois feito uma classe com respostas em forma de dicionário de strings e então partido para refatorar. E, no fim do dia, teria metade do que tenho agora.
Quando a decomposição não é necessária
Às vezes a decomposição atrapalha. Se a tarefa é um ajuste simples de estilos, uma alteração de textos, a troca de uma imagem, sente e faça. Detalhar passos como «encontrar o arquivo, abrir, alterar, salvar» é burocracia.
Para mim, a fronteira é mais ou menos esta. Se eu tenho uma imagem mental exata do resultado e sei qual é a primeira ação, faço na hora. Se falta pelo menos um desses dois pontos, abro a nota.
A decomposição também funciona mal em tarefas de pesquisa. Quando estou entendendo uma tecnologia nova, por exemplo o PassKit para Apple Wallet pela primeira vez, não consigo montar nenhum plano: não sei o suficiente para escrevê-lo. Nesses casos, trabalho na ordem inversa. Fuço o código, entendo um detalhe, entendo o segundo, e só depois sento e escrevo o plano «agora sei o suficiente para fazer de verdade».
Sobre a estimativa de tempo
O mesmo método serve para estimar prazos para o cliente. Sem decomposição, eu digo «três dias» e quase sempre é mentira. Com decomposição, olho para minha lista de 8 a 15 itens, estimo cada um em horas, somo, multiplico por 1,5 (porque esqueci alguma coisa) e chego a uma estimativa honesta.
Faz dois anos que mantenho uma planilha de horas trabalhadas, e com base nela posso dizer: tarefas para as quais fiz a decomposição com antecedência costumam terminar dentro da estimativa ou mais rápido. Tarefas sem decomposição se esticam, em média, duas a três vezes.
O que aproveitar daqui
Se você às vezes trava diante de uma tarefa, experimente algo simples:
- Feche o editor de código. Abra uma nota de texto.
- Escreva o objetivo em uma linha: o que deve existir no final.
- Liste de 8 a 15 passos até o momento em que o próximo passo seja «abrir o arquivo e escrever X».
- Durante a escrita, marque perguntas e incógnitas como itens separados.
- Quando a lista estiver pronta, envie as perguntas a quem puder responder (cliente, tech lead, documentação). Não fique travado nelas: comece pelos itens independentes.
- Abra o editor e trabalhe seguindo a lista.
Depois de cinco tarefas feitas com esse processo, você para de travar. Depois de vinte, aprende a estimar prazos com mais honestidade do que 80% dos desenvolvedores que «estimam de olho».
E o principal: isso não é sobre produtividade. É sobre poder trabalhar tranquilo, sem a sensação de estar afundando no desconhecido.
O que vem a seguir
Precisa montar um produto sem lançamentos demorados e sem caos no código? Faça uma estimativa de prazo ou fale com a gente, vamos analisar sua tarefa antes que ela vire um sprint de três meses.

