Neste artigo
- O que aconteceu, em termos técnicos
- O fluxo seguro do dia a dia
- Quando o rebase é inevitável: force-with-lease
- Recuperando o que parecia perdido: reflog
- O exercício que os comentários recomendam: quebrar de propósito
- O que exatamente o force push faz de errado num branch compartilhado?
- O git push --force-with-lease resolve o problema?
- Como recuperar commits perdidos depois de um rebase ou reset?
- Quando o rebase é seguro de usar?
- Como treinar Git sem medo de errar no trabalho?
Nono dia no emprego novo. Um dev recém-contratado precisava sincronizar o trabalho dele com o de um colega, lembrou pela metade de um tutorial que viu antes de entrar na empresa, e concluiu que o force push era a solução para tudo. Executou o comando contra o branch do colega, que já estava no repositório remoto, e sobrescreveu o histórico alheio com o próprio. O código sobreviveu por um detalhe banal: o colega tinha cópia local do próprio trabalho, e a recuperação foi possível. Ninguém gritou, segundo o relato, mas a reunião diária seguinte ficou silenciosa. A thread que contou o caso no r/learnprogramming somou 92 comentários, com uma mistura de consolo, aula de Git e o conselho que estrutura este guia: aprender o fluxo seguro antes de precisar dele.
O caso é didático porque é comum. Quem entra no primeiro emprego chega dominando o tripé de estudo, adicionar arquivos, criar commit e enviar ao remoto, e descobre que o trabalho em equipe tem uma camada inteira que o tutorial básico não cobre: o que fazer quando o remoto avançou, quando o histórico local divergiu e quando a branch do colega está no meio do caminho. Este guia percorre essa camada na ordem do desastre: o fluxo seguro do dia a dia, a alternativa controlada quando o rebase for inevitável, a regra que evita o acidente e a recuperação quando ele já aconteceu.
O que aconteceu, em termos técnicos
O force push substitui o histórico do branch remoto pelo histórico local de quem envia, sem negociar. Num repositório pessoal, isso é chato no pior caso. Num branch compartilhado, onde o colega baseou o trabalho dele nos commits que estavam no remoto, o force push apaga do remoto exatamente os commits que os outros usam como base, e o próximo comando do colega produz erros estranhos, commits que somem e conflitos sem explicação. É por isso que a cópia local do colega foi a salvação do nono dia: o Git nunca apaga nada que alguém tenha recebido, e o repositório local do colega ainda tinha o histórico completo. O remoto, esse, tinha sido reescrito.
A lição técnica do relato é a fronteira entre as duas zonas do Git. Na zona local, quase tudo é recuperável e experimentável, porque o histórico é seu e ninguém depende dele. Na zona remota compartilhada, o histórico é infraestrutura coletiva, e reescrever infraestrutura coletiva sem combinado é o que transforma um comando de correção em incidente com reunião silenciosa no dia seguinte.
O fluxo seguro do dia a dia
O fluxo que evita o desastre cabe numa sequência curta, e ela não inclui força em momento nenhum. Antes de começar a trabalhar, traga o estado do remoto. Durante o trabalho, faça commits pequenos e frequentes, com mensagens que descrevem a intenção, porque commit pequeno é o que se desfaz sem dor. Antes de enviar, traga de novo o remoto e resolva eventuais conflitos na sua máquina, em vez de enviar por cima. Só então envie:
git status
git pull --rebase
git add arquivos-alterados
git commit -m "descrição clara da mudança"
git push
Repare no que esse fluxo resolve sem alarde. O comando que traz o remoto antes do envio é o que impede a maior parte das recusas de envio, e a recusa de envio é o momento em que iniciantes são apresentados ao force push por tutoriais apressados. Se o envio for recusado, a resposta não é força, é sincronizar e reenviar. O guia completo de Git para desenvolvedores em 2026 da casa detalha cada comando dessa sequência com variações de equipe.
Quando o rebase é inevitável: force-with-lease
Existem casos legítimos de reescrita de histórico: o commit de correção que reescreve o commit local antes de enviar, o rebase que organiza a fila de commits locais antes da revisão, o pull com rebase que mantém o histórico linear. Nesses casos, o histórico reescrito é o seu, e ainda local ou pouco compartilhado. Quando o envio desse histórico reescrito for necessário, o comando seguro não é o force puro, é a versão com verificação de arrendamento, que só executa se o remoto estiver exatamente no estado que você conhece:
git push --force-with-lease
A diferença é sutil e decisiva. O force puro escreve por cima de qualquer coisa que esteja no remoto, inclusive um push do colega que aconteceu dois minutos antes. O force-with-lease verifica se o remoto ainda está onde você o viu pela última vez; se alguém enviou algo nesse intervalo, o comando recusa, e a recusa é o sistema te poupando do nono dia. Não é à toa que os comentários do caso apontam o force-with-lease como o mínimo que todo fluxo com rebase deveria adotar.
⚠️ Atenção: a regra que resume o episódio inteiro é uma só: branch compartilhada não reescreve histórico. Rebase, correção de commit e force, mesmo com verificação de arrendamento, são ferramentas para branches suas e locais. Em branch de equipe, a correção sempre avança o histórico, com commit novo que desfaz o anterior, nunca com reescrita.
Recuperando o que parecia perdido: reflog
O dia em que o Git salva a reputação é o dia em que alguém aprende o registro de referências, o reflog. Toda movimentação do indicador de posição local, commits, trocas de branch, rebase, redefinição, fica registrada no diário do repositório local, mesmo para movimentos que não aparecem em nenhum branch. O histórico que parece perdido depois de um rebase ou de uma redefinição dura continua listado lá, identificado pelo identificador do commit:
git reflog
git branch recuperado a1b2c3d
A primeira linha lista o diário, com um rótulo curto para cada movimento e o estado em que o repositório estava. A segunda cria um branch apontando para o estado escolhido, e o trabalho volta a ser visível e recuperável. O diário é local e expira com o tempo, então ele não substitui backup: ele é a rede de proteção dos últimos dias de trabalho na sua máquina. No caso do nono dia, foi a cópia local do colega que cumpriu esse papel, e o caminho formal de recuperação teria sido exatamente este, localizar o estado anterior no diário e reconstruir o branch a partir dele. O passo a passo de publicar um projeto no GitHub cobre a parte de envio que antecede esses cenários, e o quiz de Git e GitHub da casa testa se os conceitos assentaram antes de você precisar deles numa emergência.
💡 Dica: antes de qualquer rebase ou redefinição com risco, crie um branch de segurança apontando para o estado atual. Custa um comando, não vai ao remoto e transforma qualquer recuperação em troca de branch. O hábito vale mais que qualquer comando decorado.
O exercício que os comentários recomendam: quebrar de propósito
O conselho mais repetido nos comentários do caso é o mais barato de executar: quebrar um repositório local de propósito e se salvar. O roteiro cabe num intervalo de estudo. Crie um repositório de treino, faça uma meia dúzia de commits em duas branches, reescreva uma delas com rebase, force o envio para um remoto de teste, apague uma branch por engano e recupere tudo pelo diário de referências. Repita até a recuperação virar rotina, porque é esse o objetivo: o treino em cenário seguro é o que vira calma no incidente.
O contraste final do nono dia é o melhor resumo do guia. O autor do relato sabia adicionar, criar commit e enviar, e era exatamente esse o tamanho do problema: o arsenal terminava onde a equipe começava. O caminho dali para a confiança com rebase não passa por decorar mais comandos, passa por entender as duas zonas do Git, quem depende do histórico que você está prestes a mexer e o que o diário local é capaz de trazer de volta. Quem internaliza isso executa os comandos arriscados com respeito, usa a versão com verificação quando a reescrita for inevitável e nunca deixa de ter um branch de segurança. A opção de curso gratuito de Git e GitHub da FGV é o próximo passo estruturado para quem quer sair do tripé básico com certificado no fim.
Perguntas frequentes
O que exatamente o force push faz de errado num branch compartilhado?
Ele substitui o histórico do remoto pelo seu histórico local, sem negociar, apagando do remoto os commits que os colegas usam como base. Quem baseou trabalho no estado antigo passa a ver erros e commits sumidos, e a recuperação depende de cópia local ou do diário de referências de alguém.
O git push --force-with-lease resolve o problema?
Ele resolve a parte mecânica: só executa se o remoto ainda estiver no estado que você conhece, recusando o envio quando alguém enviou algo no intervalo. Ele não autoriza reescrever branch de equipe: a regra de não reescrever histórico compartilhado continua valendo, com ou sem verificação.
Como recuperar commits perdidos depois de um rebase ou reset?
Pelo diário de referências local: liste os movimentos recentes, encontre o estado anterior pelo identificador do commit e recrie um branch apontando para ele. O diário é local e expira com o tempo, então a recuperação é para os últimos dias da sua máquina, não para histórico remoto reescrito sem cópia.
Quando o rebase é seguro de usar?
Em branches suas e ainda não compartilhadas: organizar commits locais antes da revisão e sincronizar seu trabalho com o remoto via pull com rebase são usos legítimos e comuns. Em branch de equipe, a correção avança o histórico com commit novo de desfazer, nunca reescreve.
Como treinar Git sem medo de errar no trabalho?
Com um repositório de treino e o exercício de quebrar de propósito: reescrever histórico, forçar envio para remoto de teste, apagar branch e recuperar tudo pelo diário de referências até a recuperação virar rotina. No trabalho, some a isso o hábito do branch de segurança antes de qualquer operação de risco.