Glossário do Curso de Claude Code

Todos os termos do curso em um só lugar, com definições simples. Use a busca para achar rápido.

Agente de IA: Um programa de inteligência artificial que não apenas responde, mas AGE: usa ferramentas para ler arquivos, executar comandos e cumprir uma tarefa em vários passos, em vez de só devolver um texto na tela.
Ajuste fino: A camada de configuração que afina detalhes do comportamento do Claude Code, além dos ajustes principais. Envolve opções menos visíveis, muitas via variáveis de ambiente, para quem quer levar a personalização ao máximo.
Alucinação: Quando um modelo de IA gera algo que parece correto e confiante, mas não é verdadeiro: um comando que não existe, uma função inventada ou um fato errado. Reconhecer que isso acontece e o primeiro passo para revisar bem.
Antes e depois: A distinção entre eventos que disparam ANTES de uma ação, permitindo até bloqueá-la, e eventos que disparam DEPOIS, permitindo reagir ao que aconteceu. Antes serve para prevenir; depois, para responder.
Aplicativo de desktop: Um programa do Claude Code com interface gráfica, janelas e botões, instalado no computador como qualquer aplicativo comum. Dá acesso ao mesmo agente sem exigir o terminal nem um editor de código, num formato familiar a qualquer usuário.
Aprender fazendo: O princípio de que a prática consolida o aprendizado mais que a teoria sozinha. Construir um projeto real com o Claude Code fixa o que você estudou de um jeito que nenhuma leitura ou vídeo consegue, porque você vive cada conceito na prática.
Aprovação: O momento em que o Claude Code mostra a ação que pretende executar (editar um arquivo, rodar um comando) e espera você autorizar ou recusar. E a trava de segurança que mantem você no controle.
Aprovar o plano: O ato de autorizar a execução do plano proposto no plan mode. Ao aprovar, você escolhe em qual modo o agente vai executar (revisando cada edição, aceitando edições ou de forma mais automática), e só então ele começa a mexer no código.
Argumento: Um dado que você passa ao chamar um comando personalizado, logo depois do nome, para o comando se adaptar. Por exemplo, dizer qual arquivo revisar ou qual tema resumir. O comando usa esse dado no lugar de um espaço reservado.
Arquivo da skill: O arquivo que define uma skill, guardado numa pasta com o nome da skill. Tem um cabeçalho com a descrição (e outros ajustes) e um corpo em texto com as instruções que o agente segue quando a skill é usada.
Arquivo de apoio: Um arquivo extra dentro da pasta de uma skill, além do principal, que o agente pode usar quando a skill roda: um modelo para preencher, um exemplo de formato, uma referência detalhada ou um script. Enriquece a skill sem inchar o arquivo principal.
Arquivo de configuração: O arquivo onde ficam os ajustes do Claude Code, como permissões, hooks, modelo padrão e estilo de resposta. Reúne num só lugar as opções que personalizam a ferramenta. Pode existir em escopos diferentes, do pessoal ao do time.
Arquivo de subagente: Um arquivo de texto, em formato Markdown, que define um subagente. Fica na pasta de agentes do projeto ou da sua área pessoal. Tem um cabeçalho com nome, descrição, ferramentas e modelo, e um corpo com as instruções que o subagente segue.
Assinatura: Uma forma de acesso ao Claude Code paga por mês (planos Pro, Max, Team ou Enterprise). Você paga um valor fixo e usa a ferramenta dentro dos limites do plano, sem contar cada uso separadamente.
Atrofia de habilidade: A perda gradual de uma capacidade por falta de uso. Delegar tudo à IA sem entender o que ela faz pode atrofiar as suas habilidades, deixando você dependente e incapaz de trabalhar ou julgar sem o agente. Usar para aprender é o antídoto.
Atualização automática: O comportamento das instalações nativas do Claude Code, que baixam e aplicam novas versões sozinhas, em segundo plano, para manter você sempre na versão mais recente sem esforco.
Auditar a memória: Revisar o que o agente guardou na memória automática. Como as notas são arquivos de texto simples, você pode ler, editar ou apagar qualquer uma, mantendo o controle sobre o que o agente lembra.
Automação determinística: Uma automação que acontece sempre, do mesmo jeito, sem depender do julgamento do modelo. Os hooks são determinísticos: quando o evento configurado ocorre, o comando roda, sem exceção. É o oposto de uma sugestão, que o agente pode ou não seguir.
Automação por tempo e por evento: As duas formas de o agente trabalhar sozinho. Por evento, ele reage a algo que acontece, como uma mudança de código. Por tempo, ele roda num horário certo, independentemente de eventos. Cada uma serve a um tipo de tarefa automática.
Barra de status: Uma linha no rodapé do Claude Code que pode exibir informações ao vivo sobre a sessão, como quanto do contexto foi usado, o custo até ali e o estado do repositório git. É personalizável: você escolhe o que mostrar.
Bloquear (deny): A regra que impede uma ferramenta ou comando de rodar, valendo em todos os modos, inclusive nos mais soltos. E a trava mais forte: uma regra de bloquear sempre vence uma de liberar.
Bloqueio por hook: A capacidade de um hook, no evento de antes de uma ferramenta, de impedir que a ação aconteça. O hook inspeciona o que o agente vai fazer e, se for proibido, sinaliza para o Claude Code não executar, de forma garantida.
Branch (ramo): Uma linha de trabalho paralela no git, onde você pode fazer mudanças sem afetar o principal. Se der certo, o branch é juntado ao principal; se não, é descartado sem consequências. Protege o código estável enquanto você experimenta.
Buscar por conteúdo (Grep): Procurar um texto ou padrão DENTRO dos arquivos, por exemplo em quais arquivos aparece a palavra login. Responde a pergunta onde este trecho aparece, lendo o conteúdo. Por baixo, usa uma busca muito rápida (ripgrep).
Buscar por nome (Glob): Encontrar arquivos pelo padrão do nome ou do caminho, por exemplo todos os que terminam em ponto ts. Responde a pergunta onde estão os arquivos assim, sem olhar o conteúdo deles.
Caminho protegido: Um arquivo ou pasta sensível que o Claude Code nunca altera sem a sua aprovação, em todos os modos exceto o sem freios. Inclui a pasta de controle de versão e a própria configuração da ferramenta, guardando o projeto de corrupcao acidental.
Carregamento progressivo: O jeito como a skill é carregada: só a sua descrição fica sempre disponível para o Claude Code, enquanto o conteúdo completo só entra no contexto quando a skill é realmente usada. Isso deixa skills longas custarem quase nada até o momento de uso.
Causa raiz: A origem real de um problema, por trás do sintoma visível. Corrigir só o sintoma resolve na aparência, mas o problema volta; corrigir a causa raiz resolve de verdade. Encontrar a raiz é o objetivo central da depuração sistemática.
Celular: O acesso ao Claude Code pelo aplicativo no telefone, que permite acompanhar o trabalho e agir longe da mesa. Bom para conferir o andamento de uma tarefa, aprovar algo ou dar um comando rápido quando você não está no computador.
Checkpoint: Um ponto de retorno que o Claude Code guarda ao longo da sessão. Diferente do commit do git, o checkpoint pode restaurar tanto o código quanto a própria conversa a um momento anterior, desfazendo os passos recentes do agente.
CI (integração contínua): Um sistema que roda tarefas automáticas a cada mudança de código, como testes e verificações, para pegar problemas cedo. O Claude Code pode participar desse fluxo, agindo automaticamente sobre as mudanças, como um membro a mais do time.
Ciclo agêntico: O padrão de trabalho de um agente de IA: entender o objetivo, planejar, usar uma ferramenta para agir, observar o resultado e repetir os passos até a tarefa estar concluida. Cada volta e decidida conforme o que o agente acabou de observar.
Ciclo de correção: O padrão de agir, observar o erro, ajustar e tentar de novo. O Claude Code repete esse ciclo até resolver ou até precisar da sua ajuda, aprendendo com cada mensagem de erro pelo caminho.
Claude Code: Ferramenta de linha de comando da Anthropic que coloca o modelo Claude para trabalhar como um agente dentro do seu terminal e do seu projeto: le arquivos, escreve e edita código, roda comandos e explica o que faz, sempre sob a sua aprovação.
claude doctor: Um comando de diagnostico do Claude Code que verifica a sua instalação e configuração, aponta problemas e sugere correções. E a primeira parada quando algo parece errado.
CLAUDE.local.md: Um arquivo de memória com as suas preferências pessoais para um projeto específico, que não deve ser compartilhado com o time. Fica na raiz do projeto e entra no gitignore para não ir para o controle de versão.
CLAUDE.md: Um arquivo de texto, em formato Markdown, com instruções permanentes para o Claude Code. Ele é lido no início de toda sessão e carrega o contexto do projeto: comandos, convencoes, arquitetura e regras do tipo sempre faca assim.
Comando: Uma instrução de texto que você digita no terminal e confirma com Enter para o computador executar. Por exemplo, digitar claude e apertar Enter inicia o Claude Code.
Comando personalizado: Um comando criado por você a partir de um arquivo de texto. O nome do arquivo vira o nome do comando, e o conteúdo do arquivo e o que o agente recebe quando você o chama. Serve para automatizar pedidos que você repete.
Commit: Uma foto do seu projeto num momento, salva no histórico do git com uma mensagem que descreve o que mudou. Cada commit é um ponto de retorno seguro para o qual você pode voltar a qualquer momento.
Consciência de contexto: Saber, a qualquer momento, quanto da janela de contexto você já usou. A barra de status pode mostrar isso ao vivo, ajudando você a resumir ou limpar a conversa antes que o contexto encha e a qualidade caia.
Consistência da equipe: Quando todos no time usam o Claude Code de forma alinhada, seguindo os mesmos padrões e práticas. Configurações e skills de projeto garantem essa consistência, para que o trabalho de cada um siga as convenções combinadas.
Console (API): A forma de acesso em que você paga pelo uso, por meio da plataforma de desenvolvedores da Anthropic. Em vez de uma mensalidade fixa, o custo depende de quanto você usa. Útil para automação e uso programatico.
Construção em passos: Fazer o projeto crescer aos poucos, um passo pequeno de cada vez, verificando cada um antes de seguir. É a aplicação prática da decomposição e da verificação que o curso ensinou, e o que torna a construção segura e sem sustos.
Contexto: A informação que o agente considera para trabalhar: o pedido, os arquivos apontados, imagens coladas e o histórico da conversa. Contexto certo acelera; contexto demais polui e atrapalha.
Contexto isolado: A janela de contexto própria de um subagente, separada da conversa principal. O que o subagente lê e produz durante a tarefa fica no contexto dele; a conversa principal recebe apenas o resumo final, sem o ruído do processo.
Continuar (--continue): A opção que reabre a conversa mais recente do diretório atual, com todo o contexto de onde você parou. Útil para retomar o trabalho do dia anterior sem repetir nada.
Continuar crescendo: A prática de seguir evoluindo com o Claude Code depois do curso: usando a ferramenta em projetos reais, explorando os recursos com mais profundidade, acompanhando as novidades e aprendendo com a própria experiência. O curso é o começo, não o fim.
Continuar planejando: A opção de, em vez de aprovar, dar um retorno ao agente para ele refinar o plano. Útil quando o plano está no caminho certo mas ainda incompleto ou com um passo que você quer mudar.
Controle de antemão: A ideia de que, na automação, a segurança se decide antes da execução, na configuração, e não no momento da ação. Como não haverá um humano para aprovar na hora, tudo que o agente pode fazer precisa estar definido de antemão, com limites claros.
Criar arquivo (Write): Criar um arquivo novo com um conteúdo, ou sobrescrever um existente por completo. Usado quando algo precisa nascer do zero, como um novo teste ou um novo módulo.
Critério de sucesso: A forma de saber que a tarefa foi cumprida: um teste que passa, um comportamento que muda, uma saída esperada. Dar um critério ao agente permite que ele confira o próprio trabalho antes de dizer que terminou.
Dado sensível: Uma informação que precisa de proteção: senhas e chaves, dados pessoais de clientes, informações confidenciais do negócio. No uso do Claude Code, esses dados merecem cuidado com o que você envia, o que compartilha e o que automatiza.
Decompor: Quebrar um trabalho grande em passos menores e independentes, cada um mais fácil de entender, executar e revisar. Decompor bem transforma uma tarefa assustadora numa sequência de tarefas simples.
Defesa em profundidade: A prática de ter várias camadas de proteção, para que, se uma falhar, outra pegue. Com o Claude Code, isso significa combinar permissões, revisão humana e hooks: cada uma cobre o que a outra pode deixar passar.
Delegação automática: Quando o Claude Code, sem você pedir, decide acionar um subagente porque a tarefa combina com a descrição dele. É o comportamento que faz os subagentes trabalharem por você no momento certo, sem microgerenciamento.
Depuração: O processo de encontrar e corrigir a causa de um comportamento errado num programa. A depuração sistemática segue um método, reproduzir, isolar, entender, corrigir, confirmar, em vez de tentar mudanças ao acaso na esperança de que uma funcione.
Descrição do subagente: O texto que explica o que o subagente faz e quando usá-lo. É o campo mais importante, porque o Claude Code o lê para decidir quando delegar uma tarefa a esse subagente. Uma boa descrição é clara e específica.
Desenvolvimento guiado por testes: Um método em que você escreve primeiro o teste que define o comportamento certo, e só depois escreve o código que faz esse teste passar. Com o Claude Code, você define o teste e deixa o agente escrever o código, com um alvo claro e uma prova automática de sucesso.
Desfazer (reverter): Voltar o código a um estado anterior, descartando mudanças que não deram certo. Com git, isso é seguro e rotineiro: você volta a um commit anterior e recupera o projeto como estava. É o que torna a experimentação sem medo.
Diferença (diff): A comparação visual entre o antes e o depois de uma mudança no código, mostrando exatamente o que foi alterado. No editor, o Claude Code apresenta as suas mudanças como diferenças, que você revisa e aprova ali mesmo, com clareza.
Diretório de conexões: Um catálogo de servidores MCP revisados para serviços conhecidos, oferecido pela Anthropic. Serve para encontrar conexões confiáveis prontas, sem precisar procurar ou criar servidores do zero.
Editar (Edit): Mudar um trecho específico de um arquivo que já existe, trocando um pedaco por outro, sem reescrever o arquivo inteiro. E a ação mais comum e precisa do agente ao corrigir código.
Editor de código (IDE): O programa onde os desenvolvedores escrevem e organizam o código, como o VS Code ou os editores da JetBrains. O Claude Code pode viver dentro do editor, integrado ao ambiente onde você já trabalha, em vez de num terminal separado.
Entrada do hook: As informações que o Claude Code passa ao hook quando ele roda, em formato de dados estruturados: qual evento, qual ferramenta, o que a ferramenta vai fazer. O comando do hook lê esses dados para decidir como agir.
Escopo: O alcance de uma instrução: para toda a organização, para você em todos os projetos, para um projeto específico ou só para você naquele projeto. Cada nível da memória do Claude Code corresponde a um escopo.
Escopo de projeto: A configuração, os comandos, as skills, os subagentes e as regras guardados no projeto e compartilhados com o time pelo controle de versão. É o mecanismo que espalha boas práticas por toda a equipe, sem cada um configurar do zero.
Escopo do servidor: Onde a configuração de um servidor MCP vale: local (só você, naquele projeto), projeto (o time todo, pelo controle de versão) ou usuário (você, em todos os projetos). A escolha segue a mesma lógica de escopo de outros recursos.
Esforço: O quanto o modelo pensa antes de responder. Mais esforço rende respostas mais cuidadosas em tarefas difíceis, ao custo de mais tempo; menos esforço é mais rápido, bom para o que é simples. Ajustar o esforço afina o equilíbrio entre qualidade e velocidade.
Espaço reservado: Uma marca dentro do texto do comando que é substituida pelo argumento que você passar. Ha um que recebe todos os argumentos de uma vez e outros que pegam um argumento específico pela posição.
Especializar: Dar a um subagente um prompt focado num domínio, como revisão de segurança ou escrita de testes, para que ele se comporte como um especialista naquilo. Instruções focadas costumam render resultados melhores que um pedido genérico.
Estender o agente: Acrescentar ao Claude Code uma habilidade que ele não tinha de forma tão organizada: um procedimento específico, um formato próprio, um checklist seu. A skill é o mecanismo oficial para essa extensão, sem mexer no código da ferramenta.
Estilo de resposta: Um ajuste que muda o tom e o formato com que o Claude Code se comunica, sem mudar o que ele sabe. Um estilo pode fazer o agente explicar mais, colaborar mais ou ir direto ao ponto, conforme o seu objetivo naquele momento.
Estilo explicativo: Um estilo de resposta em que o Claude Code acrescenta explicações educativas ao trabalhar, ajudando você a entender o que está sendo feito e por quê. É ideal para aprender programação enquanto o agente resolve as tarefas.
Evento de hook: Um momento do ciclo de vida do Claude Code em que um hook pode disparar, como o início de uma sessão, o envio de um prompt, ou antes e depois de uma ferramenta ser usada. Cada evento é uma oportunidade de encaixar uma automação.
Excesso de confiança: A tendência de confiar demais na IA porque ela acerta muito e responde com segurança. Leva a aceitar sem revisar e a delegar decisões que não deveriam ser dela. Conhecer os limites da ferramenta é o antídoto.
Fechar o ciclo do passo: Completar um passo com a verificação e o commit: fazer a mudança, conferir que funcionou (rodando o teste ou checando o comportamento) e commitar o estado bom. Fechar cada passo assim cria uma sequência de pontos seguros.
Ferramenta: Uma ação concreta que o agente pode executar, como ler um arquivo, editar código, rodar um comando no terminal ou buscar um texto no projeto. O modelo escolhe quais ferramentas usar e em que ordem para cumprir o pedido.
Ferramenta (tool): Uma ação concreta que o Claude Code pode executar, com um nome exato, como Read para ler, Edit para editar, Bash para rodar comandos. O agente escolhe quais usar; você as menciona ao configurar permissões.
Ferramenta de leitura: Ferramenta que apenas olha o projeto sem mudar nada, como ler um arquivo ou buscar um texto. Por não alterar o código, dentro da pasta de trabalho ela não costuma pedir a sua aprovação.
Ferramenta MCP: Uma ação que um servidor MCP permite ao Claude Code executar num sistema externo, como consultar um banco, criar uma tarefa num rastreador ou enviar uma mensagem. É como as ferramentas internas do agente, só que atuando fora do projeto.
Filtro (matcher): A parte da configuração de um hook que diz para quais casos ele dispara dentro de um evento, como só para a ferramenta de rodar comandos, ou só para edições de arquivo. Sem filtro, o hook vale para todos os casos daquele evento.
Finalizar: Dar o projeto por concluído com responsabilidade: revisado, testado e assumido como seu. Finalizar não é só o código parar de mudar; é você conferir que está bom e assumir o resultado, aplicando a revisão humana no fecho.
Fluxo de tarefa: A sequência que uma tarefa percorre do início ao fim: pensar sobre o problema, planejar a abordagem, executar em passos e revisar o resultado. Um bom fluxo torna o trabalho previsível e seguro.
Fluxo de trabalho: A rotina que você adota ao usar o Claude Code: qual modo começar, quando afrouxar, quando apertar o freio e quando revisar. Um bom fluxo equilibra agilidade e segurança sem depender de decidir tudo do zero a cada vez.
Fluxo de trabalho com MCP: Uma tarefa que o Claude Code executa atravessando vários sistemas conectados por MCP num único pedido, como ler uma tarefa de um rastreador, consultar dados num banco e criar uma proposta, sem você fazer a ponte manual entre as ferramentas.
Fundação do projeto: A base sobre a qual o projeto é construído: o contexto que o agente tem (a memória), a rede de segurança (o git) e o plano da construção. Uma fundação sólida evita retrabalho e sustos ao longo do trabalho.
Gestão de contexto: A prática de manter a janela de contexto enxuta e focada em trabalhos longos, resumindo ou limpando a conversa na hora certa. Contexto bem gerido mantém as respostas afiadas e evita a queda de qualidade quando a janela enche.
Gestão de custo: Acompanhar e controlar o gasto do uso do Claude Code, escolhendo o modelo certo para cada tarefa, mantendo o contexto enxuto e evitando desperdício. Vale mais para quem usa com muita frequência, onde a soma das economias faz diferença.
Git: Um sistema de controle de versão: um programa que guarda o histórico de todas as versões do seu código, permitindo comparar, voltar atrás e trabalhar sem medo de perder ou quebrar algo. É a máquina do tempo do projeto.
GitHub: A plataforma mais usada para guardar projetos de código na nuvem e colaborar em equipe. Serve de remoto (backup e ponto de encontro) e oferece ferramentas de revisão, discussão e automação em torno do git.
Hook: Um comando que o Claude Code executa automaticamente quando um evento acontece, como antes de rodar uma ferramenta ou ao iniciar uma sessão. Roda de forma garantida, sem depender de o agente decidir, o que o torna ideal para regras que precisam valer sempre.
Hook de contexto: Um hook, no evento de início de sessão, que carrega automaticamente informações úteis, como o estado do projeto ou uma checagem inicial. Prepara o ambiente para o agente já começar com o contexto certo.
Hook de formatação: Um hook, no evento de depois de uma edição, que roda o formatador de código no arquivo alterado. Garante que todo código editado pelo agente saia sempre no padrão de estilo do projeto, sem você precisar lembrar de formatar.
Import: A referência, dentro do CLAUDE.md, a outro arquivo usando o simbolo de arroba antes do caminho. O conteúdo referenciado e trazido para o contexto no início da sessão, ajudando a organizar as instruções em pedacos.
Inicializar (/init): O comando que gera um CLAUDE.md inicial, analisando o seu projeto para descobrir comandos, testes e convencoes. Serve de ponto de partida, que você refina com instruções que ele não teria como adivinhar.
Injeção de instrução: Quando um conteúdo externo, como um texto num site, num arquivo ou numa mensagem, esconde instruções tentando fazer o agente de IA agir contra o seu interesse. Desconfiar de conteúdo não confiavel e a defesa principal.
Injeção no comando: O recurso de um comando personalizado incluir, no próprio pedido, a saída de um comando de terminal ou o conteúdo de um arquivo, para o agente já receber esse contexto pronto quando o comando roda.
Injeção via servidor: O risco de um servidor MCP não confiável trazer conteúdo com instruções escondidas que tentam manipular o agente. É a mesma injeção de instrução vista no módulo de segurança, agora vinda de uma fonte externa conectada.
Instalador nativo: O caminho recomendado de instalação do Claude Code: um comando que baixa e configura a ferramenta direto da fonte oficial, sem depender de outros programas. Nas instalações nativas, a ferramenta se atualiza sozinha em segundo plano.
Instrução específica: Uma orientacao concreta o bastante para ser verificada, como usar duas casas de indentacao, em vez de algo vago como formatar bem. Instruções específicas são seguidas com muito mais consistencia pelo agente.
Integração com o editor: A extensão ou plugin que traz o Claude Code para dentro do seu editor de código, como o VS Code ou os editores da JetBrains. Com ela, o agente trabalha no mesmo ambiente onde você já escreve código, sem precisar de um terminal separado.
Integração do GitHub: A configuração oficial que liga o Claude Code ao GitHub, permitindo que o agente responda a menções em pedidos de revisão e discussões, e aja sobre o código automaticamente, sem você estar no terminal. É instalada uma vez por quem administra o projeto.
Interface gráfica: A forma de usar um programa por janelas, botões e menus, clicando em vez de digitar comandos. É o oposto da linha de comando do terminal, e o que torna o aplicativo de desktop acessível a quem não tem familiaridade com ferramentas de desenvolvimento.
Interromper: Parar o agente no meio de uma resposta ou ação com a tecla ESC. O Claude Code preserva o trabalho já feito até ali, permitindo que você redirecione sem começar tudo de novo.
Invocação da skill: O ato de a skill entrar em ação, seja porque o Claude Code decidiu que ela é relevante (automática), seja porque você a chamou pelo nome (manual). Uma skill pode ser configurada para só aceitar a invocação manual, se você preferir.
Invocação explícita: Quando você pede diretamente para um subagente específico cuidar de uma tarefa, em vez de deixar o Claude Code decidir. Útil quando você sabe exatamente qual ajudante quer para aquele trabalho.
Janela de contexto: A quantidade de informação (medida em tokens) que o modelo consegue considerar de uma vez: o seu pedido, os arquivos lidos, o histórico da conversa. Quando ela enche, e preciso resumir ou limpar para continuar bem.
Laboratório: A área de prática guiada do curso: um terminal de treino simulado, no navegador, onde você experimenta comandos e fluxos do Claude Code sem instalar nada é sem risco de quebrar um projeto real.
Limpar a conversa: O comando que começa uma conversa nova com o contexto vazio, sem fechar a ferramenta. Usado quando o assunto muda; a conversa anterior fica salva para retomar depois.
Lista de tarefas: Uma checklist que o agente monta para planejar trabalhos de vários passos, mostrando o que está pendente, em andamento e concluido. Ajuda você a acompanhar e ajuda o agente a não se perder.
Marketplace de plugins: Um catálogo de onde se instalam plugins, com pacotes oficiais e da comunidade. Permite adicionar habilidades prontas ao Claude Code sem criá-las do zero, com a ressalva de revisar o que vem de fontes de terceiros.
MCP (Model Context Protocol): Um padrão aberto que conecta o Claude Code a ferramentas, bancos de dados e serviços externos. Com o MCP, o agente deixa de estar limitado ao seu projeto e passa a acessar sistemas de fora, lendo e agindo neles diretamente.
Memória automática: O sistema em que o próprio Claude Code guarda notas para si mesmo, com base nas suas correções e preferências observadas ao longo do uso, para lembrar delas em sessões futuras, sem você escrever nada a mão.
Memória de projeto: O conjunto de instruções que persiste entre as sessões do Claude Code. Como cada sessão começa com a memória em branco, os arquivos de memória, com o CLAUDE.md a frente, são o que ensina o agente sobre o seu projeto toda vez.
Menção de arquivo: O recurso de apontar um arquivo específico no pedido usando o atalho de arroba, que abre um autocompletar de caminhos. Assim o agente sabe exatamente onde olhar, em vez de procurar no projeto inteiro.
Mensagem de commit: O texto curto que descreve o que um commit mudou, como corrigi o erro de login. Boas mensagens tornam o histórico legível, permitindo entender a evolução do projeto sem abrir cada mudança. O Claude Code costuma escrevê-las bem.
Mensagem de erro: A saída que um comando produz quando algo deu errado, dizendo o tipo do problema e, muitas vezes, o arquivo e a linha. E a principal pista que o agente usa para se corrigir, em vez de chutar.
Menu de comandos: A lista que aparece quando você digita a barra no início da linha, mostrando todos os comandos disponíveis. Serve para descobrir e filtrar comandos sem precisar decorar os nomes.
Modelo (template): Um arquivo de apoio com uma estrutura pronta para o agente preencher, como um esqueleto de relatório ou de documento. Garante que o resultado saia sempre no formato esperado, sem o agente ter que reinventar a estrutura toda vez.
Modelo de linguagem: O sistema de inteligência artificial treinado para entender e gerar texto e código. No Claude Code, o modelo Claude é o cérebro que interpreta o seu pedido e decide as ações; a ferramenta e a estrutura que o conecta ao seu projeto.
Modelo padrão: O modelo da família Claude que o Claude Code usa quando você não pede outro. Você o define na configuração, e ele vale para as sessões até você trocar. Um bom padrão evita ter que escolher o modelo toda vez.
Modo de permissão: O ajuste que controla com que frequência o Claude Code pede a sua aprovação antes de editar arquivos ou rodar comandos. Vai do mais cauteloso, que pergunta a cada ação, ao mais automático, que age sem interromper.
Modo headless: O modo em que o Claude Code roda sem interação em tempo real: você passa uma tarefa, ele executa e devolve o resultado, sem a conversa de idas e voltas. É o que permite usar o agente dentro de scripts e automações, sem um humano na tela.
Modo manual (padrão): O modo inicial do Claude Code: ele só faz leituras sem perguntar e pede aprovação para qualquer ação que mude algo. E o mais seguro, indicado para começar e para trabalho sensível.
Modo sem freios: O modo que pula todas as checagens de permissão, executando qualquer ação na hora. Só e aceitavel em ambientes isolados e descartaveis, como containers ou máquinas virtuais sem acesso a dados importantes. E ativado por uma opção de nome deliberadamente assustador.
Modo shell: O modo em que você roda um comando do terminal direto, sem passar pelo agente, começando a linha com uma exclamacao. A saída entra no contexto e o Claude Code costuma responder sobre ela automaticamente.
Monitorar: Acompanhar o que um agente autônomo faz ao longo do tempo, por registros ou relatórios, para pegar problemas que a configuração não previu. Mesmo automatizado, o agente merece um olho humano periódico sobre o seu trabalho.
Motor do agente: A engrenagem que faz o Claude Code funcionar: o ciclo de entender, planejar, usar ferramentas e responder. O SDK dá acesso a esse motor pronto, para você construir agentes sem ter que reimplementar a lógica de um agente do zero.
Nome da skill: O identificador da skill, que vem do nome da pasta onde o arquivo dela fica. É por esse nome que você chama a skill manualmente, como um comando. A descrição diz o que ela faz; o nome diz como chamá-la.
npm: O gerenciador de pacotes do Node.js, muito usado por quem programa em JavaScript. E uma das formas alternativas de instalar o Claude Code, útil para quem já tem o Node.js instalado.
Passo pequeno e verificado: A unidade segura de uma mudança grande: uma alteração pequena o bastante para entender e revisar, seguida da verificação de que nada quebrou. Encadear passos pequenos e verificados é como se faz uma mudança grande sem susto.
Pasta de comandos: A pasta onde ficam os comandos personalizados. No projeto, uma pasta de comandos dentro da configuração compartilha os comandos com o time; na sua pasta pessoal, eles valem para todos os seus projetos.
Plan mode: O modo do Claude Code em que ele pesquisa o projeto, entende o problema e escreve um plano do que pretende fazer, mas não edita nenhum arquivo até você aprovar o plano. Separa a fase de pensar da fase de agir.
Planejamento na medida: A prática de casar o esforço de planejamento com o tamanho e o risco da tarefa: plano formal para o grande e sensível, execução direta para o pequeno e reversível. Evita tanto o excesso quanto a falta de planejamento.
Plano: A proposta escrita que o Claude Code apresenta no plan mode: os passos que ele pretende seguir para resolver a tarefa. Você lê, ajusta se quiser e só então autoriza a execução.
Plugin: Um pacote que reúne extensões do Claude Code, como skills, subagentes, comandos e outros recursos, para instalar e compartilhar de uma vez. É a forma de distribuir e reaproveitar extensões em escala, sua e da comunidade.
Prática constante: O uso regular do Claude Code no seu trabalho real, que é o que aprofunda o domínio depois do curso. Nenhum curso substitui a experiência acumulada; a prática constante é o que transforma o conhecimento em maestria ao longo do tempo.
Precedência: A ordem que decide qual configuração vence quando duas se aplicam ao mesmo ajuste. No Claude Code, o mais específico e restritivo costuma ter prioridade, como uma configuração da empresa acima de uma pessoal, garantindo que regras importantes não sejam afrouxadas.
Preparar o terreno: A fase inicial de um projeto, antes de codar: montar a pasta do projeto, dar contexto ao agente com o arquivo de memória, iniciar o controle de versão. Uma boa preparação torna todo o resto mais tranquilo e seguro.
Projeto final: A prática integradora do curso: construir um pequeno projeto real do zero ao fim com o Claude Code, aplicando tudo que você aprendeu. É onde o conhecimento vira experiência vivida, provando que você domina a prática, não só a teoria.
Prompt: O pedido que você escreve para o Claude Code. Um bom prompt tem objetivo claro, contexto útil e um critério para saber que a tarefa terminou. E a entrada mais importante do ciclo agêntico.
Pull request: Uma proposta de mudança no GitHub: você abre um pull request para pedir que as mudanças de um branch sejam revisadas e juntadas ao principal. É onde a equipe discute, revisa e aprova o código antes de ele entrar no projeto.
Raciocínio estendido: Um modo em que o Claude Code pensa por mais tempo antes de responder, útil em problemas difíceis e de vários passos. Rende um planejamento mais cuidadoso, ao custo de um pouco mais de tempo.
Recuperação ativa: Técnica de estudo em que você tenta lembrar e usar o conteúdo (respondendo, jogando, resolvendo) em vez de só reler. E o motivo de cada aula deste curso ter um jogo e um teste rápido: buscar a informação na memória fixa mais que revisitar o texto.
Recurso MCP: Um dado que um servidor MCP disponibiliza para o Claude Code ler, como o conteúdo de uma tarefa, um perfil de usuário ou um documento. Recursos são para consultar informação externa, não para agir sobre ela.
Refatoração: Reorganizar o código para melhorá-lo, deixá-lo mais claro ou mais fácil de manter, sem mudar o que ele faz por fora. Uma boa refatoração mantém o comportamento intacto enquanto melhora a estrutura, e por isso precisa ser verificada a cada passo.
Regra de permissão: Uma configuração que pre-aprova (liberar), forca pergunta (perguntar) ou impede (bloquear) uma ferramenta ou comando específico, sobre o comportamento geral do modo. Fica nos arquivos de configuração do Claude Code.
Regra por caminho (path-scoped): Um arquivo de instruções na pasta de regras do projeto que só entra no contexto quando o Claude Code trabalha com arquivos que casam com um padrão definido. Serve para instruções que só valem para uma parte do projeto.
Responsabilidade final: O princípio de que a pessoa que usa o Claude Code responde pelo que o agente produz e ela aprova. A responsabilidade não se transfere para a IA: quem coloca o código em uso é quem responde por ele, sempre.
Resumir o contexto: O comando que condensa a conversa atual num resumo, liberando espaço na janela de contexto para continuar o mesmo trabalho sem perder o essencial já conversado.
Retomar (--resume): A opção que abre um seletor das suas conversas anteriores para você escolher qual reabrir. Útil quando você tem várias sessões e quer voltar a uma específica, não necessariamente a última.
Revisão do todo: A revisão do projeto completo, além de cada passo isolado. Depois de construir, você olha o conjunto: as partes se encaixam? O projeto faz o que devia? Há pontas soltas? É a verificação em nível de projeto, que fecha a construção.
Revisão humana: O ato de uma pessoa ler, testar e aprovar o que a IA produziu antes de usar em sério. E a rede de segurança que transforma uma sugestão provavel em código confiavel, e continua sendo responsabilidade de quem usa a ferramenta.
Ritmo de trabalho: A cadência com que você alterna entre pensar, planejar, executar e revisar. Com a prática, esse ritmo vira automático, e você conduz tarefas grandes com naturalidade, sem decidir cada passo do zero.
Ritmo profissional: O método de quatro fases que quem domina o Claude Code segue em tarefas de peso: explorar para entender, planejar a abordagem, executar em passos e verificar o resultado. Segui-lo, em vez de mergulhar na primeira ideia, é o que garante qualidade e evita retrabalho.
Rotear por modelo: Escolher qual modelo da família Claude um subagente usa. Tarefas simples e repetidas podem ir para um modelo mais rápido e barato, economizando custo sem prejudicar a qualidade do trabalho principal.
Roteiro: Um plano escrito que guia uma tarefa longa ao longo de várias etapas ou sessões. Serve de referência para você e para o agente não se perderem, marcando o que já foi feito e o que falta.
Script: Um pequeno programa que executa uma sequência de comandos automaticamente. Rodar o Claude Code em modo headless dentro de um script permite encaixar o agente em fluxos automáticos, como parte de um processo maior que roda sozinho.
SDK: Um conjunto de ferramentas para desenvolvedores. O SDK do Claude Code, chamado Claude Agent SDK, permite usar o motor do agente dentro dos seus próprios programas, construindo agentes sob medida que reaproveitam toda a capacidade do Claude Code.
Segredo: Uma informação sensível que da acesso a sistemas, como senhas, chaves de API e tokens. Segredos nunca devem vazar para logs, para o código ou para fora do ambiente seguro, e merecem proteção redobrada no uso de qualquer ferramenta.
Segurança como hábito: A ideia de que a segurança não é uma configuração feita uma vez, mas um conjunto de cuidados presentes em cada uso: proteger segredos, desconfiar de conteúdo externo, não automatizar o imprudente. É a disciplina que sustenta o uso responsável ao longo do tempo.
Sensibilidade da tarefa: O quanto um erro naquela tarefa custaria: mexer numa parte critica com efeitos difíceis de desfazer e alta sensibilidade; um ajuste isolado e reversível e baixa. Ela guia o modo de permissão a escolher.
Servidor confiável: Um servidor MCP de fonte que você controla ou reconhece como idônea, como um serviço oficial ou um servidor da sua própria equipe. Antes de conectar qualquer servidor, é preciso confiar nele, porque ele passa a agir e trazer conteúdo para o agente.
Servidor local e remoto: Um servidor MCP local roda como um programa na sua máquina, útil para ferramentas que precisam de acesso direto ao sistema. Um servidor remoto roda num endereço na internet, ao qual o Claude Code se conecta por uma URL. A conexão muda um pouco entre os dois.
Servidor MCP: Um programa que expõe uma ferramenta ou serviço externo ao Claude Code por meio do MCP. Conectar um servidor MCP dá ao agente acesso ao que aquele servidor oferece, como consultar um banco ou criar uma tarefa num rastreador.
Sessão: Uma conversa aberta com o Claude Code, do momento em que você inicia a ferramenta até sair. Dentro da sessão, o agente lembra do contexto do que já foi conversado e feito.
Skill: O sistema maior de que os comandos personalizados fazem parte. Uma skill estende o que o Claude Code sabe fazer, pode ser chamada por você ou acionada pelo agente quando relevante, e ganha um módulo próprio no curso.
Slash command: Um comando do Claude Code que começa com o sinal de barra, como o de ajuda ou o de limpar a conversa. Controla a própria ferramenta (contexto, modelo, configuração), diferente de um pedido em português, que pede uma tarefa ao agente.
Subagente: Um assistente especializado que o Claude Code aciona para lidar com um tipo específico de tarefa. Ele roda no seu próprio contexto, com instruções próprias e acesso a ferramentas definido, faz o trabalho e devolve só o resultado à conversa principal.
Subagente pesquisador: Um subagente com instruções focadas em explorar e resumir: entender uma parte do projeto, levantar informações ou comparar abordagens. Faz o trabalho de leitura pesado no contexto dele e devolve um resumo à conversa principal.
Subagente revisor: Um subagente com instruções focadas em revisar código, procurando bugs, problemas de segurança ou de qualidade. Acionado após mudanças, ele analisa e devolve os achados, funcionando como um par de olhos extra especializado.
Sugestão de pedido: Um exemplo de comando que aparece em cinza no campo de entrada, baseado no seu histórico e no que você vinha fazendo. Aceitar com a tecla Tab preenche o pedido para você só ajustar e enviar.
Superfície: Uma das formas de acessar o Claude Code: o terminal, o editor de código, o aplicativo de desktop, a web ou o celular. Todas dão acesso ao mesmo agente; o que muda é a interface e a comodidade de cada uma.
Superfície principal: A superfície que você usa mais no dia a dia, escolhida conforme o seu perfil e o seu trabalho: o terminal para poder máximo, o editor para foco em código, o aplicativo de desktop para conforto. As outras superfícies complementam a principal em momentos específicos.
Tarefa agendada: Uma tarefa que o Claude Code executa automaticamente em horários definidos, como todo dia de manhã ou uma vez por semana, sem você precisar dispará-la. É a automação por tempo, útil para trabalhos periódicos e regulares.
Tarefa de alto risco: Aquela em que um erro custaria caro ou seria difícil de desfazer: mudanças grandes que tocam muitas partes, alterações em código sensível, ou trabalho num projeto que você ainda não domina. São as que mais se beneficiam do plan mode.
Terminal: Uma janela onde você conversa com o computador digitando comandos de texto, em vez de clicar em botoes. Também chamado de linha de comando, prompt ou console. E o ambiente natural do Claude Code.
Teste que falha primeiro: O teste escrito antes do código, que naturalmente falha no início porque o código ainda não existe. Fazê-lo passar vira o objetivo do agente. Um teste que falha e depois passa é a prova de que o código novo faz exatamente o que o teste exige.
Trabalho paralelo: Tocar mais de uma tarefa ao mesmo tempo, cada uma na sua sessão isolada. Com worktrees, o Claude Code pode trabalhar em várias frentes simultaneamente sem que as mudanças de uma bagunçem as da outra.
Transitar entre superfícies: Passar de uma superfície para outra conforme o momento do dia: trabalhar no editor, acompanhar pelo celular longe da mesa, acessar pela web de outro computador. Como é o mesmo agente, essa transição é natural e mantém o trabalho contínuo.
Usar para crescer: A escolha de usar o Claude Code de forma que ele desenvolva as suas habilidades, e não as substitua: entendendo o que ele faz, aprendendo com as suas explicações, usando-o como um professor. É o oposto de delegar às cegas e parar de aprender.
Variável de ambiente: Um valor de configuração definido no ambiente do sistema, que o Claude Code lê para ajustar o seu comportamento. Serve para ligar ou desligar recursos e definir detalhes, muitas vezes de forma pontual, sem editar o arquivo de configuração.
Verificar: A fase de conferir se o que foi feito realmente resolve o problema: rodar os testes, checar o comportamento, revisar as mudanças. É a fase que fecha o ciclo e que transforma eu acho que ficou pronto em eu tenho certeza.
Voltar a um ponto (rewind): Recurso que restaura o código e a conversa a um momento anterior da sessão. No modo interativo, com o campo vazio, apertar ESC duas vezes abre o menu para voltar a um ponto salvo.
Web: O acesso ao Claude Code pelo navegador, sem instalar nada, a partir de qualquer computador. Roda na nuvem, então você usa o agente de onde estiver, bastando entrar na sua conta, útil quando você não está na sua máquina de sempre.
Worktree: Uma cópia de trabalho isolada do mesmo projeto git, com o seu próprio branch, onde você pode fazer mudanças sem afetar as outras cópias. Permite rodar várias sessões do Claude Code em paralelo, cada uma na sua tarefa, sem conflitos.