Desfazer com segurança e os checkpoints

Desfazer com o git: a tranquilidade de base

A promessa da máquina do tempo se cumpre na hora de desfazer. Se uma mudança não deu certo, o git permite voltar a um commit anterior e recuperar o projeto como ele estava naquele ponto, descartando o que veio depois. Você pede ao Claude Code algo como desfaça as últimas mudanças e volte ao estado do último commit, e ele opera o git para isso. É uma operação rotineira e segura, desde que você tenha commitado seus pontos bons, o que reforça o hábito de commitar com frequência. Cada commit é uma boia de salvação; quanto mais boias, mais perto está a próxima quando você precisar.

Essa facilidade de desfazer muda a psicologia do trabalho. Quem não tem como voltar atrás fica com medo de mexer, hesita, protege demais o código. Quem sabe que pode desfazer com um comando experimenta com liberdade, tenta abordagens ousadas, deixa o agente arriscar, porque o pior caso é voltar ao último ponto bom. Essa liberdade é um dos maiores presentes que o git dá a quem programa, e ela se potencializa com o Claude Code: você pode pedir mudanças grandes e ousadas ao agente sem ansiedade, sabendo que, se não gostar, desfazer é trivial. Errar barato é a base de aprender rápido e construir com coragem.

Os checkpoints do Claude Code

Além do git, o próprio Claude Code oferece uma rede de segurança dentro da sessão: os checkpoints. Ao longo do trabalho, a ferramenta guarda pontos de retorno, e você pode voltar a um deles para restaurar o estado a um momento anterior. A diferença para o commit do git é sutil e poderosa: o checkpoint pode restaurar não só o código, mas também a própria conversa, desfazendo os passos recentes do agente como se você rebobinasse a sessão. Se o Claude Code seguiu um caminho que você não gostou nas últimas interações, um checkpoint te leva de volta ao ponto antes daquilo, código e diálogo juntos.

Na prática, isso é acessível por um gesto rápido na ferramenta, um atalho de teclado ou um comando que abre o menu de voltar a um ponto, como você viu de relance no módulo da conversa. É especialmente útil naquelas situações em que a sessão foi por um caminho errado e você prefere recomeçar de um ponto bom a tentar consertar o rumo atual. Em vez de pedir ao agente para desfazer manualmente cada passo, você rebobina de uma vez. Os checkpoints complementam o git: o git protege ao longo do projeto, entre sessões, e os checkpoints protegem dentro da sessão, nos passos recentes. Juntos, cobrem os dois horizontes de tempo.

Um cuidado: os checkpoints são uma comodidade da sessão, não um substituto do git. O git continua sendo a proteção principal e durável do seu projeto, com histórico permanente e compartilhável. Os checkpoints são uma conveniência para desfazer rápido dentro do trabalho atual. A recomendação, portanto, é usar os dois: commitar com frequência para ter a rede do git, e usar os checkpoints para os ajustes finos de rumo dentro da sessão. Confiar só nos checkpoints e nunca commitar seria abrir mão da proteção mais sólida; usar os dois te dá cobertura total.

Quando errar deixa de ser um problema

Some tudo: git para o projeto, checkpoints para a sessão, revisão para a qualidade. O resultado é um ambiente onde errar deixa de ser um problema e vira parte natural do processo. Você experimenta, o agente arrisca, e se algo não der certo, você volta atrás em segundos, sem drama e sem perda. Isso não é só conforto; muda o que você consegue fazer. Com medo de errar, a gente escolhe sempre o caminho conservador. Sem esse medo, a gente explora, tenta o ousado, aprende com o que não deu certo. O git e os checkpoints são o que transformam o Claude Code de uma ferramenta que você usa com cautela numa que você usa com coragem.

Com este tema dominado, você tem a rede de segurança completa para usar o Claude Code com liberdade. A última aula do módulo mostra um recurso avançado que essa segurança destrava: rodar várias sessões do Claude Code ao mesmo tempo, em paralelo, cada uma numa tarefa diferente, sem que elas se atrapalhem, graças a um recurso do git chamado worktree. É onde o controle de versão deixa de ser só proteção e vira um multiplicador de produtividade, permitindo que você toque várias frentes de trabalho de uma vez com o agente.