AI Engineering

Conteúdo · 85 capítulos · 412 páginas

1. 1Boas-vindasAmostra

   • Boas-vindasAmostra grátis
   • 0.1.1 Para quem este manual foi escritoAmostra grátis
   • Trilha 🅱️ — Base mínimaAmostra grátis
   • 0.1 Objetivo do manualAmostra grátis
   • 0.2 Trilha de maturidadeAmostra grátis
   • 0.3 Convenções do manualAmostra grátis
2. 2Capítulo 1 — O novo modelo de desenvolvimento de software

   • Capítulo 1 — O novo modelo de desenvolvimento de software
   • 1.1 Desenvolvimento tradicional versus desenvolvimento assistido por IA
   • 1.2 Copiloto versus agente
   • 1.3 Os cinco recursos fundamentais
   • 1.4 Autonomia versus controle
   • 1.5 Os quatro recursos que precisam ser administrados
   • 1.6 Princípios fundamentais
   • Capítulo 1 — Resumo e autoavaliação
3. 3Capítulo 2 — Modos de trabalho

   • Capítulo 2 — Modos de trabalho
   • 2.1 ASK
   • 2.2 EXPLORE
   • 2.3 PLAN
   • 2.4 IMPLEMENT
   • 2.5 DEBUG
   • 2.6 VERIFY
   • 2.7 REVIEW
   • 2.8 A máquina de estados
   • Capítulo 2 — Resumo e autoavaliação
4. 4Capítulo 3 — Fase 0: Prepare

   • Capítulo 3 — Fase 0: Prepare
   • 3.1 a 3.3 — Repositório, Git e branch
   • 3.4 a 3.6 — Build, testes e linter: o baseline
   • 3.7 a 3.9 — Ambiente, permissões e ferramentas
   • 3.10 e 3.11 — Instruções do projeto e fronteiras da tarefa
   • Capítulo 3 — Resumo e autoavaliação
5. 5Capítulo 4 — Fase 1: Understand

   • Capítulo 4 — Fase 1: Understand
   • 4.1 e 4.2 — Do pedido aos requisitos; problema × solução solicitada
   • 4.3 e 4.4 — O Problem Statement e o objetivo
   • 4.5 e 4.6 — Restrições e non-goals
   • 4.7 e 4.8 — Critérios de aceite e requisitos não funcionais
   • 4.9 e 4.10 — Dúvidas abertas e Definition of Ready
   • Capítulo 4 — Resumo e autoavaliação
6. 6Capítulo 5 — Fase 2: Explore

   • Capítulo 5 — Fase 2: Explore
   • 5.1 e 5.2 — Mapeamento inicial e arquivos relevantes
   • 5.3 e 5.4 — Fluxo da aplicação e implementações análogas
   • 5.5 a 5.7 — Padrões existentes, testes relevantes e documentação
   • 5.8 e 5.9 — Dependências e blast radius
   • 5.10 — Relatório de descoberta
   • Capítulo 5 — Resumo e autoavaliação
7. 7Capítulo 6 — Fase 3: Plan

   • Capítulo 6 — Fase 3: Plan
   • 6.1 e 6.2 — Hipóteses e soluções candidatas
   • 6.3 e 6.4 — Trade-offs e escolha da solução
   • 6.5 e 6.6 — Sequência da implementação e arquivos envolvidos
   • 6.7 a 6.9 — Test plan, riscos e rollback
   • 6.10 — Aprovação do plano
   • Capítulo 6 — Resumo e autoavaliação
8. 8Capítulo 7 — Fase 4: Decompose

   • Capítulo 7 — Fase 4: Decompose
   • 7.1 e 7.2 — Por que decompor e task sizing
   • 7.3 e 7.4 — Dependências; sequencial versus paralelo
   • 7.5 a 7.7 — Input/output, critério de conclusão e contrato entre tarefas
   • 7.8 e 7.9 — Quando subdividir novamente e DAG de tarefas
   • Capítulo 7 — Resumo e autoavaliação
9. 9Capítulo 8 — Fase 5: Route

   • Capítulo 8 — Fase 5: Route
   • 8.1 e 8.2 — Escolher humano ou IA; escolher agente
   • 8.3 — Escolher modelo
   • 8.4 e 8.5 — Escolher ferramentas; escolher nível de autonomia
   • 8.6 e 8.7 — Escolher contexto; escolher permissões
   • Capítulo 8 — Resumo e autoavaliação
10. 10Capítulo 9 — Fase 6: Implement

    • Capítulo 9 — Fase 6: Implement
    • 9.1 e 9.2 — Mudanças incrementais e pequenos diffs
    • 9.3 e 9.4 — Respeitar convenções existentes; evitar refactoring oportunista
    • 9.5 — Não expandir escopo silenciosamente
    • 9.6 e 9.7 — Checkpoints e commits
    • 9.8 — Recuperação após erro
    • Capítulo 9 — Resumo e autoavaliação
11. 11Capítulo 10 — Fase 7: Verify

    • Capítulo 10 — Fase 7: Verify
    • 10.1 e 10.2 — Pirâmide de evidências e verificação funcional
    • 10.3 e 10.4 — Verificação não funcional e regressão
    • 10.5 a 10.7 — Segurança, performance e compatibilidade
    • 10.8 — Testes negativos (negative testing)
    • 10.9 — Evidência versus afirmação
    • Capítulo 10 — Resumo e autoavaliação
12. 12Capítulo 11 — Fase 8: Review

    • Capítulo 11 — Fase 8: Review
    • 11.1 e 11.2 — Revisão independente e checklist
    • 11.3 e 11.4 — Revisão do diff e dos testes
    • 11.5 e 11.6 — Revisão de segurança e de arquitetura
    • 11.7 e 11.8 — Revisão de aceite e aprovação humana
    • Capítulo 11 — Resumo e autoavaliação
13. 13Capítulo 12 — Fase 9: Document & Learn

    • Capítulo 12 — Fase 9: Document & Learn
    • 12.1 e 12.2 — Documentar a mudança; atualizar a arquitetura
    • 12.3 e 12.4 — Registrar a decisão; capturar o aprendizado
    • 12.5 a 12.7 — Melhorar instruções, criar ou melhorar skills, automatizar recorrências
    • 12.8 e 12.9 — Identificar falhas do agente; alimentar novas boas práticas
    • Capítulo 12 — Resumo e autoavaliação
14. 14Capítulo 13 — Contexto como recurso de engenharia

    • Capítulo 13 — Contexto como recurso de engenharia
    • 13.1 e 13.2 — O que é contexto; a janela de contexto
    • 13.3 a 13.5 — Contexto útil × ruído; poluição; degradação
    • 13.6 e 13.7 — Orçamento de contexto; progressive disclosure
    • 13.8 e 13.9 — Isolamento e compressão de contexto
    • Capítulo 13 — Resumo e autoavaliação
15. 15Capítulo 14 — Hierarquia de instruções

    • Capítulo 14 — Hierarquia de instruções
    • 14.1 a 14.3 — Instruções pessoais, globais e do repositório
    • 14.4 e 14.5 — Instruções por diretório e instruções temporárias
    • 14.6 e 14.7 — Rules e skills na hierarquia
    • 14.8 e 14.9 — Quando uma instrução virou ruído; como escrever instruções eficientes
    • Capítulo 14 — Resumo e autoavaliação
16. 16Capítulo 15 — Prompt engineering para engenharia de software

    • Capítulo 15 — Prompt engineering para engenharia de software
    • 15.1 e 15.2 — Anatomia de uma tarefa; prompts orientados a resultado
    • 15.3 a 15.5 — Prompts orientados a restrições, exemplos e critérios explícitos
    • 15.6 a 15.8 — Restrições negativas, prompts longos demais e quando melhorar o contexto
    • Capítulo 15 — Resumo e autoavaliação
17. 17Capítulo 16 — Rules

    • Capítulo 16 — Rules
    • 16.1 e 16.2 — Conceito; rules versus prompts
    • 16.3 a 16.5 — Rules globais, por domínio e específicas de arquivos
    • 16.6 a 16.9 — Convenções de código, arquitetura, segurança e testes
    • 16.10 — Anti-patterns e ciclo de vida das rules
    • Capítulo 16 — Resumo e autoavaliação
18. 18Capítulo 17 — Skills

    • Capítulo 17 — Skills
    • 17.1 a 17.4 — Conceito; skill versus rule; skill versus prompt; quando criar
    • 17.5 a 17.7 — Anatomia, inputs e workflow
    • 17.8 e 17.9 — Outputs e validação
    • 17.10 e 17.11 — Skills reutilizáveis e compostas
    • 17.12 e 17.13 — Versionamento e governança
    • Capítulo 17 — Resumo e autoavaliação
19. 19Capítulo 18 — Hooks

    • Capítulo 18 — Hooks
    • 18.1 e 18.2 — Determinismo versus decisão do LLM; eventos do ciclo
    • 18.3 e 18.4 — Hooks antes e depois da ação
    • 18.5 a 18.8 — Hooks de validação, segurança, formatação e registro
    • 18.9 a 18.11 — Aprovação, observabilidade, e quando usar hook versus skill
    • Capítulo 18 — Resumo e autoavaliação
20. 20Capítulo 19 — MCP e ferramentas externas

    • Capítulo 19 — MCP e ferramentas externas
    • 19.1 a 19.3 — Conceito; uso de ferramentas; servidor MCP
    • 19.4 a 19.6 — Recursos, ferramentas e dados externos
    • 19.7 a 19.9 — Leitura × escrita, permissões e privilégio mínimo
    • 19.10 a 19.12 — Segurança, prompt injection e dados não confiáveis
    • 19.13 e 19.14 — MCP em produção e auditoria
    • Capítulo 19 — Resumo e autoavaliação
21. 21Capítulo 20 — Model Routing

    • Capítulo 20 — Model Routing
    • 20.1 a 20.4 — Nem toda tarefa requer o melhor modelo; FAST, BALANCED, DEEP
    • 20.5 a 20.7 — Complexidade versus modelo, custo versus qualidade, latência
    • 20.8 e 20.9 — Escalonamento e fallback
    • 20.10 e 20.11 — Diversidade de modelos; revisor com modelo diferente
    • Capítulo 20 — Resumo e autoavaliação
22. 22Capítulo 21 — Cost Engineering

    • Capítulo 21 — Cost Engineering
    • 21.1 a 21.3 — Tokens como recurso; custo de contexto; custo de output
    • 21.4 e 21.5 — Custo de agentes e custo de paralelismo
    • 21.6 e 21.7 — Caching e reutilização
    • 21.8 a 21.10 — ROI; quando um modelo barato sai caro; quando um modelo caro é desperdício
    • Capítulo 21 — Resumo e autoavaliação
23. 23Capítulo 22 — Subagentes

    • Capítulo 22 — Subagentes
    • 22.1 e 22.2 — Conceito; especialização
    • 22.3 a 22.5 — Isolamento, contexto próprio e permissões de ferramentas
    • 22.6 e 22.7 — Delegação; resultado estruturado
    • 22.8 — Quando não usar subagente
    • Capítulo 22 — Resumo e autoavaliação
24. 24Capítulo 23 — Padrões multiagente

    • Capítulo 23 — Padrões multiagente
    • 23.1 a 23.3 — Padrões em sequência
    • 23.4 a 23.6 — Pesquisa e especialistas
    • 23.7 a 23.9 — Orquestrador, debate e crítico
    • 23.10 — Independent Verification, e como escolher o padrão
    • Capítulo 23 — Resumo e autoavaliação
25. 25Capítulo 24 — Paralelismo

    • Capítulo 24 — Paralelismo
    • 24.1 a 24.3 — O que pode ser paralelo, o que deve ser sequencial, dependências
    • 24.4 a 24.6 — Condições de corrida, arquivos compartilhados e conflitos
    • 24.7 a 24.9 — Worktrees, merge e reconciliação de respostas
    • Capítulo 24 — Resumo e autoavaliação
26. 26Capítulo 25 — Orquestração

    • Capítulo 25 — Orquestração
    • 25.1 a 25.4 — Papel do orquestrador, grafo de tarefas, delegação e roteamento
    • 25.5 e 25.6 — Controle de estado e dependências
    • 25.7 a 25.10 — Retry, timeout, tratamento de falhas e escalonamento
    • 25.11 e 25.12 — Human-in-the-loop e Definition of Done global
    • Capítulo 25 — Resumo e autoavaliação
27. 27Capítulo 26 — Guardrails

    • Capítulo 26 — Guardrails
    • 26.1 a 26.3 — Autonomia proporcional ao risco; allowlist; denylist
    • 26.4 a 26.7 — Somente leitura, escrita, terminal e rede
    • 26.8 a 26.10 — Arquivos, banco de dados e produção
    • 26.11 — Aprovação humana, e o mapa de guardrails
    • Capítulo 26 — Resumo e autoavaliação
28. 28Capítulo 27 — Segurança

    • Capítulo 27 — Segurança
    • 27.1 a 27.3 — Segredos, credenciais e dados sensíveis
    • 27.4 e 27.5 — Dependências externas e cadeia de suprimentos
    • 27.6 a 27.8 — Prompt injection, envenenamento de ferramentas e código gerado inseguro
    • 27.9 a 27.11 — Exfiltração, auditoria e incidentes
    • Capítulo 27 — Resumo e autoavaliação
29. 29Capítulo 28 — Gestão de falhas da IA

    • Capítulo 28 — Gestão de falhas da IA
    • 28.1 e 28.2 — Alucinação e falsa conclusão
    • 28.3 a 28.5 — Overengineering, scope creep e suposição silenciosa
    • 28.6 a 28.9 — Ação destrutiva, loop, perda de contexto e regressão
    • 28.10 — Estratégias de recuperação
    • Capítulo 28 — Resumo e autoavaliação
30. 30Capítulo 29 — 🟢 Júnior: Desenvolvedor Assistido

    • Capítulo 29 — 🟢 Júnior: Desenvolvedor Assistido
    • 29.1 e 29.2 — Objetivos e competências obrigatórias
    • 29.3 a 29.5 — ASK, PLAN básico e contexto básico
    • 29.6 a 29.9 — Git, diff, testes e verificação
    • 29.10 — Segurança básica
    • 29.11 — Exercícios e o exercício guiado
    • 29.12 e 29.13 — Checklist de avaliação e critérios para tornar-se Intermediário
    • Capítulo 29 — Resumo e autoavaliação
31. 31Capítulo 30 — 🔵 Intermediário: Desenvolvedor Aumentado

    • Capítulo 30 — 🔵 Intermediário: Desenvolvedor Aumentado
    • 30.1 — Objetivos e competências obrigatórias
    • 30.2 a 30.4 — Context engineering, rules e skills
    • 30.5 a 30.7 — Hooks, MCP e agentes
    • 30.8 a 30.10 — Model routing, decomposição e CI/CD
    • 30.11 e 30.12 — Segurança e observabilidade básica
    • 30.13 — Exercícios
    • 30.14 e 30.15 — Avaliação e critérios para tornar-se Avançado
    • Capítulo 30 — Resumo e autoavaliação
32. 32Capítulo 31 — 🟣 Avançado: Orquestrador de Agentes

    • Capítulo 31 — 🟣 Avançado: Orquestrador de Agentes
    • 31.1 — Objetivos e competências
    • 31.2 a 31.4 — Arquitetura de agentes, multiagente e grafo de tarefas
    • 31.5 a 31.8 — Isolamento de contexto, execução paralela, roteamento e custo
    • 31.9 a 31.11 — Guardrails, observabilidade e avaliação
    • 31.12 e 31.13 — Escalonamento humano e recuperação de falhas
    • 31.14 e 31.15 — Governança e métricas
    • 31.16 — Exercícios avançados
    • Capítulo 31 — Resumo e autoavaliação
33. 33Capítulo 32 — Playbook: Nova feature

    • Capítulo 32 — Playbook: Nova feature
    • 32.1 e 32.2 — Understand e Explore
    • 32.3 e 32.4 — Plan e Implement
    • 32.5 e 32.6 — Test e Review
    • Capítulo 32 — Cartão de bolso, armadilhas e resumo
34. 34Capítulo 33 — Playbook: Bug fix

    • Capítulo 33 — Playbook: Bug fix
    • 33.1 a 33.3 — Reprodução, investigação e hipótese
    • 33.4 a 33.6 — Teste de regressão, correção e verificação
    • Capítulo 33 — Cartão de bolso, armadilhas e resumo
35. 35Capítulo 34 — Playbook: Refactoring

    • Capítulo 34 — Playbook: Refactoring
    • 34.1 a 34.6 — O roteiro
    • Exemplo, armadilhas e exercício
    • Capítulo 34 — Cartão de bolso e resumo
36. 36Capítulo 35 — Playbook: Código legado

    • Capítulo 35 — Playbook: Código legado
    • 35.1 a 35.6 — O roteiro
    • Exemplo, armadilhas e exercício
    • Capítulo 35 — Cartão de bolso e resumo
37. 37Capítulo 36 — Playbook: Criação de API

    • Capítulo 36 — Playbook: Criação de API
    • 36.1 a 36.6 — O roteiro
    • Exemplo, armadilhas e exercício
    • Capítulo 36 — Cartão de bolso e resumo
38. 38Capítulo 37 — Playbook: Banco e migration

    • Capítulo 37 — Playbook: Banco e migration
    • 37.1 a 37.6 — O roteiro
    • Exemplo, armadilhas e exercício
    • Capítulo 37 — Cartão de bolso e resumo
39. 39Capítulo 38 — Playbook: Front-end

    • Capítulo 38 — Playbook: Front-end
    • 38.1 a 38.6 — O roteiro
    • Exemplo, armadilhas e exercício
    • Capítulo 38 — Cartão de bolso e resumo
40. 40Capítulo 39 — Playbook: Testes

    • Capítulo 39 — Playbook: Testes
    • 39.1 a 39.6 — O roteiro
    • Exemplo, armadilhas e exercício
    • Capítulo 39 — Cartão de bolso e resumo
41. 41Capítulo 40 — Playbook: Code review

    • Capítulo 40 — Playbook: Code review
    • 40.1 a 40.6 — O roteiro
    • Exemplo, armadilhas e exercício
    • Capítulo 40 — Cartão de bolso e resumo
42. 42Capítulo 41 — Playbook: Investigação de incidente

    • Capítulo 41 — Playbook: Investigação de incidente
    • 41.1 a 41.6 — O roteiro
    • Exemplo, armadilhas e exercício
    • Capítulo 41 — Cartão de bolso e resumo
43. 43Capítulo 42 — Playbook: Performance

    • Capítulo 42 — Playbook: Performance
    • 42.1 a 42.6 — O roteiro
    • Exemplo, armadilhas e exercício
    • Capítulo 42 — Cartão de bolso e resumo
44. 44Capítulo 43 — Playbook: Vulnerabilidade

    • Capítulo 43 — Playbook: Vulnerabilidade
    • 43.1 a 43.6 — O roteiro
    • Exemplo, armadilhas e exercício
    • Capítulo 43 — Cartão de bolso e resumo
45. 45Capítulo 44 — Playbook: Atualização de dependências

    • Capítulo 44 — Playbook: Atualização de dependências
    • 44.1 a 44.6 — O roteiro
    • Exemplo, armadilhas e exercício
    • Capítulo 44 — Cartão de bolso e resumo
46. 46Capítulo 45 — Playbook: Migração tecnológica

    • Capítulo 45 — Playbook: Migração tecnológica
    • 45.1 a 45.6 — O roteiro
    • Exemplo, armadilhas e exercício
    • Capítulo 45 — Cartão de bolso e resumo
47. 47Capítulo 46 — Playbook: Documentação

    • Capítulo 46 — Playbook: Documentação
    • 46.1 a 46.6 — O roteiro
    • Exemplo, armadilhas e exercício
    • Capítulo 46 — Cartão de bolso e resumo
48. 48Capítulo 47 — Playbook: Multi-agent feature development

    • Capítulo 47 — Playbook: Multi-agent feature development
    • 47.1 a 47.6 — O roteiro
    • Exemplo, armadilhas e exercício
    • Capítulo 47 — Cartão de bolso e resumo
49. 49Capítulo 48 — Vibe Coding

    • Capítulo 48 — Vibe Coding
    • 48.1 e 48.2 — Quando experimentar é aceitável, e quando vira risco
    • 48.3 — Como sair do protótipo para a engenharia
    • Capítulo 48 — Cartão, resumo e exercício
50. 50Capítulo 49 — Agent Everywhere

    • Capítulo 49 — Agent Everywhere
    • O custo, a fronteira, exemplo e a saída
    • Capítulo 49 — Cartão, resumo e exercício
51. 51Capítulo 50 — Prompt "faça tudo"

    • Capítulo 50 — Prompt "faça tudo"
    • O custo, a fronteira, exemplo e a saída
    • Capítulo 50 — Cartão, resumo e exercício
52. 52Capítulo 51 — Context Dump

    • Capítulo 51 — Context Dump
    • O custo, a fronteira, exemplo e a saída
    • Capítulo 51 — Cartão, resumo e exercício
53. 53Capítulo 52 — Instruções e rules gigantes

    • Capítulo 52 — Instruções e rules gigantes
    • O custo, a fronteira, exemplo e a saída
    • Capítulo 52 — Cartão, resumo e exercício
54. 54Capítulo 53 — Overplanning

    • Capítulo 53 — Overplanning
    • O custo, a fronteira, exemplo e a saída
    • Capítulo 53 — Cartão, resumo e exercício
55. 55Capítulo 54 — Underplanning

    • Capítulo 54 — Underplanning
    • O custo, a fronteira, exemplo e a saída
    • Capítulo 54 — Cartão, resumo e exercício
56. 56Capítulo 55 — Modelo mais caro para tudo

    • Capítulo 55 — Modelo mais caro para tudo
    • O custo, a fronteira, exemplo e a saída
    • Capítulo 55 — Cartão, resumo e exercício
57. 57Capítulo 56 — Modelo barato para decisões críticas

    • Capítulo 56 — Modelo barato para decisões críticas
    • O custo, a fronteira, exemplo e a saída
    • Capítulo 56 — Cartão, resumo e exercício
58. 58Capítulo 57 — Multi-agent theater

    • Capítulo 57 — Multi-agent theater
    • O custo, a fronteira, exemplo e a saída
    • Capítulo 57 — Cartão, resumo e exercício
59. 59Capítulo 58 — Revisor que participou da implementação

    • Capítulo 58 — Revisor que participou da implementação
    • O custo, a fronteira, exemplo e a saída
    • Capítulo 58 — Cartão, resumo e exercício
60. 60Capítulo 59 — Testes gerados para confirmar a própria implementação

    • Capítulo 59 — Testes gerados para confirmar a própria implementação
    • O custo, a fronteira, exemplo e a saída
    • Capítulo 59 — Cartão, resumo e exercício
61. 61Capítulo 60 — Agente com terminal irrestrito

    • Capítulo 60 — Agente com terminal irrestrito
    • O custo, a fronteira, exemplo e a saída
    • Capítulo 60 — Cartão, resumo e exercício
62. 62Capítulo 61 — MCP com privilégios excessivos

    • Capítulo 61 — MCP com privilégios excessivos
    • O custo, a fronteira, exemplo e a saída
    • Capítulo 61 — Cartão, resumo e exercício
63. 63Capítulo 62 — Automação sem observabilidade

    • Capítulo 62 — Automação sem observabilidade
    • O custo, a fronteira, exemplo e a saída
    • Capítulo 62 — Cartão, resumo e exercício
64. 64Capítulo 63 — "Tests passed, therefore correct"

    • Capítulo 63 — "Tests passed, therefore correct"
    • O custo, a fronteira, exemplo e a saída
    • Capítulo 63 — Cartão, resumo e exercício
65. 65Capítulo 64 — Observabilidade de agentes

    • Capítulo 64 — Observabilidade de agentes
    • 64.1 e 64.2 — Registro da tarefa e chamadas de ferramenta
    • 64.3 a 64.5 — Decisões, erros e retentativas
    • 64.6 a 64.8 — Tempo, tokens e custo
    • 64.9 — Intervenções humanas, e o registro montado
    • Capítulo 64 — Resumo e autoavaliação
66. 66Capítulo 65 — Métricas

    • Capítulo 65 — Métricas
    • 65.1 a 65.3 — Lead time, first-pass success e regression rate
    • 65.4 e 65.5 — Retrabalho e taxa de intervenção humana
    • 65.6 a 65.8 — Custo por tarefa, eficiência de tokens e efetividade dos testes
    • Lendo as métricas juntas: o painel
    • Capítulo 65 — Resumo e autoavaliação
67. 67Capítulo 66 — Avaliação de agentes

    • Capítulo 66 — Avaliação de agentes
    • 66.1 e 66.2 — Evals e golden tasks
    • 66.3 — Suítes de regressão
    • 66.4 a 66.6 — Comparar modelos, prompts e agentes
    • 66.7 — Cost-quality benchmark
    • Capítulo 66 — Resumo e autoavaliação
68. 68Capítulo 67 — Aplicação no Visual Studio Code

    • Capítulo 67 — Aplicação no Visual Studio Code
    • 67.1 a 67.4 — Chat, inline, Plan e Agent
    • 67.5 a 67.7 — Contexto, instruções e skills
    • 67.8 e 67.9 — Ferramentas e permissões
    • 67.10 — Sessions
    • Capítulo 67 — Resumo e autoavaliação
69. 69Capítulo 68 — Aplicação no Cursor

    • Capítulo 68 — Aplicação no Cursor
    • 68.1 — Mapeamento dos conceitos
    • 68.2 e 68.3 — Ask e Agents
    • 68.4 e 68.5 — Rules e context
    • 68.6 — MCP
    • 68.7 — Aplicação dos workflows do manual
    • Capítulo 68 — Resumo e autoavaliação
70. 70Capítulo 69 — Aplicação no Claude Code

    • Capítulo 69 — Aplicação no Claude Code
    • 69.1 e 69.2 — CLAUDE.md e rules
    • 69.3 e 69.4 — Plan e skills
    • 69.5 e 69.6 — Subagents e hooks
    • 69.7 e 69.8 — MCP e plugins
    • 69.9 — Permissões
    • 69.10 — Estratégias multiagente
    • Capítulo 69 — Resumo e autoavaliação
71. 71Capítulo 70 — Decision Trees

    • Capítulo 70 — Decision Trees
    • 70.1 e 70.2 — Qual estado? Para onde vou?
    • 70.3 a 70.5 — Classe de risco, alteração × liberação e autonomia
    • 70.6 a 70.8 — Plano, modelo e escalonamento
    • Capítulo 70 — Resumo e autoavaliação
72. 72Capítulo 71 — Qual mecanismo usar?

    • Capítulo 71 — Qual mecanismo usar?
    • 71.1 e 71.2 — A árvore e os mecanismos
    • 71.3 a 71.6 — Combinações, escada, exemplos e sintomas
    • Capítulo 71 — Resumo e autoavaliação
73. 73Capítulo 72 — Checklists

    • Capítulo 72 — Checklists
    • 72.1 a 72.3 — Antes de começar, de PLAN e de IMPLEMENT
    • 72.4 e 72.5 — Antes de executar comandos e de adicionar dependência
    • 72.6 a 72.8 — Antes de finalizar, do commit e do PR
    • 72.9 e 72.10 — Antes do deploy e antes de produção
    • Capítulo 72 — Resumo e rastreabilidade
74. 7473.1 — Problem Statement

    • 73.1 — Problem Statement
    • 73.2 — ASK prompt
    • 73.3 — EXPLORE prompt
    • 73.4 — PLAN prompt
    • 73.5 — Implementation prompt
    • 73.6 — Debug prompt
    • 73.7 — Verification prompt
    • 73.8 — Reviewer prompt
    • 73.9 — Agent definition
    • 73.10 — Skill
    • 73.11 — Rule
    • 73.12 — Hook
    • 73.13 — Multi-agent workflow
    • 73.14 — Task contract
    • 73.15 — Definition of Done
    • 73.16 — Relatório de status
    • 73.17 — Plano de liberação
    • 73.18 — Registro de incidente e postmortem
75. 75Capítulo 74 — Cheat Sheets

    • Capítulo 74 — Cheat Sheets
    • 74.1 a 74.3 — Modos, prompt anatomy e context
    • 74.4 e 74.5 — Agents e model routing
    • 74.6 a 74.8 — Segurança, review e troubleshooting
    • Capítulo 74 — Resumo e rastreabilidade
76. 76Apêndice A — Glossário

    • Apêndice A — Glossário
77. 77Apêndice B — Matriz de maturidade

    • Apêndice B — Matriz de maturidade
78. 78Apêndice C — Matriz de risco

    • Apêndice C — Matriz de risco
79. 79Apêndice D — Matriz de escolha de modelo

    • Apêndice D — Matriz de escolha de modelo
80. 80Apêndice E — Catálogo de agentes

    • Apêndice E — Catálogo de agentes
81. 81Apêndice F — Catálogo de skills

    • Apêndice F — Catálogo de skills
82. 82Apêndice G — Catálogo de hooks

    • Apêndice G — Catálogo de hooks
83. 83Apêndice H — Exemplos completos

    • Apêndice H — Exemplos completos
84. 84Apêndice I — Troubleshooting

    • Apêndice I — Troubleshooting
85. 85Apêndice J — Referências externas

    • Apêndice J — Referências externas