1> ## Documentation Index

2> Fetch the complete documentation index at: https://code.claude.com/docs/llms.txt

3> Use this file to discover all available pages before exploring further.

4 

5# Fluxos de trabalho comuns

6 

7> Guias passo a passo para explorar bases de código, corrigir bugs, refatorar, testar e outras tarefas cotidianas com Claude Code.

8 

9Esta página aborda fluxos de trabalho práticos para desenvolvimento cotidiano: explorar código desconhecido, depuração, refatoração, escrita de testes, criação de PRs e gerenciamento de sessões. Cada seção inclui exemplos de prompts que você pode adaptar aos seus próprios projetos. Para padrões e dicas de nível superior, consulte [Melhores práticas](/pt/best-practices).

10 

11## Entender novas bases de código

12 

13### Obter uma visão geral rápida da base de código

14 

15Suponha que você acabou de ingressar em um novo projeto e precisa entender sua estrutura rapidamente.

16 

17<Steps>

18 <Step title="Navegue até o diretório raiz do projeto">

19 ```bash theme={null}

20 cd /path/to/project

21 ```

22 </Step>

23 

24 <Step title="Inicie Claude Code">

25 ```bash theme={null}

26 claude

27 ```

28 </Step>

29 

30 <Step title="Peça uma visão geral de alto nível">

31 ```text theme={null}

32 give me an overview of this codebase

33 ```

34 </Step>

35 

36 <Step title="Aprofunde-se em componentes específicos">

37 ```text theme={null}

38 explain the main architecture patterns used here

39 ```

40 

41 ```text theme={null}

42 what are the key data models?

43 ```

44 

45 ```text theme={null}

46 how is authentication handled?

47 ```

48 </Step>

49</Steps>

50 

51<Tip>

52 Dicas:

53 

54 * Comece com perguntas amplas e depois estreite para áreas específicas

55 * Pergunte sobre convenções de codificação e padrões usados no projeto

56 * Solicite um glossário de termos específicos do projeto

57</Tip>

58 

59### Encontrar código relevante

60 

61Suponha que você precise localizar código relacionado a um recurso ou funcionalidade específica.

62 

63<Steps>

64 <Step title="Peça ao Claude para encontrar arquivos relevantes">

65 ```text theme={null}

66 find the files that handle user authentication

67 ```

68 </Step>

69 

70 <Step title="Obtenha contexto sobre como os componentes interagem">

71 ```text theme={null}

72 how do these authentication files work together?

73 ```

74 </Step>

75 

76 <Step title="Entenda o fluxo de execução">

77 ```text theme={null}

78 trace the login process from front-end to database

79 ```

80 </Step>

81</Steps>

82 

83<Tip>

84 Dicas:

85 

86 * Seja específico sobre o que você está procurando

87 * Use linguagem de domínio do projeto

88 * Instale um [plugin de inteligência de código](/pt/discover-plugins#code-intelligence) para sua linguagem para dar ao Claude navegação precisa de "ir para definição" e "encontrar referências"

89</Tip>

90 

91***

92 

93## Corrigir bugs com eficiência

94 

95Suponha que você tenha encontrado uma mensagem de erro e precise encontrar e corrigir sua origem.

96 

97<Steps>

98 <Step title="Compartilhe o erro com Claude">

99 ```text theme={null}

100 I'm seeing an error when I run npm test

101 ```

102 </Step>

103 

104 <Step title="Peça recomendações de correção">

105 ```text theme={null}

106 suggest a few ways to fix the @ts-ignore in user.ts

107 ```

108 </Step>

109 

110 <Step title="Aplique a correção">

111 ```text theme={null}

112 update user.ts to add the null check you suggested

113 ```

114 </Step>

115</Steps>

116 

117<Tip>

118 Dicas:

119 

120 * Diga ao Claude o comando para reproduzir o problema e obtenha um rastreamento de pilha

121 * Mencione quaisquer etapas para reproduzir o erro

122 * Deixe Claude saber se o erro é intermitente ou consistente

123</Tip>

124 

125***

126 

127## Refatorar código

128 

129Suponha que você precise atualizar código antigo para usar padrões e práticas modernas.

130 

131<Steps>

132 <Step title="Identifique código legado para refatoração">

133 ```text theme={null}

134 find deprecated API usage in our codebase

135 ```

136 </Step>

137 

138 <Step title="Obtenha recomendações de refatoração">

139 ```text theme={null}

140 suggest how to refactor utils.js to use modern JavaScript features

141 ```

142 </Step>

143 

144 <Step title="Aplique as alterações com segurança">

145 ```text theme={null}

146 refactor utils.js to use ES2024 features while maintaining the same behavior

147 ```

148 </Step>

149 

150 <Step title="Verifique a refatoração">

151 ```text theme={null}

152 run tests for the refactored code

153 ```

154 </Step>

155</Steps>

156 

157<Tip>

158 Dicas:

159 

160 * Peça ao Claude para explicar os benefícios da abordagem moderna

161 * Solicite que as alterações mantenham compatibilidade com versões anteriores quando necessário

162 * Faça refatoração em pequenos incrementos testáveis

163</Tip>

164 

165***

166 

167## Usar subagents especializados

168 

169Suponha que você queira usar subagents de IA especializados para lidar com tarefas específicas de forma mais eficaz.

170 

171<Steps>

172 <Step title="Visualize subagents disponíveis">

173 ```text theme={null}

174 /agents

175 ```

176 

177 Isso mostra todos os subagents disponíveis e permite que você crie novos.

178 </Step>

179 

180 <Step title="Use subagents automaticamente">

181 Claude Code delega automaticamente tarefas apropriadas para subagents especializados:

182 

183 ```text theme={null}

184 review my recent code changes for security issues

185 ```

186 

187 ```text theme={null}

188 run all tests and fix any failures

189 ```

190 </Step>

191 

192 <Step title="Solicite explicitamente subagents específicos">

193 ```text theme={null}

194 use the code-reviewer subagent to check the auth module

195 ```

196 

197 ```text theme={null}

198 have the debugger subagent investigate why users can't log in

199 ```

200 </Step>

201 

202 <Step title="Crie subagents personalizados para seu fluxo de trabalho">

203 ```text theme={null}

204 /agents

205 ```

206 

207 Em seguida, selecione "Create New subagent" e siga os prompts para definir:

208 

209 * Um identificador único que descreve o propósito do subagent (por exemplo, `code-reviewer`, `api-designer`).

210 * Quando Claude deve usar este agente

211 * Quais ferramentas ele pode acessar

212 * Um prompt do sistema descrevendo o papel e comportamento do agente

213 </Step>

214</Steps>

215 

216<Tip>

217 Dicas:

218 

219 * Crie subagents específicos do projeto em `.claude/agents/` para compartilhamento em equipe

220 * Use campos `description` descritivos para permitir delegação automática

221 * Limite o acesso a ferramentas ao que cada subagent realmente precisa

222 * Consulte a [documentação de subagents](/pt/sub-agents) para exemplos detalhados

223</Tip>

224 

225***

226 

227## Usar Plan Mode para análise segura de código

228 

229Plan Mode instrui Claude a criar um plano analisando a base de código com operações somente leitura, perfeito para explorar bases de código, planejar alterações complexas ou revisar código com segurança. Em Plan Mode, Claude usa [`AskUserQuestion`](/pt/tools-reference) para reunir requisitos e esclarecer seus objetivos antes de propor um plano.

230 

231### Quando usar Plan Mode

232 

233* **Implementação multi-etapa**: Quando seu recurso requer fazer edições em muitos arquivos

234* **Exploração de código**: Quando você quer pesquisar a base de código completamente antes de alterar qualquer coisa

235* **Desenvolvimento interativo**: Quando você quer iterar na direção com Claude

236 

237### Como usar Plan Mode

238 

239**Ative Plan Mode durante uma sessão**

240 

241Você pode mudar para Plan Mode durante uma sessão usando **Shift+Tab** para percorrer os modos de permissão.

242 

243Se você estiver em Normal Mode, **Shift+Tab** primeiro muda para Auto-Accept Mode, indicado por `⏵⏵ accept edits on` na parte inferior do terminal. Um **Shift+Tab** subsequente mudará para Plan Mode, indicado por `⏸ plan mode on`.

244 

245**Inicie uma nova sessão em Plan Mode**

246 

247Para iniciar uma nova sessão em Plan Mode, use a flag `--permission-mode plan`:

248 

249```bash theme={null}

250claude --permission-mode plan

251```

252 

253**Execute consultas "headless" em Plan Mode**

254 

255Você também pode executar uma consulta em Plan Mode diretamente com `-p` (ou seja, em ["modo headless"](/pt/headless)):

256 

257```bash theme={null}

258claude --permission-mode plan -p "Analyze the authentication system and suggest improvements"

259```

260 

261### Exemplo: Planejando uma refatoração complexa

262 

263```bash theme={null}

264claude --permission-mode plan

265```

266 

267```text theme={null}

268I need to refactor our authentication system to use OAuth2. Create a detailed migration plan.

269```

270 

271Claude analisa a implementação atual e cria um plano abrangente. Refine com acompanhamentos:

272 

273```text theme={null}

274What about backward compatibility?

275```

276 

277```text theme={null}

278How should we handle database migration?

279```

280 

281<Tip>Pressione `Ctrl+G` para abrir o plano em seu editor de texto padrão, onde você pode editá-lo diretamente antes de Claude prosseguir.</Tip>

282 

283Quando você aceita um plano, Claude automaticamente nomeia a sessão a partir do conteúdo do plano. O nome aparece na barra de prompt e no seletor de sessão. Se você já definiu um nome com `--name` ou `/rename`, aceitar um plano não o sobrescreverá.

284 

285### Configure Plan Mode como padrão

286 

287```json theme={null}

288// .claude/settings.json

289{

290 "permissions": {

291 "defaultMode": "plan"

292 }

293}

294```

295 

296Consulte a [documentação de configurações](/pt/settings#available-settings) para mais opções de configuração.

297 

298***

299 

300## Trabalhar com testes

301 

302Suponha que você precise adicionar testes para código não coberto.

303 

304<Steps>

305 <Step title="Identifique código não testado">

306 ```text theme={null}

307 find functions in NotificationsService.swift that are not covered by tests

308 ```

309 </Step>

310 

311 <Step title="Gere scaffolding de teste">

312 ```text theme={null}

313 add tests for the notification service

314 ```

315 </Step>

316 

317 <Step title="Adicione casos de teste significativos">

318 ```text theme={null}

319 add test cases for edge conditions in the notification service

320 ```

321 </Step>

322 

323 <Step title="Execute e verifique os testes">

324 ```text theme={null}

325 run the new tests and fix any failures

326 ```

327 </Step>

328</Steps>

329 

330Claude pode gerar testes que seguem os padrões e convenções existentes do seu projeto. Ao solicitar testes, seja específico sobre qual comportamento você quer verificar. Claude examina seus arquivos de teste existentes para corresponder ao estilo, frameworks e padrões de asserção já em uso.

331 

332Para cobertura abrangente, peça ao Claude para identificar casos extremos que você pode ter perdido. Claude pode analisar seus caminhos de código e sugerir testes para condições de erro, valores de limite e entradas inesperadas que são fáceis de negligenciar.

333 

334***

335 

336## Criar pull requests

337 

338Você pode criar pull requests pedindo ao Claude diretamente ("create a pr for my changes"), ou guiar Claude através disso passo a passo:

339 

340<Steps>

341 <Step title="Resuma suas alterações">

342 ```text theme={null}

343 summarize the changes I've made to the authentication module

344 ```

345 </Step>

346 

347 <Step title="Gere uma pull request">

348 ```text theme={null}

349 create a pr

350 ```

351 </Step>

352 

353 <Step title="Revise e refine">

354 ```text theme={null}

355 enhance the PR description with more context about the security improvements

356 ```

357 </Step>

358</Steps>

359 

360Quando você cria uma PR usando `gh pr create`, a sessão é automaticamente vinculada a essa PR. Você pode retomá-la mais tarde com `claude --from-pr <number>`.

361 

362<Tip>

363 Revise a PR gerada por Claude antes de enviar e peça ao Claude para destacar riscos ou considerações potenciais.

364</Tip>

365 

366## Lidar com documentação

367 

368Suponha que você precise adicionar ou atualizar documentação para seu código.

369 

370<Steps>

371 <Step title="Identifique código não documentado">

372 ```text theme={null}

373 find functions without proper JSDoc comments in the auth module

374 ```

375 </Step>

376 

377 <Step title="Gere documentação">

378 ```text theme={null}

379 add JSDoc comments to the undocumented functions in auth.js

380 ```

381 </Step>

382 

383 <Step title="Revise e melhore">

384 ```text theme={null}

385 improve the generated documentation with more context and examples

386 ```

387 </Step>

388 

389 <Step title="Verifique a documentação">

390 ```text theme={null}

391 check if the documentation follows our project standards

392 ```

393 </Step>

394</Steps>

395 

396<Tip>

397 Dicas:

398 

399 * Especifique o estilo de documentação que você deseja (JSDoc, docstrings, etc.)

400 * Peça por exemplos na documentação

401 * Solicite documentação para APIs públicas, interfaces e lógica complexa

402</Tip>

403 

404***

405 

406## Trabalhar em notas e pastas não-código

407 

408Claude Code funciona em qualquer diretório. Execute-o dentro de um cofre de notas, uma pasta de documentação ou qualquer coleção de arquivos markdown para pesquisar, editar e reorganizar conteúdo da mesma forma que você faria com código.

409 

410O diretório `.claude/` e `CLAUDE.md` ficam ao lado dos diretórios de configuração de outras ferramentas sem conflito. Claude lê arquivos novamente em cada chamada de ferramenta, então vê edições que você faz em outro aplicativo na próxima vez que lê esse arquivo.

411 

412***

413 

414## Trabalhar com imagens

415 

416Suponha que você precise trabalhar com imagens em sua base de código e queira ajuda do Claude para analisar o conteúdo da imagem.

417 

418<Steps>

419 <Step title="Adicione uma imagem à conversa">

420 Você pode usar qualquer um destes métodos:

421 

422 1. Arraste e solte uma imagem na janela do Claude Code

423 2. Copie uma imagem e cole-a no CLI com ctrl+v (Não use cmd+v)

424 3. Forneça um caminho de imagem ao Claude. Por exemplo, "Analyze this image: /path/to/your/image.png"

425 </Step>

426 

427 <Step title="Peça ao Claude para analisar a imagem">

428 ```text theme={null}

429 What does this image show?

430 ```

431 

432 ```text theme={null}

433 Describe the UI elements in this screenshot

434 ```

435 

436 ```text theme={null}

437 Are there any problematic elements in this diagram?

438 ```

439 </Step>

440 

441 <Step title="Use imagens para contexto">

442 ```text theme={null}

443 Here's a screenshot of the error. What's causing it?

444 ```

445 

446 ```text theme={null}

447 This is our current database schema. How should we modify it for the new feature?

448 ```

449 </Step>

450 

451 <Step title="Obtenha sugestões de código do conteúdo visual">

452 ```text theme={null}

453 Generate CSS to match this design mockup

454 ```

455 

456 ```text theme={null}

457 What HTML structure would recreate this component?

458 ```

459 </Step>

460</Steps>

461 

462<Tip>

463 Dicas:

464 

465 * Use imagens quando descrições de texto seriam pouco claras ou complicadas

466 * Inclua capturas de tela de erros, designs de UI ou diagramas para melhor contexto

467 * Você pode trabalhar com múltiplas imagens em uma conversa

468 * A análise de imagem funciona com diagramas, capturas de tela, mockups e muito mais

469 * Quando Claude referencia imagens (por exemplo, `[Image #1]`), `Cmd+Click` (Mac) ou `Ctrl+Click` (Windows/Linux) o link para abrir a imagem em seu visualizador padrão

470</Tip>

471 

472***

473 

474## Referenciar arquivos e diretórios

475 

476Use @ para incluir rapidamente arquivos ou diretórios sem esperar que Claude os leia.

477 

478<Steps>

479 <Step title="Referencie um único arquivo">

480 ```text theme={null}

481 Explain the logic in @src/utils/auth.js

482 ```

483 

484 Isso inclui o conteúdo completo do arquivo na conversa.

485 </Step>

486 

487 <Step title="Referencie um diretório">

488 ```text theme={null}

489 What's the structure of @src/components?

490 ```

491 

492 Isso fornece uma listagem de diretório com informações de arquivo.

493 </Step>

494 

495 <Step title="Referencie recursos MCP">

496 ```text theme={null}

497 Show me the data from @github:repos/owner/repo/issues

498 ```

499 

500 Isso busca dados de servidores MCP conectados usando o formato @server:resource. Consulte [recursos MCP](/pt/mcp#use-mcp-resources) para detalhes.

501 </Step>

502</Steps>

503 

504<Tip>

505 Dicas:

506 

507 * Os caminhos de arquivo podem ser relativos ou absolutos

508 * Referências de arquivo @ adicionam `CLAUDE.md` no diretório do arquivo e diretórios pai ao contexto

509 * Referências de diretório mostram listagens de arquivo, não conteúdos

510 * Você pode referenciar múltiplos arquivos em uma única mensagem (por exemplo, "@file1.js and @file2.js")

511</Tip>

512 

513***

514 

515## Usar pensamento estendido (thinking mode)

516 

517[Pensamento estendido](https://platform.claude.com/docs/en/build-with-claude/extended-thinking) é ativado por padrão, dando ao Claude espaço para raciocinar através de problemas complexos passo a passo antes de responder. Este raciocínio é visível em modo verboso, que você pode ativar com `Ctrl+O`. Durante pensamento estendido, o spinner mostra dicas de progresso inline como "still thinking" e "almost done thinking" para indicar que Claude está trabalhando ativamente.

518 

519Além disso, [modelos que suportam esforço](/pt/model-config#adjust-effort-level) usam raciocínio adaptativo: em vez de um orçamento de token de pensamento fixo, o modelo decide dinamicamente se e quanto pensar com base em sua configuração de nível de esforço e na tarefa em questão. Raciocínio adaptativo permite que Claude responda mais rápido a prompts rotineiros e reserve pensamento mais profundo para etapas que se beneficiam dele.

520 

521Pensamento estendido é particularmente valioso para decisões arquitetônicas complexas, bugs desafiadores, planejamento de implementação multi-etapa e avaliação de compensações entre diferentes abordagens.

522 

523<Note>

524 Frases como "think", "think hard" e "think more" são interpretadas como instruções de prompt regulares e não alocam tokens de pensamento.

525</Note>

526 

527### Configurar thinking mode

528 

529Pensamento é ativado por padrão, mas você pode ajustá-lo ou desativá-lo.

530 

531| Escopo | Como configurar | Detalhes |

532| ------------------------------ | ------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |

533| **Nível de esforço** | Execute `/effort`, ajuste em `/model`, ou defina [`CLAUDE_CODE_EFFORT_LEVEL`](/pt/env-vars) | Controle a profundidade de pensamento em [modelos suportados](/pt/model-config#adjust-effort-level) |

534| **Palavra-chave `ultrathink`** | Inclua "ultrathink" em qualquer lugar em seu prompt | Adiciona uma instrução em contexto dizendo ao modelo para raciocinar mais nesse turno. Não altera o nível de esforço em si; consulte [Ajustar nível de esforço](/pt/model-config#adjust-effort-level) para isso |

535| **Atalho de alternância** | Pressione `Option+T` (macOS) ou `Alt+T` (Windows/Linux) | Alterne pensamento ligado/desligado para a sessão atual (todos os modelos). Pode exigir [configuração de terminal](/pt/terminal-config) para ativar atalhos de tecla Option |

536| **Padrão global** | Use `/config` para alternar thinking mode | Define seu padrão em todos os projetos (todos os modelos).<br />Salvo como `alwaysThinkingEnabled` em `~/.claude/settings.json` |

537| **Limitar orçamento de token** | Defina a variável de ambiente [`MAX_THINKING_TOKENS`](/pt/env-vars) | Limite o orçamento de pensamento para um número específico de tokens. Em modelos com raciocínio adaptativo, apenas `0` se aplica a menos que raciocínio adaptativo seja desativado. Exemplo: `export MAX_THINKING_TOKENS=10000` |

538 

539Para visualizar o processo de pensamento do Claude, pressione `Ctrl+O` para alternar o modo verboso e veja o raciocínio interno exibido como texto em itálico cinzento.

540 

541### Como funciona o pensamento estendido

542 

543Pensamento estendido controla quanto raciocínio interno Claude realiza antes de responder. Mais pensamento fornece mais espaço para explorar soluções, analisar casos extremos e autocorrigir erros.

544 

545Em [modelos que suportam esforço](/pt/model-config#adjust-effort-level), pensamento usa raciocínio adaptativo: o modelo aloca dinamicamente tokens de pensamento com base no nível de esforço que você seleciona. Esta é a forma recomendada de ajustar a compensação entre velocidade e profundidade de raciocínio. Se você quiser que Claude pense mais ou menos do que seu nível de esforço produziria de outra forma, você também pode dizer isso diretamente em seu prompt ou em `CLAUDE.md`.

546 

547Com modelos mais antigos, pensamento usa um orçamento fixo de tokens extraído de sua alocação de saída. O orçamento varia por modelo; consulte [`MAX_THINKING_TOKENS`](/pt/env-vars) para limites por modelo. Você pode limitar o orçamento com essa variável de ambiente, ou desativar pensamento inteiramente via `/config` ou a alternância `Option+T`/`Alt+T`.

548 

549Em modelos com raciocínio adaptativo, `MAX_THINKING_TOKENS` só se aplica quando definido como `0` para desativar pensamento, ou quando `CLAUDE_CODE_DISABLE_ADAPTIVE_THINKING=1` reverte o modelo para o orçamento fixo. `CLAUDE_CODE_DISABLE_ADAPTIVE_THINKING` se aplica apenas a Opus 4.6 e Sonnet 4.6. Opus 4.7 sempre usa raciocínio adaptativo e não suporta um orçamento de pensamento fixo. Consulte [variáveis de ambiente](/pt/env-vars).

550 

551<Warning>

552 Você é cobrado por todos os tokens de pensamento usados, mesmo quando resumos de pensamento são redatados. Em modo interativo, pensamento aparece como um stub recolhido por padrão. Defina `showThinkingSummaries: true` em `settings.json` para mostrar resumos completos.

553</Warning>

554 

555***

556 

557## Retomar conversas anteriores

558 

559Ao iniciar Claude Code, você pode retomar uma sessão anterior:

560 

561* `claude --continue` continua a conversa mais recente no diretório atual

562* `claude --resume` abre um seletor de conversa ou retoma por nome

563* `claude --from-pr 123` retoma sessões vinculadas a uma pull request específica

564 

565De dentro de uma sessão ativa, use `/resume` para mudar para uma conversa diferente.

566 

567Quando a sessão selecionada é antiga e grande o suficiente que relê-la consumiria uma parte substancial de seus limites de uso, `--resume`, `--continue` e `/resume` oferecem retomar a partir de um resumo em vez de carregar a transcrição completa. Este prompt não está disponível no Amazon Bedrock, Google Cloud Vertex AI ou Microsoft Foundry.

568 

569As sessões são armazenadas por diretório de projeto. Por padrão, o seletor `/resume` mostra sessões interativas do worktree atual, com atalhos de teclado para ampliar a lista para outros worktrees ou projetos, pesquisar, visualizar e renomear. Consulte [Use o seletor de sessão](#use-the-session-picker) abaixo para a referência completa de atalhos.

570 

571Quando você seleciona uma sessão de outro worktree do mesmo repositório, Claude Code a retoma diretamente sem exigir que você mude de diretórios primeiro. Selecionar uma sessão de um projeto não relacionado copia um comando `cd` e resume para sua área de transferência em vez disso.

572 

573Retomar por nome resolve em todo o repositório atual e seus worktrees. Tanto `claude --resume <name>` quanto `/resume <name>` procuram uma correspondência exata e a retomam diretamente, mesmo que a sessão viva em um worktree diferente.

574 

575Quando o nome é ambíguo, `claude --resume <name>` abre o seletor com o nome pré-preenchido como um termo de pesquisa. `/resume <name>` de dentro de uma sessão relata um erro em vez disso, então execute `/resume` sem argumento para abrir o seletor e escolher.

576 

577Sessões criadas por `claude -p` ou invocações SDK não aparecem no seletor, mas você ainda pode retomar uma passando seu ID de sessão diretamente para `claude --resume <session-id>`.

578 

579### Nomeie suas sessões

580 

581Dê nomes descritivos às sessões para encontrá-las mais tarde. Esta é uma prática recomendada ao trabalhar em múltiplas tarefas ou recursos.

582 

583<Steps>

584 <Step title="Nomeie a sessão">

585 Nomeie uma sessão na inicialização com `-n`:

586 

587 ```bash theme={null}

588 claude -n auth-refactor

589 ```

590 

591 Ou use `/rename` durante uma sessão, que também mostra o nome na barra de prompt:

592 

593 ```text theme={null}

594 /rename auth-refactor

595 ```

596 

597 Você também pode renomear qualquer sessão do seletor: execute `/resume`, navegue até uma sessão e pressione `Ctrl+R`.

598 </Step>

599 

600 <Step title="Retome por nome mais tarde">

601 Da linha de comando:

602 

603 ```bash theme={null}

604 claude --resume auth-refactor

605 ```

606 

607 Ou de dentro de uma sessão ativa:

608 

609 ```text theme={null}

610 /resume auth-refactor

611 ```

612 </Step>

613</Steps>

614 

615### Use o seletor de sessão

616 

617O comando `/resume` (ou `claude --resume` sem argumentos) abre um seletor de sessão interativo com estes recursos:

618 

619**Atalhos de teclado no seletor:**

620 

621| Atalho | Ação |

622| :-------------------------------------------------------- | :---------------------------------------------------------------------------------------------------------------------------------------------------------------------- |

623| `↑` / `↓` | Navegue entre sessões |

624| `→` / `←` | Expanda ou recolha sessões agrupadas |

625| `Enter` | Selecione e retome a sessão destacada |

626| `Space` | Visualize o conteúdo da sessão. `Ctrl+V` também funciona em terminais que não o capturam como colar |

627| `Ctrl+R` | Renomeie a sessão destacada |

628| `/` ou qualquer caractere imprimível diferente de `Space` | Entre no modo de pesquisa e filtre sessões |

629| `Ctrl+A` | Mostre sessões de todos os projetos nesta máquina. Pressione novamente para restaurar o repositório atual |

630| `Ctrl+W` | Mostre sessões de todos os worktrees do repositório atual. Pressione novamente para restaurar o worktree atual. Mostrado apenas em repositórios com múltiplos worktrees |

631| `Ctrl+B` | Filtre para sessões do seu branch git atual. Pressione novamente para mostrar sessões de todos os branches |

632| `Esc` | Saia do seletor ou modo de pesquisa |

633 

634**Organização de sessão:**

635 

636O seletor exibe sessões com metadados úteis:

637 

638* Nome da sessão se definido, caso contrário o resumo da conversa ou primeiro prompt do usuário

639* Tempo decorrido desde a última atividade

640* Contagem de mensagens

641* Branch git (se aplicável)

642* Caminho do projeto, mostrado após ampliar para todos os projetos com `Ctrl+A`

643 

644Sessões bifurcadas (criadas com `/branch`, `/rewind`, ou `--fork-session`) são agrupadas sob sua sessão raiz, facilitando encontrar conversas relacionadas.

645 

646<Tip>

647 Dicas:

648 

649 * **Nomeie sessões cedo**: Use `/rename` ao iniciar trabalho em uma tarefa distinta: é muito mais fácil encontrar "payment-integration" do que "explain this function" mais tarde

650 * Use `--continue` para acesso rápido à sua conversa mais recente no diretório atual

651 * Use `--resume session-name` quando você sabe qual sessão precisa

652 * Use `--resume` (sem um nome) quando você precisa navegar e selecionar

653 * Para scripts, use `claude --continue --print "prompt"` para retomar em modo não interativo

654 * Pressione `Space` no seletor para visualizar uma sessão antes de retomá-la

655 * A conversa retomada começa com o mesmo modelo e configuração do original

656 

657 Como funciona:

658 

659 1. **Armazenamento de Conversa**: Todas as conversas são automaticamente salvas localmente com seu histórico de mensagens completo

660 2. **Desserialização de Mensagem**: Ao retomar, todo o histórico de mensagens é restaurado para manter contexto

661 3. **Estado de Ferramenta**: O uso de ferramenta e resultados da conversa anterior são preservados

662 4. **Restauração de Contexto**: A conversa retoma com todo o contexto anterior intacto

663</Tip>

664 

665***

666 

667## Executar sessões paralelas de Claude Code com Git worktrees

668 

669Ao trabalhar em múltiplas tarefas ao mesmo tempo, você precisa que cada sessão do Claude tenha sua própria cópia da base de código para que as alterações não colidam. Git worktrees resolvem isso criando diretórios de trabalho separados que cada um tem seus próprios arquivos e branch, enquanto compartilham o mesmo histórico de repositório e conexões remotas. Isso significa que você pode ter Claude trabalhando em um recurso em um worktree enquanto corrige um bug em outro, sem que nenhuma sessão interfira com a outra.

670 

671Use a flag `--worktree` (`-w`) para criar um worktree isolado e iniciar Claude nele. O valor que você passa se torna o nome do diretório worktree e nome do branch:

672 

673```bash theme={null}

674# Inicie Claude em um worktree nomeado "feature-auth"

675# Cria .claude/worktrees/feature-auth/ com um novo branch

676claude --worktree feature-auth

677 

678# Inicie outra sessão em um worktree separado

679claude --worktree bugfix-123

680```

681 

682Se você omitir o nome, Claude gera um automaticamente:

683 

684```bash theme={null}

685# Auto-gera um nome como "bright-running-fox"

686claude --worktree

687```

688 

689Worktrees são criados em `<repo>/.claude/worktrees/<name>` e fazem branch a partir do branch remoto padrão, que é para onde `origin/HEAD` aponta. O branch worktree é nomeado `worktree-<name>`.

690 

691O branch base não é configurável através de um flag ou configuração do Claude Code. `origin/HEAD` é uma referência armazenada em seu diretório `.git` local que Git definiu uma vez quando você clonou. Se o branch padrão do repositório mudar mais tarde no GitHub ou GitLab, seu `origin/HEAD` local continua apontando para o antigo, e worktrees farão branch a partir daí. Para ressincronizar sua referência local com o que o remoto atualmente considera seu padrão:

692 

693```bash theme={null}

694git remote set-head origin -a

695```

696 

697Este é um comando Git padrão que apenas atualiza seu diretório `.git` local. Nada no servidor remoto muda. Se você quiser que worktrees façam base em um branch específico em vez do padrão do remoto, defina-o explicitamente com `git remote set-head origin your-branch-name`.

698 

699Para controle total sobre como worktrees são criados, incluindo escolher uma base diferente por invocação, configure um [hook WorktreeCreate](/pt/hooks#worktreecreate). O hook substitui a lógica padrão `git worktree` do Claude Code inteiramente, para que você possa buscar e fazer branch a partir de qualquer ref que você precise.

700 

701Você também pode pedir ao Claude para "work in a worktree" ou "start a worktree" durante uma sessão, e ele criará um automaticamente.

702 

703### Worktrees de subagent

704 

705Subagents também podem usar isolamento de worktree para trabalhar em paralelo sem conflitos. Peça ao Claude para "use worktrees for your agents" ou configure em um [subagent personalizado](/pt/sub-agents#supported-frontmatter-fields) adicionando `isolation: worktree` ao frontmatter do agente. Cada subagent obtém seu próprio worktree que é automaticamente limpo quando o subagent termina sem alterações.

706 

707### Limpeza de worktree

708 

709Quando você sai de uma sessão de worktree, Claude lida com limpeza com base em se você fez alterações:

710 

711* **Sem alterações**: o worktree e seu branch são removidos automaticamente

712* **Alterações ou commits existem**: Claude o solicita para manter ou remover o worktree. Manter preserva o diretório e branch para que você possa retornar mais tarde. Remover exclui o diretório worktree e seu branch, descartando todas as alterações não confirmadas e commits

713 

714Worktrees de subagent órfãos por uma falha ou uma execução paralela interrompida são removidos automaticamente na inicialização uma vez que são mais antigos do que sua configuração [`cleanupPeriodDays`](/pt/settings#available-settings), desde que não tenham alterações não confirmadas, nenhum arquivo não rastreado e nenhum commit não enviado. Worktrees que você cria com `--worktree` nunca são removidos por esta varredura.

715 

716Para limpar worktrees fora de uma sessão do Claude, use [gerenciamento manual de worktree](#manage-worktrees-manually).

717 

718<Tip>

719 Adicione `.claude/worktrees/` ao seu `.gitignore` para evitar que o conteúdo do worktree apareça como arquivos não rastreados em seu repositório principal.

720</Tip>

721 

722### Copiar arquivos gitignored para worktrees

723 

724Git worktrees são checkouts frescos, então eles não incluem arquivos não rastreados como `.env` ou `.env.local` do seu repositório principal. Para copiar automaticamente esses arquivos quando Claude cria um worktree, adicione um arquivo `.worktreeinclude` à raiz do seu projeto.

725 

726O arquivo usa sintaxe `.gitignore` para listar quais arquivos copiar. Apenas arquivos que correspondem a um padrão e também são gitignored são copiados, então arquivos rastreados nunca são duplicados.

727 

728```text .worktreeinclude theme={null}

729.env

730.env.local

731config/secrets.json

732```

733 

734Isso se aplica a worktrees criados com `--worktree`, worktrees de subagent e sessões paralelas no [aplicativo desktop](/pt/desktop#work-in-parallel-with-sessions).

735 

736### Gerenciar worktrees manualmente

737 

738Para mais controle sobre localização de worktree e configuração de branch, crie worktrees com Git diretamente. Isso é útil quando você precisa fazer checkout de um branch existente específico ou colocar o worktree fora do repositório.

739 

740```bash theme={null}

741# Crie um worktree com um novo branch

742git worktree add ../project-feature-a -b feature-a

743 

744# Crie um worktree com um branch existente

745git worktree add ../project-bugfix bugfix-123

746 

747# Inicie Claude no worktree

748cd ../project-feature-a && claude

749 

750# Limpe quando terminar

751git worktree list

752git worktree remove ../project-feature-a

753```

754 

755Saiba mais na [documentação oficial de Git worktree](https://git-scm.com/docs/git-worktree).

756 

757<Tip>

758 Lembre-se de inicializar seu ambiente de desenvolvimento em cada novo worktree de acordo com seu projeto. Dependendo de sua stack, isso pode incluir executar instalação de dependência (`npm install`, `yarn`), configurar ambientes virtuais ou seguir o processo de configuração padrão do seu projeto.

759</Tip>

760 

761### Controle de versão não-git

762 

763Isolamento de worktree funciona com git por padrão. Para outros sistemas de controle de versão como SVN, Perforce ou Mercurial, configure [hooks WorktreeCreate e WorktreeRemove](/pt/hooks#worktreecreate) para fornecer lógica personalizada de criação e limpeza de worktree. Quando configurados, esses hooks substituem o comportamento padrão do git quando você usa `--worktree`, então [`.worktreeinclude`](#copy-gitignored-files-to-worktrees) não é processado. Copie quaisquer arquivos de configuração local dentro de seu script de hook em vez disso.

764 

765Para coordenação automatizada de sessões paralelas com tarefas compartilhadas e mensagens, consulte [equipes de agentes](/pt/agent-teams).

766 

767***

768 

769## Obtenha notificações quando Claude precisa de sua atenção

770 

771Quando você inicia uma tarefa de longa duração e muda para outra janela, você pode configurar notificações de desktop para saber quando Claude termina ou precisa de sua entrada. Isso usa o evento de hook `Notification` [hook event](/pt/hooks-guide#get-notified-when-claude-needs-input), que dispara sempre que Claude está esperando permissão, ocioso e pronto para um novo prompt, ou completando autenticação.

772 

773<Steps>

774 <Step title="Adicione o hook às suas configurações">

775 Abra `~/.claude/settings.json` e adicione um hook `Notification` que chama o comando de notificação nativa da sua plataforma:

776 

777 <Tabs>

778 <Tab title="macOS">

779 ```json theme={null}

780 {

781 "hooks": {

782 "Notification": [

783 {

784 "matcher": "",

785 "hooks": [

786 {

787 "type": "command",

788 "command": "osascript -e 'display notification \"Claude Code needs your attention\" with title \"Claude Code\"'"

789 }

790 ]

791 }

792 ]

793 }

794 }

795 ```

796 </Tab>

797 

798 <Tab title="Linux">

799 ```json theme={null}

800 {

801 "hooks": {

802 "Notification": [

803 {

804 "matcher": "",

805 "hooks": [

806 {

807 "type": "command",

808 "command": "notify-send 'Claude Code' 'Claude Code needs your attention'"

809 }

810 ]

811 }

812 ]

813 }

814 }

815 ```

816 </Tab>

817 

818 <Tab title="Windows">

819 ```json theme={null}

820 {

821 "hooks": {

822 "Notification": [

823 {

824 "matcher": "",

825 "hooks": [

826 {

827 "type": "command",

828 "command": "powershell.exe -Command \"[System.Reflection.Assembly]::LoadWithPartialName('System.Windows.Forms'); [System.Windows.Forms.MessageBox]::Show('Claude Code needs your attention', 'Claude Code')\""

829 }

830 ]

831 }

832 ]

833 }

834 }

835 ```

836 </Tab>

837 </Tabs>

838 

839 Se seu arquivo de configurações já tiver uma chave `hooks`, mescle a entrada `Notification` nela em vez de sobrescrever. Você também pode pedir ao Claude para escrever o hook para você descrevendo o que você quer no CLI.

840 </Step>

841 

842 <Step title="Opcionalmente, estreite o matcher">

843 Por padrão, o hook dispara em todos os tipos de notificação. Para disparar apenas para eventos específicos, defina o campo `matcher` para um destes valores:

844 

845 | Matcher | Dispara quando |

846 | :--------------------- | :------------------------------------------------------------ |

847 | `permission_prompt` | Claude precisa que você aprove um uso de ferramenta |

848 | `idle_prompt` | Claude terminou e está esperando seu próximo prompt |

849 | `auth_success` | Autenticação completa |

850 | `elicitation_dialog` | Um servidor MCP abre um formulário de elicitação |

851 | `elicitation_complete` | Um formulário de elicitação MCP é enviado ou descartado |

852 | `elicitation_response` | Uma resposta de elicitação MCP é enviada de volta ao servidor |

853 </Step>

854 

855 <Step title="Verifique o hook">

856 Digite `/hooks` e selecione `Notification` para confirmar que o hook aparece. Selecioná-lo mostra o comando que será executado. Para testá-lo de ponta a ponta, peça ao Claude para executar um comando que requer permissão e mude para longe do terminal, ou peça ao Claude para disparar uma notificação diretamente.

857 </Step>

858</Steps>

859 

860Para o esquema de evento completo e tipos de notificação, consulte a [referência de Notificação](/pt/hooks#notification).

861 

862***

863 

864## Usar Claude como um utilitário estilo unix

865 

866### Adicione Claude ao seu processo de verificação

867 

868Suponha que você queira usar Claude Code como um linter ou revisor de código.

869 

870**Adicione Claude ao seu script de compilação:**

871 

872```json theme={null}

873// package.json

874{

875 ...

876 "scripts": {

877 ...

878 "lint:claude": "claude -p 'you are a linter. please look at the changes vs. main and report any issues related to typos. report the filename and line number on one line, and a description of the issue on the second line. do not return any other text.'"

879 }

880}

881```

882 

883<Tip>

884 Dicas:

885 

886 * Use Claude para revisão de código automatizada em seu pipeline CI/CD

887 * Personalize o prompt para verificar problemas específicos relevantes ao seu projeto

888 * Considere criar múltiplos scripts para diferentes tipos de verificação

889</Tip>

890 

891### Pipe in, pipe out

892 

893Suponha que você queira canalizar dados para Claude e obter dados de volta em um formato estruturado.

894 

895**Canalize dados através do Claude:**

896 

897```bash theme={null}

898cat build-error.txt | claude -p 'concisely explain the root cause of this build error' > output.txt

899```

900 

901<Tip>

902 Dicas:

903 

904 * Use pipes para integrar Claude em scripts shell existentes

905 * Combine com outras ferramentas Unix para fluxos de trabalho poderosos

906 * Considere usar `--output-format` para saída estruturada

907</Tip>

908 

909### Controlar formato de saída

910 

911Suponha que você precise da saída do Claude em um formato específico, especialmente ao integrar Claude Code em scripts ou outras ferramentas.

912 

913<Steps>

914 <Step title="Use formato de texto (padrão)">

915 ```bash theme={null}

916 cat data.txt | claude -p 'summarize this data' --output-format text > summary.txt

917 ```

918 

919 Isso produz apenas a resposta de texto simples do Claude (comportamento padrão).

920 </Step>

921 

922 <Step title="Use formato JSON">

923 ```bash theme={null}

924 cat code.py | claude -p 'analyze this code for bugs' --output-format json > analysis.json

925 ```

926 

927 Isso produz um array JSON de mensagens com metadados incluindo custo e duração.

928 </Step>

929 

930 <Step title="Use formato JSON de streaming">

931 ```bash theme={null}

932 cat log.txt | claude -p 'parse this log file for errors' --output-format stream-json

933 ```

934 

935 Isso produz uma série de objetos JSON em tempo real conforme Claude processa a solicitação. Cada mensagem é um objeto JSON válido, mas a saída inteira não é JSON válido se concatenado.

936 </Step>

937</Steps>

938 

939<Tip>

940 Dicas:

941 

942 * Use `--output-format text` para integrações simples onde você apenas precisa da resposta do Claude

943 * Use `--output-format json` quando você precisa do log de conversa completo

944 * Use `--output-format stream-json` para saída em tempo real de cada turno de conversa

945</Tip>

946 

947***

948 

949## Executar Claude em um cronograma

950 

951Suponha que você queira que Claude lide com uma tarefa automaticamente em uma base recorrente, como revisar PRs abertas todas as manhãs, auditar dependências semanalmente ou verificar falhas de CI durante a noite.

952 

953Escolha uma opção de agendamento com base em onde você quer que a tarefa seja executada:

954 

955| Opção | Onde é executado | Melhor para |

956| :---------------------------------------------------------- | :--------------------------------------- | :----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |

957| [Rotinas](/pt/routines) | Infraestrutura gerenciada pela Anthropic | Tarefas que devem ser executadas mesmo quando seu computador está desligado. Também podem ser acionadas por chamadas de API ou eventos do GitHub além de um cronograma. Configure em [claude.ai/code/routines](https://claude.ai/code/routines). |

958| [Tarefas agendadas no desktop](/pt/desktop-scheduled-tasks) | Sua máquina, via aplicativo desktop | Tarefas que precisam de acesso direto a arquivos locais, ferramentas ou alterações não confirmadas. |

959| [GitHub Actions](/pt/github-actions) | Seu pipeline de CI | Tarefas vinculadas a eventos de repositório como PRs abertos, ou cronogramas cron que devem viver junto com sua configuração de fluxo de trabalho. |

960| [`/loop`](/pt/scheduled-tasks) | A sessão CLI atual | Polling rápido enquanto uma sessão está aberta. As tarefas são canceladas quando você inicia uma nova conversa; `--resume` e `--continue` restauram as não expiradas. |

961 

962<Tip>

963 Ao escrever prompts para tarefas agendadas, seja explícito sobre o que o sucesso parece e o que fazer com os resultados. A tarefa é executada autonomamente, então não pode fazer perguntas de esclarecimento. Por exemplo: "Review open PRs labeled `needs-review`, leave inline comments on any issues, and post a summary in the `#eng-reviews` Slack channel."

964</Tip>

965 

966***

967 

968## Pergunte ao Claude sobre suas capacidades

969 

970Claude tem acesso integrado à sua documentação e pode responder perguntas sobre seus próprios recursos e limitações.

971 

972### Perguntas de exemplo

973 

974```text theme={null}

975can Claude Code create pull requests?

976```

977 

978```text theme={null}

979how does Claude Code handle permissions?

980```

981 

982```text theme={null}

983what skills are available?

984```

985 

986```text theme={null}

987how do I use MCP with Claude Code?

988```

989 

990```text theme={null}

991how do I configure Claude Code for Amazon Bedrock?

992```

993 

994```text theme={null}

995what are the limitations of Claude Code?

996```

997 

998<Note>

999 Claude fornece respostas baseadas em documentação para essas perguntas. Para demonstrações práticas, execute `/powerup` para lições interativas com demos animadas, ou consulte as seções de fluxo de trabalho específicas acima.

1000</Note>

1001 

1002<Tip>

1003 Dicas:

1004 

1005 * Claude sempre tem acesso à documentação mais recente do Claude Code, independentemente da versão que você está usando

1006 * Faça perguntas específicas para obter respostas detalhadas

1007 * Claude pode explicar recursos complexos como integração MCP, configurações empresariais e fluxos de trabalho avançados

1008</Tip>

1009 

1010***

1011 

1012## Próximos passos

1013 

1014<CardGroup cols={2}>

1015 <Card title="Melhores práticas" icon="lightbulb" href="/pt/best-practices">

1016 Padrões para aproveitar ao máximo Claude Code

1017 </Card>

1018 

1019 <Card title="Como Claude Code funciona" icon="gear" href="/pt/how-claude-code-works">

1020 Entenda o loop agentic e gerenciamento de contexto

1021 </Card>

1022 

1023 <Card title="Estender Claude Code" icon="puzzle-piece" href="/pt/features-overview">

1024 Adicione skills, hooks, MCP, subagents e plugins

1025 </Card>

1026 

1027 <Card title="Implementação de referência" icon="code" href="https://github.com/anthropics/claude-code/tree/main/.devcontainer">

1028 Clone a implementação de referência do contêiner de desenvolvimento

1029 </Card>

1030</CardGroup>