O Que É Kiro?
Kiro é um ambiente de codificação baixável criado pela Amazon Web Services que leva o desenvolvimento assistido por IA em uma direção que a maioria das ferramentas dessa categoria não tentou.
Enquanto a maioria das ferramentas de codificação por IA permite que você digite um prompt e receba o código imediatamente, Kiro executa primeiro um processo de planejamento: ele lê o contexto do seu projeto, escreve um documento de requisitos, gera um design técnico, divide tudo em uma lista numerada de tarefas e só então começa a escrever código.
Disponível como IDE, ferramenta de linha de comando, interface web (atualmente em preview para usuários pagos) e aplicativo mobile (acesso antecipado no iOS), o Kiro se posiciona como a ferramenta para desenvolvedores que querem uma saída estruturada e mantível, em vez de código rápido que terão de desfazer uma semana depois.
Para Quem é o Kiro?
- Desenvolvedores que foram prejudicados por código gerado por IA que quebra depois do primeiro dia. O fluxo de trabalho por spec do Kiro força o planejamento antes da implementação, o que significa que o código que ele escreve é rastreável até requisitos documentados, e não montado no chute.
- Equipes migrando para fluxos de trabalho agentic. Os Agent Hooks do Kiro permitem automatizar tarefas recorrentes, como escrever testes ou gerar documentação, acionadas automaticamente sempre que um arquivo qualificado muda, sem necessidade de prompts repetidos.
- Desenvolvedores do ecossistema AWS. O Kiro é construído sobre a infraestrutura da AWS, processa dados em regiões AWS dentro da sua geografia e se conecta naturalmente aos serviços AWS. Se seu stack já é pesado em AWS, o Kiro se encaixa sem sobrecarga de configuração.
- Usuários do VS Code que querem IA indo além do autocomplete. O IDE Kiro é construído sobre a mesma base do VS Code. Seus atalhos de teclado, configurações e extensões são transferidos durante a integração em minutos.
Prós e Contras do Kiro
- Fluxo de trabalho por spec planeja antes de escrever qualquer código
- Agent Hooks automatizam tarefas com base em eventos de arquivo
- Extensões e configurações do VS Code são importadas sem problemas
- O modo Autopilot constrói sem solicitações constantes de aprovação
- Os documentos de steering fornecem ao Kiro o contexto do seu projeto
- Suporta múltiplos modelos de ponta, incluindo Opus 4.8
- Integração com servidor MCP conecta ferramentas externas nativamente
- Exige download; não é acessível pelo navegador na camada gratuita
- 50 créditos gratuitos acabam mais rápido do que o esperado
- Houve um timeout uma vez durante a fase de refinamento dos requisitos
Distribuição de Avaliação
As notas mais fortes do Kiro são em recursos e funcionalidade, onde seu fluxo de trabalho orientado por spec, agent hooks e execução em autopilot o colocam à frente de todas as outras ferramentas de codificação por IA abordadas aqui. Ele perde pontos em acessibilidade e no modelo de créditos, ambos exigindo atenção honesta antes de se comprometer com um fluxo de trabalho.
| Recurso | Nota (de 10) | Por Que a Nota |
|---|---|---|
| Facilidade de Uso | 7.0 | Familiar para qualquer usuário do VS Code; o requisito de download e a natureza voltada apenas para desenvolvedores o tornam fora do alcance de usuários não técnicos |
| Recursos e Funcionalidade | 9.5 | Fluxo de trabalho por spec, agent hooks, autopilot, integração MCP, documentos de steering: o conjunto de recursos mais completo entre todas as ferramentas de IA para codificação analisadas |
| Design e Personalização | 7.0 | Temas escuros e claros do IDE; forte controle sobre a estrutura do código gerado por meio da edição de spec e dos documentos de steering |
| Custo-Benefício | 6.5 | Os 50 créditos da camada gratuita caíram para 4.28 consumidos apenas durante o planejamento, antes de uma única linha de código da aplicação ser escrita |
| Desempenho e Confiabilidade | 7.5 | A saída do planejamento foi detalhada e específica; um timeout confirmado em 7 minutos e 24 segundos durante o refinamento de requisitos |
| Geral | 8.2 | O fluxo de trabalho por spec do Kiro é a abordagem mais estruturada para desenvolvimento assistido por IA analisada até agora. A nota reflete essa diferenciação genuína, limitada pela camada gratuita restrita e pela única falha de confiabilidade registrada durante o teste. |
Recursos do Kiro
- Fluxo de trabalho orientado por spec: requisitos, design, tarefas, código
- Agent Hooks automatizam tarefas com base em eventos de arquivo
- Documentos de steering fornecem contexto do projeto ao agente
- Modo Autopilot executa tarefas sem aprovação passo a passo
- Suporte a servidor MCP para integração com ferramentas externas
- Importação de configuração do VS Code na primeira inicialização
- Suporte a múltiplos modelos, incluindo Claude Opus 4.8
Minha Análise Honesta do Kiro: O Que Encontrei Depois de Testá-lo
A maioria dos construtores de aplicativos com IA cai em uma de duas categorias:
- ferramentas visuais que geram uma interface a partir de uma descrição
- e ferramentas baseadas em chat que escrevem código diretamente em resposta a um prompt
O Kiro não se encaixa em nenhuma das duas, e é por isso que analisá-lo exige uma abordagem diferente.
Kiro é um IDE agentic. Você não arrasta componentes para uma tela, e não recebe uma prévia ao vivo depois de 30 segundos. O que você obtém é um ambiente de desenvolvimento local que planeja uma build antes de iniciá-la, gerando requisitos, um documento de design e uma lista estruturada de tarefas que o agente então executa passo a passo.
O aplicativo que ele produz é um projeto real na sua máquina, em arquivos que você possui, usando um stack que você define.
Para testar se esse processo realmente funciona, eu construí uma plataforma de gestão de propriedades do zero dentro do Kiro.
O prompt cobria autenticação de proprietários e inquilinos, gerenciamento de propriedades e unidades, controle de contratos, solicitações de manutenção com atualização de status, integração de pagamentos Stripe, notificações por e-mail e um painel do proprietário com relatórios. Esse é o mesmo prompt usado para avaliar Rork, Figma Make, Uizard e Retool, o que torna possível comparar como cada ferramenta lida com complexidade real, em vez de um exemplo simples.
A pergunta que esta análise buscou responder era específica: O fluxo de trabalho spec-first do Kiro produz uma saída melhor estruturada e mais mantível do que ferramentas que vão direto para o código?
Aqui está o que encontrei.
Colocando o Kiro para Rodar: Um Download, Não uma Aba do Navegador
Todas as outras ferramentas de criação de apps com IA avaliadas junto com esta comparação vivem no navegador. O Kiro não. Começar significa ir para kiro.dev, clicar em Downloads, selecionar seu sistema operacional e instalar o aplicativo na sua máquina.
Eu estava usando Pop OS, uma distribuição Linux baseada em Debian, então selecionei o pacote Debian (.deb) no menu suspenso. O site também oferece um pacote Universal (.tar.gz) para outras instalações Linux. Instaladores para Windows e macOS estão disponíveis na mesma página de downloads.
O que isso significa na prática:
- A primeira sessão exige instalação local, não uma aba do navegador
- Sem acesso apenas pela internet na camada gratuita (a interface web está disponível apenas em planos pagos, atualmente em preview)
- Para desenvolvedores, isso não é um problema
- Para qualquer pessoa avaliando o Kiro em comparação com construtores baseados em navegador, considere isso no seu tempo de configuração
A instalação em si foi simples. Não houve etapas de configuração, nem dependências para resolver manualmente, e o aplicativo foi iniciado de forma limpa após a instalação padrão do pacote.
O Login Acontece no Seu Navegador, Não Dentro do App
Quando o IDE abre pela primeira vez, ele não pede para você fazer login dentro da janela do aplicativo. Ele redireciona você para uma página no navegador para tratar a autenticação por lá.
A tela de login apresenta quatro opções:
| Método de Login | Para Quem Serve |
|---|---|
| Desenvolvedores individuais e freelancers | |
| GitHub | O ajuste mais natural para desenvolvedores com contas já existentes |
| AWS Builder ID | Desenvolvedores já dentro do ecossistema AWS |
| Sua Organização | Equipes corporativas usando SSO |
A opção GitHub é bem escolhida para o público-alvo. A maioria dos desenvolvedores já tem uma conta no GitHub e pode se autenticar sem criar uma nova credencial.
Algumas coisas importantes para saber antes de se inscrever:
- Entrar via Google ou AWS Builder ID (não AWS Identity Center) concede um crédito de $20 aplicado ao seu primeiro upgrade para um plano pago. Esse é um benefício único que vale a pena conhecer antes de escolher seu método de login.
- Entrar via “Sua Organização” direciona por SSO corporativo e é a porta de entrada para equipes que precisam de gerenciamento centralizado de identidade.
- Ao fazer login, você concorda com o AWS Customer Agreement, Service Terms, Privacy Notice e AWS Intellectual Property License. Como o Kiro é um produto AWS, seus dados são processados em regiões AWS dentro da sua geografia.
Onboarding: Três Etapas de Configuração que Levam Menos de Dois Minutos
Após o login, o Kiro executa uma sequência curta de configuração antes de abrir o IDE principal. As etapas são:
Etapa 1: Escolha seu tema. Kiro Dark ou Kiro Light. Ambos mostram uma prévia ao vivo do realce de sintaxe antes de você confirmar.
Etapa 2: Configure a integração com o shell. Isso permite abrir qualquer projeto a partir do seu terminal usando o comando kiro . Você pode pular isso e configurar depois.
Etapa 3: Importar do VS Code. O Kiro traz suas extensões existentes do VS Code (qualquer uma disponível no Open VSX), configurações e atalhos de teclado. As extensões carregam em segundo plano enquanto o onboarding continua, então não há espera em uma tela de carregamento.
A importação do VS Code é a parte mais útil na prática dessa sequência. Se você passou anos personalizando um ambiente do VS Code, a transição não exige começar do zero. A importação funcionou sem problemas na minha sessão.
O que o onboarding não inclui é qualquer introdução aos recursos centrais do Kiro. Você não recebe um guia sobre o que são Specs, Agent Hooks ou Steering Documents. Você chega à tela principal e descobre isso por conta própria. Isso é aceitável para um público de desenvolvedores experientes, mas significa que sua primeira sessão com os recursos mais distintos da ferramenta envolve exploração autodirigida.
Dentro do IDE: Os Quatro Painéis que Tornam o Kiro Diferente
A aparência do IDE Kiro lembra o VS Code porque ele foi construído sobre a mesma base. O explorador de arquivos, as abas do editor, o terminal, a barra de busca e a barra de menus funcionam exatamente como esperado.
O que diferencia o Kiro de uma instalação padrão do VS Code é o painel esquerdo dedicado, que contém quatro seções que não existem em nenhuma extensão do VS Code:
| Seção do Painel | O Que Ela Faz |
|---|---|
| Specs | Cria e gerencia documentos de especificação (requisitos, design, tarefas) para builds complexas |
| Agent Hooks | Define tarefas automatizadas que disparam com eventos do sistema de arquivos |
| Agent Steering and Skills | Armazena documentos de orientação que moldam como o agente se comporta em todas as sessões |
| MCP Servers | Conecta ferramentas externas e fontes de dados ao agente do Kiro |
O lado direito do IDE abriga o painel de chat. É aqui que você interage com o Kiro e onde vê o consumo de créditos em tempo real. “Est.
Credits Used: 0.1, Elapsed time: 57s” é atualizado após cada ação do agente, o que significa que você sempre sabe quanto cada tarefa está custando.
Na parte inferior da barra de entrada do chat, dois controles determinam como o Kiro se comporta em cada tarefa:
- Seletor de modelo: Escolha Auto (o Kiro seleciona o modelo mais eficiente em custo para cada solicitação) ou selecione um modelo específico, como Claude Sonnet 4.6 ou Claude Opus 4.8.
- Alternância de Autopilot: Com o Autopilot ativado, o Kiro escreve e edita arquivos sem aguardar sua aprovação em cada etapa. Com ele desativado, o Kiro pausa antes de cada comando e pede que você Trust, Reject ou Run manualmente.
Para o teste da plataforma de gestão de propriedades, mantive o Autopilot ativado durante o planejamento e usei aprovação manual durante a execução das tarefas para avaliar cada etapa de forma independente.
Veredito: O layout do IDE é confortável em minutos para qualquer usuário do VS Code. As quatro seções do painel esquerdo são onde está o valor do Kiro, e entender cada uma antes da sua primeira sessão determina o quanto você tira proveito da ferramenta.
Documentos de Steering: Dando Contexto ao Kiro Antes do Seu Primeiro Prompt
A primeira coisa a fazer dentro de um novo projeto no Kiro não é começar uma build. É gerar documentos de steering.
Cliquei em “Generate Steering Docs” no painel do Kiro antes de enviar qualquer prompt. O Kiro analisou o diretório de projeto vazio e criou três arquivos markdown dentro de .kiro/steering/:
| Arquivo | Conteúdo |
|---|---|
| product.md | Nome do produto, descrição, conceitos centrais do domínio e principais metas |
| structure.md | Layout esperado das pastas e convenções de organização de arquivos |
| tech.md | Stack de tecnologia esperada, comandos comuns e convenções de código |
Para um projeto completamente vazio, o Kiro inferiu padrões sensatos: React com TypeScript, rotas de API do Next.js, PostgreSQL, Prisma, Tailwind CSS e autenticação baseada em JWT. Ele sinalizou tanto tech.md quanto structure.md como placeholders que deveriam ser atualizados assim que o stack real fosse confirmado por meio da estruturação inicial.
Isso importa porque toda ação subsequente do agente lê esses arquivos antes de fazer qualquer coisa. Depois que você estrutura o projeto e o stack real é confirmado, atualizar tech.md faz o Kiro aplicar essas convenções automaticamente em todas as tarefas futuras.
Você também pode adicionar seus próprios arquivos de steering para padrões de API, convenções de nomenclatura, regras de deploy ou qualquer outra restrição que queira que o agente trate como fixa.
Vibe Mode vs Spec Mode: A Decisão Que Molda Toda a Build
Quando você abre o chat para uma nova build, o Kiro mostra dois modos antes de você digitar qualquer coisa:
Vibe mode permite que você converse primeiro e construa enquanto avança. Sem documentos de planejamento, sem saída estruturada. Melhor para experimentos rápidos, exploração em estágio inicial ou tarefas em que os requisitos ainda estão sendo definidos.
Spec mode executa uma sequência de planejamento antes de qualquer código ser escrito. O Kiro gera requisitos, um documento de design técnico e uma lista de tarefas. Somente depois que os três forem revisados e aprovados ele começa a escrever código. Melhor para trabalho de nível de produção em que a manutenibilidade importa.
Escolhi o Spec mode para a plataforma de gestão de propriedades. Depois que enviei o prompt, o Kiro fez duas perguntas de acompanhamento antes de gerar qualquer coisa:
- “What do you want to start with?” (Requirements, marcado como recomendado, ou Technical Design)
- “Is this a new feature or a bugfix?” (Build a Feature, recomendado, ou Fix a Bug)
Essas perguntas determinam a estrutura de tudo o que vem depois. Escolher “Requirements” significa que o Kiro escreve user stories e critérios de aceitação antes de tocar na arquitetura.
Essa sequência produz artefatos de planejamento fundamentalmente diferentes de começar com um design técnico e derivar requisitos depois.
O Fluxo de Trabalho Spec: Requisitos, Design e uma Lista de Tarefas Antes de Qualquer Código
Esta é a seção que faz valer a pena avaliar o Kiro seriamente.
Depois de selecionar “Requirements” e “Build a Feature”, o Kiro criou um arquivo requirements.md dentro de .kiro/specs/property-management-platform/. O documento apareceu imediatamente no editor. Eu podia lê-lo enquanto era escrito. O conteúdo incluía:
O glossário: 12 termos de domínio definidos com precisão, incluindo Auth_Service, Property_Service, Lease_Service, Payment_Service, Maintenance_Service, Notification_Service e Dashboard_Service, com cada um mapeado para um subsistema planejado específico.
A descrição da plataforma: Tanto os papéis de Landlord quanto de Tenant foram documentados, junto com a stack de tecnologia confirmada: Next.js, TypeScript, PostgreSQL, Prisma, Tailwind CSS, Stripe e Docker.
Após gerar o documento inicial, o Kiro executou uma etapa automática de refinamento. Ele analisou todos os 12 requisitos, despachou subagentes detailer em paralelo para cada um deles e atualizou requirements.md com critérios de aceitação completos para cada requisito. O painel acompanhou isso em tempo real: “Refining requirements 12/12.”
Depois que os requisitos ficaram prontos, cliquei em “Continue” e selecionei “Generate Design and Tasks”. O Kiro produziu design.md e tasks.md juntos. A divisão de tarefas foi a saída mais marcante da sessão:
11 grupos de tarefas, 43 subtarefas, em ordem de implementação:
- Estruturação do projeto e infraestrutura
- Autenticação (JWT, blacklist, middleware, páginas)
- Gerenciamento de propriedades e unidades
- Gerenciamento de inquilinos
- Gerenciamento de contratos, uploads de documentos e cron job
- Solicitações de manutenção
- Pagamentos Stripe e webhook
- Notificações por e-mail
- Painel do proprietário e relatórios
- Componentes de UI compartilhados e layouts
- Endurecimento da API (rate limiting, CORS, health check, validação de ambiente)
Toda subtarefa incluía comandos exatos, caminhos de arquivo e referências rastreáveis aos requisitos. A tarefa 1.1, por exemplo, fazia referência direta aos Requisitos R12 (Docker) e R10 (REST API) na sua descrição. A conexão entre planejamento e execução era explícita e verificável durante todo o processo.
Rork, por comparação, pula toda essa etapa e vai direto para gerar uma interface do usuário a partir do prompt. A diferença na qualidade da saída é visível: a lista de tarefas do Kiro é específica o suficiente para ser entregue a um desenvolvedor humano, que entenderia exatamente o que precisa ser construído e em que ordem.
Execução das Tarefas: O Que o Kiro Realmente Construiu
Com a lista de tarefas aprovada, cliquei em “Start task” na Tarefa 1.1: Inicializar projeto Next.js 14 com TypeScript, Tailwind CSS e ESLint.
O Kiro atualizou o status da tarefa para “in progress” em tasks.md, depois delegou a execução ao seu subagente spec-task-execution. O agente verificou o workspace primeiro, confirmou que apenas a pasta .kiro spec existia, sem nenhum projeto Next.js ainda, e prosseguiu para estruturar o projeto.
Dentro do primeiro ciclo de execução, a árvore de arquivos foi preenchida com:
- package.json com dependências de Next.js, React 19.2.4, TypeScript e Tailwind listadas
- tsconfig.json, eslint.config.mjs, next.config.ts
- estrutura de diretórios src/ e public/
- AGENTS.md e CLAUDE.md, gerados pelo Kiro como arquivos de orientação do agente para o projeto
- README.md
O arquivo CLAUDE.md vale destaque: o Kiro é um produto AWS, mas roda sobre os modelos Claude da Anthropic. O arquivo CLAUDE.md é como agentes movidos por Claude armazenam orientações comportamentais específicas do projeto. Sua presença no scaffold gerado reflete o modelo subjacente, mesmo dentro do contexto de infraestrutura da AWS.
No topo da visualização da lista de tarefas, um botão “Run all tasks” permitiria ao Kiro executar todas as 43 subtarefas em sequência com o Autopilot ativado.
Executei as tarefas individualmente para avaliar cada etapa. Para um projeto real em que você confia no plano aprovado, executar todas as tarefas automaticamente e revisar a saída ao final de cada grupo é um fluxo de trabalho razoável e eficiente em termos de tempo.
Cada arquivo que o Kiro gerou durante a execução era um arquivo real no meu diretório de projeto local, de minha propriedade e editável desde o primeiro segundo. Essa é uma distinção importante em relação a construtores baseados em navegador, como Figma Make ou Uizard, onde a saída é um ativo de design ou um aplicativo hospedado que você não controla localmente.
O Timeout no Minuto Sete: O Que Isso Significa para a Confiabilidade
Quero ser direto sobre isso porque aconteceu durante a parte mais importante do teste.
Depois que o Kiro refinou todos os 12 requisitos e aceitou as edições em requirements.md, o agente sofreu timeout. A mensagem de erro no painel de chat dizia:
“The request timed out. Please try again. (Conversation ID: 29d25548-c3ce-414c-8f57-702124c7fec6). Elapsed time: 7m 24s.”
Isso aconteceu na transição entre a fase de requisitos e a geração do design. O trabalho concluído antes do timeout foi salvo. Nenhum requisito foi perdido.
Depois de reconhecer o erro, cliquei em “Continue” e selecionei “Generate Design and Tasks”. O Kiro se recuperou sem repetir a etapa de requisitos, produziu ambos os documentos corretamente e continuou normalmente pelo resto da sessão.
Contexto que importa aqui:
- O timeout aconteceu em um prompt complexo cobrindo 12 áreas distintas de requisitos com refinamento paralelo em execução. Tarefas mais simples provavelmente não levarão tanto tempo.
- O Kiro está atualmente em preview, e a confiabilidade no limite superior de tarefas complexas é uma característica conhecida de ferramentas nessa fase.
- A recuperação foi limpa. O sistema de checkpoint preservou todo o trabalho concluído e a próxima etapa foi executada imediatamente.
Dito isso, sete minutos depois de entrar no recurso mais distintivo da ferramenta, encontrar um timeout é uma falha real de experiência. Se você estiver trabalhando com prazo apertado, uma ferramenta que para e exige uma nova tentativa é frustrante, mesmo quando a recuperação é tranquila.
Agent Hooks: Automação Que Funciona Sem Ser Pedida
Agent Hooks não aparecem em nenhuma outra ferramenta de codificação por IA avaliada junto com esta comparação, e merecem atenção específica porque representam uma maneira diferente de pensar sobre assistência por IA.
Um Hook é uma tarefa que roda automaticamente quando um evento do sistema de arquivos ocorre. Você descreve o comportamento em linguagem simples, o Kiro o converte em um listener de eventos e, a partir daí, o comportamento roda em segundo plano sempre que a condição de disparo é atendida. Sem comando para executar, sem lembrete para configurar.
Exemplos do que os Hooks podem fazer:
- Ao salvar arquivo: gerar testes básicos para qualquer componente que ainda não tenha um arquivo de teste
- Ao salvar arquivo: executar limpeza ou verificação de formatação do código
- Ao criar arquivo: gerar documentação automaticamente para novas funções
- Ao alterar constantes de string: atualizar arquivos de localização sem ação manual
O hook é armazenado dentro de .kiro/hooks/ como um arquivo editável. Se você quiser ajustar a condição de disparo ou a instrução, edita o arquivo diretamente. A configuração é transparente e controlável por versão junto com o resto do seu projeto.
O exemplo de teste ao salvar é o mais prático de imediato: desenvolvedores constantemente deixam para escrever testes no fim do sprint, e um hook que adiciona discretamente testes básicos sempre que um componente é salvo remove essa decisão por completo. Os testes aparecem na árvore de arquivos após o próximo salvamento, sem nenhuma ação da sua parte.
Consumo de Créditos: O Que a Camada Gratuita Realmente Oferece
O modelo de créditos é a área em que o Kiro exige a leitura mais cuidadosa antes de se comprometer com um fluxo de trabalho.
A camada gratuita oferece 50 créditos. Aqui está o que uma única sessão de spec de plataforma de gestão de propriedades consumiu: 4.28 créditos só para o planejamento, cobrindo requisitos, o documento de design e a lista completa de 43 tarefas, antes de uma única linha de código da aplicação ser escrita.
A essa taxa de consumo:
| Cenário | Cobertura Estimada da Camada Gratuita |
|---|---|
| Sessões apenas de planejamento (sem execução de código) | Aproximadamente 11 sessões |
| Planejamento mais execução parcial de tarefas | 3 a 5 sessões |
| Spec completo até a execução em um projeto complexo | 1 projeto completo no máximo |
Principais mecânicas para entender antes de se inscrever:
- Os créditos não acumulam. O que sobrar no fim do seu mês de cobrança desaparece.
- O faturamento por excesso está desativado por padrão em todos os planos pagos. Você precisa ativá-lo em Settings antes de atingir o limite, ou o Kiro para de funcionar no meio da tarefa.
- A escolha do modelo afeta a taxa de consumo. Executar a mesma tarefa via Claude Sonnet 4.6 custa 1.3 vezes mais créditos do que executá-la no modo Auto. Modelos Opus custam mais ainda.
- Usuários da camada gratuita recebem Claude Sonnet 4.5 e um conjunto de modelos de peso aberto, incluindo Qwen3 Coder Next, DeepSeek v3.2 e MiniMax 2.1. Usuários da camada paga desbloqueiam Claude Sonnet 4.6, Claude Opus 4.6 e Claude Opus 4.8.
- O uso de créditos é visível no painel de chat após cada ação do agente e é atualizado no dashboard de assinatura a cada cinco minutos.
O rastreador de crédito em tempo real (“Est. Credits Used: 0.1, Elapsed time: 57s” após cada tarefa) é um recurso de transparência que nenhuma ferramenta comparável oferece atualmente. Você sabe exatamente quanto cada tarefa custa enquanto ela é executada, o que ajuda a decidir entre usar o modo Auto ou um modelo específico para uma determinada tarefa.
Preço e Planos do Kiro
O Kiro funciona em um modelo baseado em créditos com cinco níveis, desde um plano gratuito com alocação mensal fixa até um plano de alta capacidade projetado para uso profissional diário.
Todos os planos pagos incluem acesso a modelos premium, a opção de habilitar overage por uso, e o conjunto completo de recursos do Kiro, incluindo specs, hooks, autopilot e acesso via CLI.
O que saber antes de escolher um plano:
- O plano gratuito fornece uma alocação mensal fixa de créditos sem necessidade de cartão de crédito. Ele não expira, mas uma única sessão spec complexa fará uma diferença visível nele.
- Na primeira vez em que você fizer upgrade do gratuito para qualquer plano pago usando Google ou AWS Builder ID (não AWS Identity Center), você recebe um crédito de $20 aplicado ao custo da sua assinatura. Esse benefício vale uma única vez.
- O Kiro cobra no primeiro dia de cada mês-calendário. Fazer upgrade no meio do mês significa pagar uma taxa proporcional, mas acessar imediatamente o limite total de créditos do seu novo plano.
- O faturamento por excedente está disponível em todos os planos pagos por uma taxa fixa por crédito adicional, mas vem desativado por padrão. Ative-o em Settings antes de atingir o limite, ou o Kiro pausa seu trabalho quando os créditos acabarem.
- Créditos não utilizados não são transferidos para o mês seguinte.
- Cada desenvolvedor precisa da própria assinatura. Não há atualmente opção de seat compartilhado para equipe. Recursos de cobrança em equipe estão listados como em breve.
- A política padrão do Kiro é sem reembolsos para cancelamentos no meio do mês. O acesso continua até o final do ciclo de cobrança. Reembolsos são considerados caso a caso apenas para erros de faturamento.
- Cartões de crédito são o único método de pagamento aceito.
- O preço do GovCloud (US) é aproximadamente 20% mais alto do que o preço padrão, e a camada gratuita não está disponível nesse ambiente. O acesso ao GovCloud exige um plano pago e autenticação corporativa via AWS IAM Identity Center.
- A interface web está atualmente em preview e disponível apenas para usuários pagos. Os créditos são consumidos na mesma taxa, esteja você trabalhando no IDE, CLI ou web.
Qual plano atende a qual tipo de usuário: O plano gratuito é suficiente para realizar uma avaliação real. Para desenvolvimento ativo em projetos reais, um plano pago é necessário para evitar acabar no meio da sessão. Os planos de nível mais alto fazem sentido para desenvolvedores que executam várias sessões spec completas por semana ou trabalham em vários projetos complexos ao mesmo tempo.
Alternativas ao Kiro
O concorrente mais direto do Kiro é Cursor, o editor de código com IA que também é construído sobre a base do VS Code e mira desenvolvedores que querem IA profundamente integrada ao seu ambiente de desenvolvimento.
A diferença central é a filosofia de fluxo de trabalho. O Cursor foi criado para acelerar o que você já está fazendo: você escreve código, e o Cursor ajuda.
O Kiro foi criado para assumir primeiro a fase de planejamento: o agente define o que precisa ser construído antes de escrever qualquer coisa.
Se sua principal frustração é a troca lenta de contexto entre um chat de IA e seu editor, o Cursor resolve isso de forma mais direta. Se sua frustração é código gerado por IA que carece de estrutura ou é difícil de manter, o fluxo de trabalho spec do Kiro é a resposta mais relevante.
| Recurso | Kiro | Cursor |
|---|---|---|
| Facilidade de Uso | Familiar para usuários do VS Code; o fluxo de trabalho por spec adiciona uma curva de aprendizado | Familiar para usuários do VS Code; menor atrito no onboarding |
| Melhor Para | Builds estruturadas, orientadas por spec, para projetos de produção | Edição assistida por IA rápida e tarefas de agente dentro de bases de código existentes |
| Backend e Dados | Constrói projetos locais reais com controle total de stack | Edita e estende arquivos de projetos existentes com controle total de stack |
| Flexibilidade de Design | Sem construtor visual; gera código real, de propriedade local | Sem construtor visual; gera código real, de propriedade local |
| Modelo de Preço | Baseado em créditos; 50 créditos gratuitos; todo uso desconta de uma alocação mensal de créditos | Baseado em créditos desde junho de 2025; o modo Auto é ilimitado; a seleção de modelos premium desconta de um pool mensal de créditos |
Veredito Final: O Kiro Vale a Pena?
O Kiro se destaca por colocar o planejamento antes da codificação. Seu fluxo de trabalho de especificação, documentos de steering e divisão de tarefas produzem uma base de código mais estruturada e mantível do que ferramentas de IA que vão direto para a implementação. O recurso Agent Hooks é outro destaque, permitindo automações de fluxo de trabalho que continuam rodando além de um único prompt.
As desvantagens são a curva de aprendizado e o preço. A camada gratuita é limitada demais para projetos grandes, e os desenvolvedores precisam se sentir confortáveis trabalhando em um IDE. Durante os testes, também encontrei um timeout, embora o Kiro tenha se recuperado sem perder progresso.
Se você é um desenvolvedor construindo software de produção, o Kiro é uma das ferramentas de codificação por IA mais fortes disponíveis hoje. Se você está procurando um construtor de aplicativos no-code simples, porém, ele não é a opção certa.
