# Guia Definitivo: Kiro (IDE + CLI) > Guia completo do Kiro — IDE e CLI da AWS com specs-driven development, powers, hooks e integração profunda com serviços cloud. Source: https://agentify.ia.br/blog/kiro-ide-cli/ Kiro é o agente de codificação da AWS que aposta numa filosofia diferente: antes de escrever código, ele pensa. Enquanto a maioria das ferramentas de IA dispara código a partir de um prompt, o Kiro transforma sua intenção em especificações estruturadas, design técnico e tarefas sequenciadas — e só então implementa. Disponível como IDE standalone e CLI para terminal, ele cobre o ciclo completo do desenvolvimento com rigor de engenharia. [IMAGEM: Cover do artigo — Kiro IDE e CLI lado a lado] ## Overview ### O que é o Kiro Kiro é um serviço de codificação agêntica desenvolvido pela AWS, construído sobre o Amazon Bedrock. Lançado em preview em julho de 2025 e em disponibilidade geral (GA) em novembro de 2025, ele se posiciona como a ponte entre “vibe coding” e engenharia de produção. A proposta central: você descreve o que quer construir em linguagem natural, e o Kiro gera requisitos formais, documentos de design técnico e tarefas de implementação antes de tocar em uma linha de código. Isso é o que a AWS chama de **specs-driven development** — e é o diferencial que separa o Kiro de concorrentes como Cursor, Copilot e Claude Code. ### Dois Produtos, Uma Assinatura O Kiro se divide em dois produtos complementares que compartilham a mesma assinatura: Produto Tipo Melhor para Kiro IDE IDE standalone (baseado em Code OSS) Desenvolvimento visual, specs completas, powers Kiro CLI Agente de terminal Automação, CI/CD, workflows headless, velocidade Ambos usam os mesmos steering files, configurações MCP e créditos da sua conta. Você pode alternar entre IDE e CLI sem perder contexto ou consistência. ### Modelos Disponíveis O Kiro opera com múltiplos modelos de fundação via Amazon Bedrock: - **Auto** (padrão) — mix inteligente de modelos frontier otimizado para qualidade, latência e custo - **Claude Sonnet 4.5 / 4.6** — modelos premium da Anthropic - **Claude Opus 4.5 / 4.6 / 4.7** — máxima capacidade - **Claude Haiku 4.5** — rápido e econômico - **Modelos open weight** (tier gratuito) — Qwen3 Coder Next, DeepSeek v3.2, MiniMax 2.1 ### Planos e Preços Plano Preço Créditos/mês Modelos Free $0 50 Open weight + Claude Sonnet 4.5 Pro $20/mês 1.000 Todos os premium (Auto, Sonnet 4.6, Opus) Pro+ $40/mês 2.000 Todos os premium Power $200/mês 10.000 Todos os premium Overages disponíveis nos planos pagos: **$0,04 por crédito adicional**. Créditos são fracionários — prompts simples podem consumir menos de 1 crédito (mínimo de 0,01). Para startups: a AWS oferece até 1 ano de Kiro Pro+ gratuito para startups elegíveis (até Series B). ## Tutorial ### Instalação do Kiro IDE O Kiro IDE é um aplicativo desktop disponível para macOS, Windows e Linux. **Pré-requisitos:** - Sistema operacional: macOS 10.15+, Windows 10+, ou Linux (Ubuntu 20.04+) - Conta AWS Builder ID, Google ou GitHub para login **Passos:** - Acesse [kiro.dev/downloads](https://kiro.dev/downloads) - Baixe o instalador para seu sistema operacional - Execute o instalador e siga as instruções - No primeiro launch, faça login com sua conta preferida Como o Kiro é baseado em Code OSS, suas extensões Open VSX e configurações do VS Code são compatíveis. Você pode importar settings existentes na primeira execução. ### Instalação do Kiro CLI O CLI é instalado via script único e funciona em macOS, Linux e Windows: ``` curl -fsSL https://cli.kiro.dev/install | bash ``` Após a instalação, autentique-se: ``` kiro login ``` Isso abre o navegador para autenticação via Builder ID ou social login. Uma vez autenticado, o CLI compartilha a mesma assinatura e créditos do IDE. **Verificar instalação:** ``` kiro --version ``` ### Primeiro Uso: Specs-Driven Workflow no IDE Vamos construir uma feature completa usando o workflow de specs. O exemplo: adicionar um sistema de reviews a um e-commerce. #### Passo 1: Do Prompt aos Requisitos No Kiro IDE, abra seu projeto e inicie uma nova spec. Digite um prompt simples: ``` Add a review system for products ``` O Kiro não começa a codar imediatamente. Em vez disso, ele gera **user stories** com critérios de aceitação em formato EARS (Easy Approach to Requirements Syntax): - Visualizar reviews de um produto - Criar uma nova review com rating - Filtrar reviews por estrelas - Ordenar por data ou relevância Cada user story inclui edge cases que você normalmente só descobriria durante a implementação. [IMAGEM: Screenshot mockup do Kiro gerando requisitos a partir de um prompt] #### Passo 2: Design Técnico Com os requisitos aprovados, o Kiro analisa seu codebase existente e gera um documento de design: - Diagramas de fluxo de dados - Interfaces TypeScript - Schemas de banco de dados - Endpoints de API - Hierarquia de componentes Você revisa, ajusta e aprova. Nada é implementado sem seu OK. #### Passo 3: Tarefas Sequenciadas O Kiro quebra o design em tarefas e sub-tarefas, sequenciadas por dependência: - Criar schema do banco (migration) - Implementar modelo Review - Criar endpoints da API (CRUD) - Escrever testes unitários - Implementar componentes de UI - Adicionar testes de integração - Implementar responsividade e acessibilidade Cada tarefa inclui detalhes como testes esperados, estados de loading e requisitos de acessibilidade. Você executa uma por uma, com indicador de progresso e histórico de diffs. #### Passo 4: Implementação Clique em “Execute” em cada tarefa. O Kiro implementa, e você revisa o diff antes de aceitar. Se algo não ficou como esperado, use o **checkpointing** para voltar a qualquer ponto anterior sem perder progresso. ### Primeiro Uso: Kiro CLI No terminal, navegue até seu projeto e inicie uma sessão: ``` cd ~/meu-projeto kiro chat ``` Você entra num loop interativo onde pode conversar com o agente sobre seu código: ``` > Analise a estrutura do projeto e sugira melhorias na organização dos módulos ``` Para execução headless (ideal para CI/CD): ``` kiro --print "Look at the latest CI failure logs, find the root cause, and apply a fix." ``` **Comandos essenciais do CLI:** Comando Descrição kiro chat Inicia sessão interativa kiro --print "prompt" Execução headless (sem interação) /model Selecionar modelo /save Exportar conversa /load Importar conversa /usage Ver uso do contexto /prompts Listar prompts disponíveis ctrl-j Input multi-linha ctrl-k Busca fuzzy ### Uso Intermediário: Custom Agents no CLI Custom agents são agentes especializados que você configura para tarefas específicas. Cada um tem seu próprio contexto, permissões de ferramentas e prompts otimizados. Exemplo: criar um agente especialista em backend: ``` kiro agent create backend-specialist ``` Configure o agente com: - Permissões de ferramentas pré-aprovadas - Arquivos de contexto específicos (schemas, padrões de API) - Prompts customizados Depois, invoque-o: ``` kiro chat --agent backend-specialist ``` O agente usa sua janela de contexto apenas no que importa — sem “context rot” de informações irrelevantes. **Execução paralela:** O CLI suporta múltiplas tarefas em paralelo, cada uma com seu próprio contexto e atualizações em tempo real. ### Configuração Avançada: Steering Files Steering files são arquivos markdown que fornecem conhecimento persistente sobre seu projeto. Em vez de explicar suas convenções em cada chat, você documenta uma vez: Crie `.kiro/steering/` no root do projeto: ``` # Convenções do Projeto ## Stack - Backend: Node.js + Express + TypeScript - Database: PostgreSQL com Prisma ORM - Frontend: React + Vite ## Padrões - Sempre usar async/await (nunca callbacks) - Validação de input com Zod em todos os endpoints - Testes com Vitest - Commits seguem Conventional Commits ## Estrutura - src/modules/{feature}/ — cada feature é um módulo isolado - src/shared/ — utilitários compartilhados - src/infra/ — configurações de infraestrutura ``` O Kiro lê esses arquivos automaticamente e segue suas convenções em toda interação — tanto no IDE quanto no CLI. **Steering global vs local:** - `.kiro/steering/` no projeto → aplicado a esse projeto - `~/.kiro/steering/` no home → aplicado a todos os projetos ## Deep Dive ### Powers: MCP Integrado e Sem Overload Powers são o sistema de extensibilidade do Kiro. Eles empacotam **MCP servers + steering files + hooks** em uma única instalação com um clique. A diferença crucial em relação a MCP servers tradicionais: powers são ativados **sob demanda**. O Kiro avalia quais powers são relevantes para sua conversa atual e carrega apenas esses, evitando o problema de context overload que acontece quando você tem dezenas de MCP servers configurados. **Powers disponíveis (exemplos):** Categoria Powers Design Figma (design-to-code), Miro Backend Supabase, Firebase, Neon, Aurora DSQL Deploy Netlify, Terraform, AWS CDK, ECS Express Observabilidade Datadog, Dynatrace, New Relic, CloudWatch Segurança Snyk, Aikido, Checkmarx, SonarQube Pagamentos Stripe, Checkout.com, StepPay AWS Amplify, Lambda, Step Functions, SAM, Bedrock AgentCore Utilidades Context7 (docs), Exa (web search), Zapier **Instalação de um power:** No IDE, basta clicar “Add to Kiro” na página de powers ou buscar dentro do editor. A configuração é automática. Powers são **gratuitos** — não há cobrança adicional por usá-los em nenhum plano. > **Nota:** Powers estão disponíveis atualmente apenas no IDE. Suporte no CLI está planejado para breve. ### Hooks: Automação Event-Driven Hooks são automações que disparam ações do agente quando eventos específicos ocorrem: - **On save** — quando você salva um arquivo - **On create** — quando um novo arquivo é criado - **On delete** — quando um arquivo é removido - **Manual trigger** — quando você dispara manualmente **Exemplos práticos:** ``` Evento: Salvar componente React Ação: Atualizar arquivo de teste correspondente Evento: Modificar endpoint de API Ação: Atualizar documentação do README Evento: Antes de commit Ação: Scan de segurança para credenciais vazadas ``` Hooks são commitados no Git, então toda a equipe se beneficia das mesmas validações e padrões de qualidade. ### Property-Based Testing (PBT) Uma das features mais inovadoras do Kiro: testes baseados em propriedades que verificam se seu código realmente implementa o que a spec define. **Como funciona:** - O Kiro extrai propriedades universais das suas specs EARS - Gera centenas/milhares de casos de teste aleatórios - Testa se o código se comporta conforme especificado - Usa “shrinking” para encontrar contra-exemplos mínimos **Diferença para testes unitários tradicionais:** Teste Unitário Property-Based Test ”User A adiciona Car #5 aos favoritos → Car #5 aparece na lista" "Para QUALQUER usuário e QUALQUER listing, QUANDO adicionar aos favoritos, o item DEVE aparecer na lista” Testa 1 cenário específico Testa centenas de combinações automaticamente Limitado pela imaginação do dev Encontra edge cases que você não pensou ### Integração AWS Nativa Como produto da AWS, o Kiro tem integração profunda com o ecossistema: - **Amazon Bedrock** — infraestrutura de modelos (múltiplos FMs) - **AWS IAM Identity Center** — SSO para equipes (SAML/SCIM) - **AWS Management Console** — gestão centralizada de assinaturas - **AWS GovCloud** — disponível para setores regulados (pricing ~20% maior) - **AWS Startups / Activate** — créditos para startups elegíveis Powers específicos da AWS cobrem Lambda, Step Functions, CDK, CloudFormation, Aurora, S3, ECS, Bedrock AgentCore, e mais. ### Kiro Web (Preview) Além do IDE e CLI, existe o **Kiro Web** — uma interface no navegador para usar o agente sem instalar nada. Disponível em preview para assinantes Pro, Pro+ e Power (apenas região US durante o preview). Créditos são compartilhados entre IDE, CLI e Web. ### Checkpointing O Kiro gera um checkpoint a cada mudança que o agente faz. Você pode voltar a qualquer ponto anterior da execução sem perder progresso — essencial quando uma implementação toma um rumo indesejado e você quer reverter sem gastar créditos refazendo trabalho. ### Multi-Root Workspaces Para projetos com múltiplos repositórios ou submodules, o Kiro suporta workspaces com múltiplas raízes. O agente navega entre todos os roots configurados, ideal para monorepos e arquiteturas de microserviços. ## Avaliação: Spider Chart Notas de 1 a 10 baseadas em benchmarks públicos + avaliação prática. Como o Kiro se apresenta em dois formatos (IDE e CLI), avaliamos ambos lado a lado. Eixo IDE CLI Justificativa Código (qualidade) 8/10 8/10 Claude Sonnet 4.5/4.6 e Opus via Bedrock — qualidade alta, mas sem benchmark público próprio (depende dos modelos Anthropic subjacentes) Contexto (compreensão) 8/10 8/10 Specs como contexto estruturado, steering files hierárquicos, powers (MCP integrado). CLI ganhou conversation compaction e reasoning preservation em v2.0 Autonomia 7/10 8/10 IDE prioriza execução estruturada (specs → revisão → implementação), reduzindo autonomia livre. CLI com headless mode e subagents (v1.23+) é mais autônomo para CI/CD Velocidade 7/10 7/10 Overhead de spec generation antes de codar. Após specs aprovadas, execução rápida. Auto mode otimiza roteamento de modelos para balancear latência/qualidade Custo-benefício 8/10 8/10 Pro $20/mês com 1.000 créditos fracionários (mínimo 0,01). Free tier limitado (50 créditos). Startups elegíveis ganham até 1 ano de Pro+ gratuito Especialização (skills) 9/10 9/10 Steering files globais e por projeto, powers com ativação sob demanda, hooks commitáveis. CLI adicionou skills com progressive context loading (v1.24) Multi-agente 6/10 7/10 IDE tem parallel tasks em specs mas sem orquestração visual multi-agente. CLI tem subagents nativos com live progress tracking e Plan agent (v1.23+) Ecossistema 8/10 7/10 IDE tem powers (MCP + steering + hooks em um clique), integração AWS nativa, Open VSX. CLI ainda sem powers (planejado), mas tem MCP registry e custom agents **Média geral: IDE 7.6/10 · CLI 7.8/10** > **Metodologia**: Código baseia-se em SWE-bench Verified + Aider Polyglot (modelos subjacentes). Autonomia em Terminal-Bench + avaliação prática do headless mode. Demais eixos são avaliação prática comparativa com concorrentes diretos (Cursor, Claude Code, Copilot). Escala: 1-4 (fraco), 5-6 (adequado), 7-8 (bom), 9-10 (excelente/líder). Dados verificados em maio/2026. [IMAGEM: Spider chart comparativo Kiro IDE vs Kiro CLI com 8 eixos] ## Prós e Contras ### Prós - **Specs-driven é transformador** — a abordagem de gerar requisitos → design → tarefas antes de codar reduz drasticamente retrabalho e “AI slop”. Você sabe exatamente o que está sendo construído e por quê. - **Powers eliminam o caos de MCP** — ativação sob demanda resolve o problema de context overload. Um clique instala tudo (MCP + steering + hooks) de forma coesa. - **IDE + CLI com mesma assinatura** — flexibilidade real. Use o IDE para features complexas com specs, e o CLI para automação e CI/CD. Sem custo extra. - **Integração AWS profunda** — se sua stack é AWS, nenhum outro agente de codificação oferece integração tão nativa. Powers para Lambda, CDK, Aurora, Step Functions são first-party. - **Property-based testing** — verificação de que o código implementa a spec é algo que nenhum concorrente oferece nativamente. - **Hooks para consistência de equipe** — automações commitadas no Git garantem que todo o time segue os mesmos padrões sem esforço manual. ### Contras - **Tier gratuito limitado** — 50 créditos/mês é pouco para uso real. Na prática, você precisa de um plano pago para trabalhar seriamente. - **Powers apenas no IDE (por enquanto)** — se você prefere o CLI, ainda não tem acesso ao ecossistema de powers. Suporte planejado, mas sem data confirmada. - **Vendor lock-in AWS** — embora funcione com qualquer projeto, a integração mais profunda é com serviços AWS. Se sua stack é GCP ou Azure, você perde parte do valor. - **Specs adicionam overhead** — para tarefas simples (fix rápido, refactor pequeno), o workflow de specs pode ser mais lento que um prompt direto. O Kiro oferece “vibe mode” para esses casos, mas o diferencial principal fica subutilizado. - **Ecossistema de powers ainda crescendo** — comparado ao marketplace de extensões do VS Code ou plugins do JetBrains, o catálogo de powers ainda é jovem. Muitos são first-party AWS. - **Créditos não acumulam** — créditos não utilizados no mês são perdidos. Se você tem meses de uso intenso alternados com meses leves, o modelo pode não ser ideal. ### Veredicto **Kiro é ideal para:** - Equipes que trabalham com AWS e querem integração nativa - Desenvolvedores que valorizam planejamento antes de implementação - Projetos de médio/grande porte onde specs reduzem retrabalho - Times que precisam de consistência (hooks + steering compartilhados) - Workflows que combinam IDE (features complexas) + CLI (automação) **Kiro NÃO é ideal para:** - Quem busca apenas autocomplete rápido (Copilot é mais direto) - Projetos pequenos/pessoais onde specs são overhead desnecessário - Desenvolvedores com stack 100% GCP/Azure sem serviços AWS - Quem precisa de tier gratuito robusto para uso diário --- ## Próximos Passos Se você quer implementar specs-driven development na sua equipe ou precisa de ajuda configurando powers e hooks para seu contexto específico, a [ft.ia.br](https://ft.ia.br) oferece consultoria especializada em agentes de codificação — do setup inicial à otimização de workflows complexos. Para explorar como o Kiro se compara a outros agentes, confira nossos comparativos: - [LINK_INTERNO: kiro-ide-vs-kiro-cli] — IDE vs CLI: quando usar cada um - [LINK_INTERNO: copilot-vs-kiro-ide] — GitHub Copilot vs Kiro IDE - [LINK_INTERNO: claude-code-vs-kiro-cli] — Claude Code vs Kiro CLI --- *Versão testada: Kiro IDE 0.7+ / Kiro CLI (GA, novembro 2025). Dados de preços verificados em maio de 2026.* -->