Blog

Como usar o Claude Code Skills para CI/CD: Guia Completo

Ashley Innocent

Ashley Innocent

22 janeiro 2026

Como usar o Claude Code Skills para CI/CD: Guia Completo

Se você tem procurado uma maneira de injetar inteligência em seu pipeline de CI/CD sem ter que lidar com scripts de automação complexos, as Habilidades de Código Claude (Claude Code Skills) podem ser exatamente o que você precisa. Esses fluxos de trabalho personalizados, impulsionados por IA, automatizam tudo, desde verificações de segurança pré-commit até validação de implantação. Você os define usando instruções em linguagem natural, em vez de scripts de shell frágeis.

O que torna as Habilidades de Código Claude poderosas para CI/CD:

💡
Construindo pipelines centrados em API? Combine as Habilidades de Código Claude com Apidog para automação de API de ponta a ponta. Apidog oferece testes visuais de API, geração automatizada de testes a partir de especificações OpenAPI e ferramentas CLI prontas para CI/CD que se integram perfeitamente com suas habilidades. Experimente Apidog gratuitamente para impulsionar seus fluxos de trabalho de API.
botão

Neste guia, exploraremos o que são as Habilidades de Código Claude, como construir fluxos de trabalho CI/CD personalizados e exemplos do mundo real que você pode implementar hoje.

Compreendendo as Habilidades de Código Claude

O Que São Habilidades?

As Habilidades de Código Claude são fluxos de trabalho de IA personalizados e reutilizáveis que estendem as capacidades do Claude Code. Pense neles como scripts inteligentes que podem:

Ao contrário dos scripts tradicionais que seguem uma lógica rígida, as habilidades aproveitam as capacidades de raciocínio do Claude para lidar com casos extremos, sugerir melhorias e se adaptar a condições variáveis.

Como as Habilidades Funcionam

As habilidades operam através de vários mecanismos chave:

1. Comandos Invocáveis pelo Usuário

# Run a skill with a slash command
/deploy-validation --env production
/security-review
/ci-pipeline-monitor --branch main

2. Ferramentas Permitidas

As habilidades especificam quais ferramentas podem usar:

3. Ganchos de Ciclo de Vida

As habilidades podem disparar ações em pontos específicos:

4. Arquivos de Planejamento

As habilidades podem manter o estado usando arquivos markdown para rastrear o progresso, armazenar descobertas e habilitar fluxos de trabalho retomáveis.

Por Que as Habilidades Se Destacam em CI/CD

Scripts de CI/CD tradicionais falham facilmente quando confrontados com condições inesperadas. As habilidades trazem inteligência à automação:

Anatomia da Habilidade: Componentes e Estrutura

Estrutura de Diretórios

As habilidades residem em .claude/skills/ com esta estrutura:

.claude/
├── skills/
│   ├── deploy-validation/
│   │   ├── SKILL.md              # Skill manifest and instructions
│   │   ├── planning.md           # State tracking (optional)
│   │   └── scripts/              # Helper scripts (optional)
│   ├── security-review/
│   │   └── SKILL.md
│   └── ci-monitor/
│       └── SKILL.md
└── skills.md                     # Index of all skills

O Manifesto SKILL.md

Cada habilidade começa com um frontmatter YAML seguido por instruções markdown:

---
name: deploy-validation
version: "1.0.0"
description: Validates deployment readiness with comprehensive checks
user-invocable: true
allowed-tools:
  - Bash
  - Read
  - Edit
  - Grep
  - Glob
hooks:
  SessionStart:
    - matcher: command
      command: "echo '[Deploy Validator] Starting pre-deployment checks...'"
  Stop:
    - matcher: command
      command: "echo '[Deploy Validator] Checks complete. Review output above.'"
---

# Habilidade de Validação de Implantação

Validação abrangente pré-implantação para lançamentos em produção.

## Uso

```bash
/deploy-validation --env production
/deploy-validation --env staging --dry-run
/deploy-validation --skip-tests  # Use cautiously

O Que Esta Habilidade Faz

Verificação de Ambiente

Verificações de Qualidade de Código

Testes

Validação de Build

Varredura de Segurança

Verificação de Documentação

Relatório de Implantação

Instruções para Claude

Quando invocada, siga este processo:

  1. Analisar argumentos de linha de comando para determinar ambiente e opções
  2. Verificar o branch git atual e o SHA do commit
  3. Executar cada etapa de validação em sequência
  4. Para cada falha, registrar o problema e continuar (coletar todos os erros)
  5. Após todas as verificações, gerar um relatório de resumo
  6. Se alguma verificação crítica falhar, sair com código de erro 1
  7. Se todas as verificações forem aprovadas, sair com código 0 e mostrar mensagem de sucesso

---

## Casos de Uso de Habilidades para CI/CD

### 1. Validação Pré-Commit

**Habilidade: `/pre-commit-guard`**

Valida automaticamente as alterações antes dos commits:
- Linting e formatação
- Varredura de segurança para segredos
- Execução de testes unitários
- Verificação de tamanho de arquivo
- Detecção de quebras de compatibilidade

**Benefício**: Capturar problemas antes que entrem na base de código.

### 2. Análise de Pull Request

**Habilidade: `/pr-review`**

Revisão inteligente de PR que:
- Analisa alterações de código em busca de problemas de qualidade
- Verifica vulnerabilidades de segurança
- Verifica cobertura de testes
- Sugere melhorias
- Gera comentários de revisão

**Benefício**: Revisão de código consistente e completa sem gargalos humanos.

### 3. Fluxos de Trabalho de Teste Automatizados

**Habilidade: `/test-runner`**

Execução inteligente de testes que:
- Detecta quais testes são relevantes para as alterações
- Executa testes em ordem ótima
- Analisa falhas e sugere correções
- Gera relatórios de cobertura
- Rastreia tendências de desempenho de testes

**Benefício**: Feedback mais rápido com seleção inteligente de testes.

### 4. Validação de Implantação

**Habilidade: `/deploy-validator`**

Verificações pré-implantação, incluindo:
- Validação da configuração do ambiente
- Verificação de dependências
- Verificação de migrações de banco de dados
- Testes de compatibilidade de API
- Detecção de regressão de desempenho

**Benefício**: Prevenir falhas de implantação antes que aconteçam.

### 5. Monitoramento de Pipeline CI

**Habilidade: `/ci-monitor`**

Monitora a saúde do pipeline:
- Acompanha taxas de sucesso de build
- Identifica testes instáveis
- Analisa tendências de desempenho
- Alerta sobre degradação
- Sugere otimizações

**Benefício**: Manutenção e otimização proativa do pipeline.

### 6. Automação de Lançamento

**Habilidade: `/release-manager`**

Orquestra o processo de lançamento:
- Aumento de versão
- Geração de Changelog
- Criação de Tags
- Verificação de artefatos de build
- Redação de notas de lançamento

**Benefício**: Lançamentos consistentes e sem erros.

### 7. Automação de Testes de API

**Habilidade: `/api-test-runner`**

Para equipes que constroem APIs, combine as Habilidades de Código Claude com o [Apidog](https://apidog.com) para validação abrangente de API:

- **Gerar casos de teste**: Crie testes de API a partir de especificações OpenAPI/Swagger
- **Executar testes automatizados**: Execute coleções de testes Apidog em seu pipeline
- **Validar respostas**: Verifique códigos de status, schemas e tempos de resposta
- **Simular dependências**: Configure servidores mock para testes isolados
- **Rastrear cobertura**: Monitore a cobertura de testes de endpoints API

**Exemplo de integração de habilidade:**
```bash
/api-test-runner --collection ./tests/api-collection.json --env production

Benefício: Capture regressões de API antes da implantação com depuração visual e relatórios detalhados. A integração CI/CD do Apidog facilita a adição de testes de API a qualquer pipeline.

Criando Sua Primeira Habilidade CI/CD

Vamos construir uma habilidade prática: uma ferramenta de revisão de segurança que verifica o código antes dos commits.

Passo 1: Criar o Diretório da Habilidade

mkdir -p .claude/skills/security-review

Passo 2: Escrever o Manifesto da Habilidade

Crie .claude/skills/security-review/SKILL.md:

---
name: security-review
version: "1.0.0"
description: Security scan for common vulnerabilities and secrets
user-invocable: true
allowed-tools:
  - Bash
  - Read
  - Grep
  - Glob
  - Write
hooks:
  SessionStart:
    - matcher: command
      command: "echo '[Security Review] Starting security scan...'"
  Stop:
    - matcher: command
      command: "echo '[Security Review] Scan complete'"
---

# Habilidade de Revisão de Segurança

Escaneia o código em busca de problemas de segurança antes dos commits.

## Uso

```bash
/security-review                    # Scan all changed files
/security-review --all              # Scan entire codebase
/security-review --file src/auth.js # Scan specific file

Padrões de Detecção

Esta habilidade verifica por:

Segredos Hardcoded

Vulnerabilidades Comuns

Configurações Inseguras

Problemas de Dependência

Instruções

Quando invocada:

Determinar escopo da varredura

Procurar por segredos

Verificar padrões de vulnerabilidade

Escanear dependências

Gerar relatório

Status de saída


### Passo 3: Registrar a Habilidade

Adicione a `.claude/skills.md`:

```markdown
# Habilidades Disponíveis

## Segurança e Qualidade

### /security-review
Varredura de segurança para vulnerabilidades e segredos.
- **Versão**: 1.0.0
- **Uso**: `/security-review [--all] [--file CAMINHO]`
- **Quando usar**: Antes de commits, durante revisão de PR

Passo 4: Testar a Habilidade

# No Claude Code
/security-review

Claude agora executará o fluxo de trabalho de revisão de segurança, verificando seu código em busca de problemas.

Padrões de Habilidade Avançados

Padrão 1: Fluxos de Trabalho com Estado Usando Arquivos de Planejamento

Para processos de várias etapas, use arquivos de planejamento para rastrear o progresso:

---
name: release-manager
version: "1.0.0"
user-invocable: true
allowed-tools:
  - Bash
  - Read
  - Write
  - Edit
---

# Gerenciador de Lançamentos

Gerencia o processo completo de lançamento.

## Gerenciamento de Estado

Esta habilidade usa `planning.md` para rastrear o progresso do lançamento:

```markdown
# Progresso do Lançamento v2.5.0

## Fase 1: Validação Pré-Lançamento [CONCLUÍDO]
- [x] Executar suíte de testes completa
- [x] Verificar cobertura de código > 80%
- [x] Escanear por problemas de segurança

## Fase 2: Aumento de Versão [EM ANDAMENTO]
- [x] Atualizar package.json
- [ ] Atualizar CHANGELOG.md
- [ ] Atualizar documentação

## Fase 3: Build e Tag [PENDENTE]
- [ ] Criar build de produção
- [ ] Executar testes de fumaça
- [ ] Criar tag git
- [ ] Enviar para o registro

## Fase 4: Pós-Lançamento [PENDENTE]
- [ ] Criar lançamento no GitHub
- [ ] Atualizar notas de lançamento
- [ ] Notificar a equipe

Instruções

Verificar se planning.md existe

Executar cada fase:

Para cada tarefa:


### Padrão 2: Fluxos de Trabalho Condicionais

As habilidades podem se adaptar com base no tipo de projeto:

```markdown
## Instruções

1. **Detectar tipo de projeto**
   - Verificar por `package.json` → projeto Node.js
   - Verificar por `requirements.txt` → projeto Python
   - Verificar por `Cargo.toml` → projeto Rust

2. **Executar testes apropriados**
   - Node.js: `npm test`
   - Python: `pytest`
   - Rust: `cargo test`

3. **Gerar relatórios de cobertura**
   - Node.js: Usar Jest/Istanbul
   - Python: Usar pytest-cov
   - Rust: Usar tarpaulin

Padrão 3: Execução Paralela

Para tarefas independentes, execute-as concorrentemente:

## Instruções

1. **Verificações paralelas** (executar simultaneamente):
   - Linting (ESLint, Prettier)
   - Type checking (TypeScript)
   - Security scan (npm audit)
   - Build de documentação

2. **Coletar resultados**
   - Esperar todas as tarefas serem concluídas
   - Agrupar descobertas
   - Relatar quaisquer falhas

Padrão 4: Tomada de Decisão Interativa

As habilidades podem pedir entrada do usuário:

## Instruções

1. **Analisar riscos de implantação**
   - Verificar por quebras de compatibilidade
   - Revisar scripts de migração
   - Avaliar complexidade de rollback

2. **Se risco ALTO detectado**
   - Apresentar descobertas ao usuário
   - Perguntar: "Implantar mesmo assim? (sim/não/cancelar)"
   - Se sim: prosseguir com a implantação
   - Se não: abortar e registrar decisão
   - Se cancelar: sair sem ação

3. **Se risco BAIXO**
   - Aprovar implantação automaticamente
   - Registrar decisão para auditoria

Integrando Habilidades com GitHub Actions

Método 1: Invocação Direta de Habilidade

Adicione Claude Code ao seu fluxo de trabalho do GitHub Actions:

# .github/workflows/security-scan.yml
name: Security Scan

on:
  pull_request:
    branches: [main, develop]

jobs:
  security-review:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v3

      - name: Install Claude Code
        run: |
          curl -fsSL https://install.claude.com | sh

      - name: Run Security Review
        env:
          ANTHROPIC_API_KEY: ${{ secrets.ANTHROPIC_API_KEY }}
        run: |
          claude /security-review --all

      - name: Upload Report
        if: always()
        uses: actions/upload-artifact@v3
        with:
          name: security-report
          path: .claude/security-reports/

Método 2: Ação GitHub Personalizada

Crie uma ação reutilizável:

# .github/actions/claude-skill/action.yml
name: 'Run Claude Code Skill'
description: 'Execute a Claude Code skill in CI'
inputs:
  skill-name:
    description: 'Name of the skill to run'
    required: true
  skill-args:
    description: 'Arguments to pass to the skill'
    required: false
    default: ''
  api-key:
    description: 'Anthropic API key'
    required: true

runs:
  using: 'composite'
  steps:
    - name: Setup Claude
      shell: bash
      run: |
        curl -fsSL https://install.claude.com | sh

    - name: Run Skill
      shell: bash
      env:
        ANTHROPIC_API_KEY: ${{ inputs.api-key }}
      run: |
        claude /${{ inputs.skill-name }} ${{ inputs.skill-args }}

Uso em fluxos de trabalho:

# .github/workflows/deploy.yml
name: Deploy

on:
  push:
    branches: [main]

jobs:
  validate-and-deploy:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v3

      - name: Pre-Deployment Validation
        uses: ./.github/actions/claude-skill
        with:
          skill-name: deploy-validation
          skill-args: '--env production'
          api-key: ${{ secrets.ANTHROPIC_API_KEY }}

      - name: Deploy
        if: success()
        run: ./deploy.sh production

      - name: Post-Deployment Check
        uses: ./.github/actions/claude-skill
        with:
          skill-name: health-check
          skill-args: '--url https://api.example.com'
          api-key: ${{ secrets.ANTHROPIC_API_KEY }}

Método 3: Teste de Matriz

Execute habilidades em vários ambientes:

# .github/workflows/test-matrix.yml
name: Test Matrix

on: [push, pull_request]

jobs:
  test:
    strategy:
      matrix:
        node-version: [16, 18, 20]
        os: [ubuntu-latest, macos-latest, windows-latest]

    runs-on: ${{ matrix.os }}

    steps:
      - uses: actions/checkout@v3

      - name: Setup Node
        uses: actions/setup-node@v3
        with:
          node-version: ${{ matrix.node-version }}

      - name: Run Test Skill
        env:
          ANTHROPIC_API_KEY: ${{ secrets.ANTHROPIC_API_KEY }}
        run: |
          claude /test-runner --node-version ${{ matrix.node-version }}

Integração de Git Hooks

Configurando Git Hooks

Git hooks permitem que as habilidades sejam executadas automaticamente em eventos git.

Hook Pré-Commit

Previne commits ruins antes que aconteçam:

# .git/hooks/pre-commit
#!/bin/bash

echo "Executando revisão de segurança pré-commit..."

# Run Claude Code security review
claude /security-review

if [ $? -ne 0 ]; then
    echo "FALHA: Problemas de segurança detectados. Commit bloqueado."
    echo "Corrija os problemas acima ou use 'git commit --no-verify' para ignorar (não recomendado)"
    exit 1
fi

echo "APROVADO: Verificação de segurança aprovada"
exit 0

Torne-o executável:

chmod +x .git/hooks/pre-commit

Hook Pré-Push

Validar antes de enviar para o repositório remoto:

# .git/hooks/pre-push
#!/bin/bash

echo "Executando validação pré-push..."

# Get the branch being pushed
BRANCH=$(git rev-parse --abbrev-ref HEAD)

# Run different checks based on branch
if [ "$BRANCH" = "main" ]; then
    echo "Enviando para main - executando validação completa..."
    claude /deploy-validation --env production
elif [ "$BRANCH" = "develop" ]; then
    echo "Enviando para develop - executando validação de staging..."
    claude /deploy-validation --env staging
else
    echo "Branch de feature - executando validação rápida..."
    claude /quick-check
fi

if [ $? -ne 0 ]; then
    echo "FALHA: Validação falhou. Envio bloqueado."
    exit 1
fi

echo "APROVADO: Validação aprovada"
exit 0

Hook Pós-Merge

Executar após a fusão de branches:

# .git/hooks/post-merge
#!/bin/bash

echo "Verificações pós-merge..."

# Check if dependencies changed
if git diff-tree -r --name-only --no-commit-id HEAD@{1} HEAD | grep -q "package-lock.json"; then
    echo "Dependências alteradas - executando auditoria de segurança..."
    claude /dependency-audit
fi

# Check if database migrations exist
if git diff-tree -r --name-only --no-commit-id HEAD@{1} HEAD | grep -q "migrations/"; then
    echo "Migrações detectadas - validando..."
    claude /migration-validator
fi

exit 0

Integração com Husky

Para equipes que usam Husky para gerenciar git hooks:

// package.json
{
  "husky": {
    "hooks": {
      "pre-commit": "claude /security-review && claude /lint-check",
      "pre-push": "claude /test-runner --quick",
      "post-merge": "claude /dependency-audit"
    }
  }
}

Ou com Husky v6+:

# .husky/pre-commit
#!/bin/sh
. "$(dirname "$0")/_/husky.sh"

claude /security-review
claude /lint-check

Conclusão

As Habilidades de Código Claude transformam CI/CD de scripts frágeis em fluxos de trabalho inteligentes e adaptativos. Ao combinar o raciocínio de IA com a automação tradicional, as habilidades podem:

Se seu pipeline de CI/CD inclui endpoints de API, combinar as Habilidades de Código Claude com o Apidog oferece o melhor dos dois mundos:

FuncionalidadeBenefício
Teste Visual de APIConstruir casos de teste sem escrever código
Importação OpenAPIGerar testes automaticamente a partir de suas especificações
Servidores MockTestar integrações antes que os backends estejam prontos
CLI de CI/CDExecutar testes Apidog em qualquer pipeline
Colaboração em EquipeCompartilhar coleções de testes com sua equipe

Pronto para otimizar seu fluxo de trabalho de API? Baixe o Apidog gratuitamente e crie sua primeira coleção de testes de API em minutos.

botão

Pratique o design de API no Apidog

Descubra uma forma mais fácil de construir e usar APIs

Cadastre-se gratuitamenteBaixar