A Era da Inteligência
Vale pagar caro por IA? Quanto um dev deveria investir em ferramentas
No capítulo anterior de A Era da Inteligência, eu defendi que a unidade econômica correta para avaliar IA não é preço do token nem salário isoladamente. É custo por resultado válido.
A mesma lógica vale para uma pergunta muito mais pessoal:
quanto um desenvolvedor deveria gastar por mês com IA?
É fácil responder olhando uma tabela de preços. Também é fácil cair no extremo oposto e dizer que “qualquer plano caro se paga porque produtividade não tem preço”.
As duas respostas são ruins.
Em setembro de 2026, um dev pode montar uma pilha que vai de quase zero a várias centenas de dólares por mês sem esforço. Há planos individuais de US$ 10 e US$ 20, tiers de US$ 39 e US$ 100 e opções de alto uso que chegam a US$ 200. Além disso, existem API, créditos adicionais, ferramentas especializadas e cobrança por uso.
O problema não é faltar opção.
É saber qual opção compra capacidade real e qual apenas compra redundância.
Minha regra seria esta:
não defina seu orçamento de IA pelo número de ferramentas que você consegue assinar. Defina pelo gargalo que vale a pena remover.
Esse artigo é uma tentativa de transformar essa regra em um método prático.
O mercado já criou uma escada de US$ 10 a US$ 200 por mês
Antes de discutir quanto vale pagar, é útil olhar como o mercado se organizou.
A página atual do GitHub Copilot lista, para indivíduos:
- Free;
- Pro por US$ 10/mês;
- Pro+ por US$ 39/mês;
- Max por US$ 100/mês.
O próprio GitHub passou a expressar parte do uso em AI Credits. Completar código continua ilimitado nos planos pagos, enquanto chat, agentes, CLI e outras tarefas consomem créditos conforme modelo e complexidade.
O Cursor lista o Pro a US$ 20/mês e oferece tiers superiores com limites maiores para uso agentic.
A Anthropic mantém Claude Pro a US$ 20/mês e Max a partir de US$ 100, chegando a uma opção de 20× a capacidade do Pro por US$ 200/mês. Claude Code está incluído nos planos pagos, mas uso de API é uma conta separada.
A OpenAI mantém o ChatGPT Plus em US$ 20/mês e possui opções Pro voltadas a uso mais intenso. Ao mesmo tempo, a API segue outra economia: em 3 de setembro de 2026, o GPT-5.6 Sol aparece com US$ 4 por milhão de tokens de entrada e US$ 20 por milhão de saída na tabela promocional vigente, enquanto o GPT-5.6 Luna aparece a US$ 0,20 e US$ 1,20.
Isso cria uma situação nova para o dev.
Você não compra mais simplesmente “uma IA”.
Você pode comprar:
acesso a um produto
+
limites maiores
+
um agente de código
+
variedade de modelos
+
execução em nuvem
+
créditos medidos
+
API
E várias dessas coisas se sobrepõem.
É aí que o orçamento começa a vazar.
A assinatura mais cara pode ser a que você quase não usa
Imagine quatro cobranças:
chat premium US$ 20
IDE com IA US$ 20
outro chat US$ 20
coding assistant US$ 39
---------------------------
total US$ 99/mês
A conta não é absurda para alguém que vive de software.
Mas existe uma pergunta anterior:
essas quatro assinaturas resolvem quatro gargalos diferentes?
Se três delas são usadas para:
- explicar código;
- gerar testes;
- revisar uma função;
- pesquisar documentação;
- escrever um primeiro rascunho;
talvez você não tenha quatro ferramentas.
Talvez tenha quatro interfaces para a mesma capacidade.
Variedade de modelos é útil. Redundância de assinaturas não é automaticamente útil.
Eu separaria as duas coisas.
Variedade tem valor de opção
Modelos diferentes podem ser melhores em:
- planejamento;
- escrita;
- código;
- navegação de repositório;
- contexto longo;
- velocidade;
- custo;
- tarefas agentic.
Ter acesso a mais de um modelo pode evitar ficar preso a um único fornecedor ou a uma única característica de modelo.
Assinaturas redundantes têm custo fixo
Se você paga todo mês por três produtos e usa o segundo e o terceiro apenas “quando lembra”, o valor da variedade pode ser menor do que o custo da duplicação.
A melhor solução pode ser:
- uma assinatura principal;
- uma ferramenta de código;
- um pequeno orçamento de API para experimentar modelos quando necessário.
Em outros casos, um produto multi-modelo pode substituir duas assinaturas.
O ponto não é qual marca vence.
É comprar diversidade sem pagar três vezes pelo mesmo trabalho.
Eu dividiria o orçamento de IA de um dev em quatro caixas
Em vez de escolher ferramentas primeiro, eu criaria quatro caixas.
1. Assistente geral
Serve para:
- pesquisa;
- análise;
- escrita;
- planejamento;
- documentos;
- arquivos;
- decisões;
- tarefas fora do editor.
Para muita gente, uma assinatura de aproximadamente US$ 20 já cobre uma parte enorme desse uso.
O upgrade para tiers de US$ 100 ou US$ 200 só faz sentido quando o limite do plano básico aparece durante trabalho valioso com frequência suficiente para custar mais do que o upgrade.
2. Ferramenta integrada ao código
Essa caixa precisa justificar por que existe separadamente.
O valor aparece quando a ferramenta:
- entende o repositório;
- edita múltiplos arquivos;
- roda testes;
- acompanha a issue;
- propõe patch;
- revisa diff;
- trabalha no terminal;
- delega tarefa para agente;
- reduz troca de contexto.
Aqui um Copilot Pro de US$ 10 ou um Cursor Pro de US$ 20 podem ser economicamente muito diferentes de simplesmente abrir outro chat no navegador.
Não porque “programam melhor” em qualquer situação.
Porque estão mais perto do workflow onde o custo de contexto acontece.
3. API e experimentação
Essa é a caixa que eu considero subestimada.
Um dev pode gastar US$ 20 em uma assinatura e nunca aprender a responder perguntas como:
- quanto custa essa feature por usuário?
- qual modelo barato resolve 80% das chamadas?
- quando preciso escalar para um modelo de fronteira?
- quanto cache economiza?
- quanto retries consomem?
- quanto custa rodar isso 10 mil vezes?
Uma reserva pequena de API — por exemplo US$ 10, US$ 20 ou US$ 30 mensais — pode ensinar mais sobre engenharia econômica de IA do que uma quarta assinatura de chat.
Não precisa ser gasto todo mês.
É um teto de experimento.
4. Ferramenta especializada
Essa caixa só abre quando existe um problema específico.
Exemplos:
- geração visual;
- vídeo;
- voz;
- pesquisa especializada;
- observabilidade de LLM;
- evals;
- banco vetorial;
- browser agent;
- automação.
A regra é simples:
ferramenta especializada entra porque há um caso recorrente, não porque apareceu uma demo impressionante.
Então quanto eu recomendaria?
Não existe um número universal, mas dá para criar faixas úteis.
Essas faixas abaixo são heurísticas minhas, não uma regra de mercado.
Faixa 1 — aprendendo ou usando ocasionalmente: US$ 0–20/mês
Objetivo:
- aprender a usar IA bem;
- entender limitações;
- testar fluxo de trabalho;
- descobrir onde existe ganho real.
Uma ferramenta paga já pode ser suficiente.
Não vejo motivo para um estudante ou dev que ainda usa IA ocasionalmente montar uma pilha de US$ 100 apenas para “ter todos os modelos”.
O gargalo nessa fase tende a ser uso e método, não limite.
Faixa 2 — dev profissional usando IA diariamente: US$ 20–60/mês
Aqui começa o que considero o sweet spot para muita gente.
Uma configuração plausível:
assistente geral US$ 20
coding assistant US$ 10–20
API / experimentos US$ 10–20
--------------------------------
orçamento US$ 40–60
Isso já cobre:
- raciocínio e pesquisa;
- IA dentro do editor;
- acesso programático;
- comparação de modelos;
- aprendizado de custo real.
É bastante capacidade antes de entrar nos tiers caros.
Faixa 3 — uso intensivo com impacto direto em receita: US$ 60–150/mês
Aqui eu esperaria evidência.
O dev está:
- entregando mais projetos;
- usando agentes com frequência;
- delegando tarefas longas;
- economizando horas verificáveis;
- mantendo múltiplos repositórios;
- usando IA em produção;
- ganhando dinheiro com a capacidade adicional.
Nesse cenário, US$ 100 por mês pode ser barato.
Mas “uso muito” não é a mesma coisa que “gera muito valor”.
O que justifica essa faixa é o impacto no trabalho.
Faixa 4 — power user / agentic: US$ 150–300+ por mês
Essa faixa existe e pode fazer total sentido.
Mas eu colocaria uma condição:
o orçamento precisa ser gerenciado como infraestrutura.
Isso significa medir:
- uso;
- tarefas delegadas;
- custo;
- tempo poupado;
- taxa de aceitação;
- retrabalho;
- receita ou capacidade liberada.
Se você não sabe dizer por que está gastando US$ 250, talvez tenha assinado capacidade antes de construir o processo que a utiliza.
O teste de break-even é quase constrangedoramente simples
Uma assinatura custa US$ 20 por mês.
Se sua hora de trabalho vale US$ 50, ela precisa economizar aproximadamente:
US$ 20 ÷ US$ 50/h = 0,4 hora
Ou seja:
24 minutos por mês.
Uma ferramenta de US$ 100 precisa devolver duas horas.
Uma de US$ 200 precisa devolver quatro horas.
Visto assim, planos caros parecem fáceis de justificar.
Mas esse cálculo tem uma armadilha.
Nem toda hora “poupada” vira valor.
Você pode terminar uma função 30 minutos antes e gastar os mesmos 30 minutos:
- corrigindo um bug introduzido pelo agente;
- relendo código que não compreendeu;
- refazendo contexto;
- esperando tool calls;
- revisando uma solução superengenheirada.
Por isso eu usaria uma fórmula um pouco melhor:
valor mensal capturado =
(horas realmente liberadas × valor/hora)
+ receita adicional
+ custo de erros evitados
ROI líquido =
valor mensal capturado
- assinatura
- API
- retrabalho
- supervisão
A palavra importante é capturado.
Não “potencialmente economizado”.
Os dados atuais são um bom motivo para medir em vez de acreditar
A evidência sobre produtividade com IA em desenvolvimento está ficando mais interessante justamente porque não aponta para uma resposta simples.
Um working paper do NBER publicado em maio de 2026 analisou dados de mais de 100 mil desenvolvedores no GitHub. Os autores encontraram aumentos grandes em atividade de código com gerações sucessivas de ferramentas de IA: autocomplete, agentes interativos e agentes autônomos.
Mas o efeito caiu conforme a métrica se aproximava de software realmente entregue.
No caso dos agentes autônomos, o aumento estimado de atividade chegou a 180% em commits, mas caiu para cerca de 30% em releases.
Essa diferença é enorme.
Ela sugere algo que qualquer dev experiente reconhece:
gerar mais código
≠
entregar mais software útil
Outro resultado importante vem da METR.
O estudo com ferramentas do início de 2025 encontrou desenvolvedores experientes ficando 19% mais lentos em tarefas reais de grandes projetos open source quando podiam usar IA, mesmo acreditando que estavam mais rápidos.
Em fevereiro de 2026, a própria METR publicou uma atualização: os sinais com ferramentas mais novas apontavam para melhora, mas problemas de seleção e medição tornaram os novos números pouco confiáveis para estimar o tamanho do ganho.
Essa é uma posição intelectualmente útil.
Não é “IA não aumenta produtividade”.
Também não é “IA sempre aumenta produtividade”.
É:
o ganho depende de ferramenta, tarefa, contexto, experiência e processo — então você precisa medir seu próprio workflow.
Um terceiro estudo, publicado pelo NBER em agosto de 2026 em um domínio bem específico de código econométrico, mostrou outro lado da história. Transformar um chatbot em um agente restrito que executa e revisa o próprio código elevou o sucesso de 74% para 96% no benchmark usado, com aproximadamente oito centavos adicionais por execução.
Não dá para generalizar esse número para desenvolvimento web.
Mas ele ilustra um princípio importante:
às vezes pagar mais por agência e verificação produz um resultado economicamente melhor do que economizar centavos no modelo.
É por isso que eu não faria orçamento de IA olhando apenas para assinatura.
O sinal para fazer upgrade não é “quero o melhor modelo”
Eu faria upgrade quando uma destas situações aparecesse de forma recorrente.
Limite interrompe trabalho valioso
Você bate no limite semanal exatamente durante sessões que geram entrega.
Fila e latência viram gargalo
Esperar a ferramenta reduz o benefício que ela deveria criar.
O tier superior habilita um workflow que o inferior não cobre
Por exemplo:
- agentes mais longos;
- execução em nuvem;
- mais contexto;
- acesso a modelo necessário para tarefas difíceis;
- mais créditos para revisão ou delegação.
O custo de contornar o limite supera o upgrade
Se você passa duas horas por mês alternando contas, resumindo contexto e reconstruindo sessão para economizar US$ 80, talvez esteja economizando dinheiro e queimando valor.
E quando eu faria downgrade?
Downgrade é uma habilidade importante numa época em que toda ferramenta quer virar mensalidade.
Eu reduziria plano se:
- não bati no limite nos últimos 30 dias;
- uso a ferramenta menos de duas vezes por semana;
- outra assinatura cobre 80% do mesmo trabalho;
- o uso migrou para API;
- o ganho percebido não aparece em entregas;
- continuo aceitando quase nenhum código sugerido;
- a ferramenta virou hábito, não vantagem.
Uma assinatura não precisa ser “ruim” para deixar de fazer sentido.
Basta não ser o gargalo atual.
O método de 30 dias que eu usaria
Se você quer descobrir quanto deveria gastar, não decida para sempre.
Faça um experimento de um mês.
Semana 1 — baseline
Registre por alguns dias:
- horas de trabalho;
- tipo de tarefa;
- tempo até concluir;
- bugs/retrabalho;
- número de entregas;
- pontos em que IA ajudou;
- pontos em que atrapalhou.
Não precisa virar ciência.
Uma planilha simples basta.
Semana 2 — stack mínima
Use:
- uma ferramenta geral;
- uma ferramenta de código;
- API apenas quando necessário.
Evite adicionar novidade.
O objetivo é descobrir o que a base resolve.
Semana 3 — teste do upgrade
Escolha um gargalo.
Exemplo:
“Estou ficando sem créditos no coding agent três vezes por semana.”
Ou:
“Preciso comparar modelos para uma feature e minha ferramenta não permite.”
Teste um upgrade ou ferramenta adicional.
Semana 4 — fechamento
Responda:
- o que ficou mais rápido?
- o que ficou melhor?
- o que eu passei a fazer que antes não fazia?
- quanto retrabalho surgiu?
- qual ferramenta eu quase não usei?
- qual limite realmente me incomodou?
- se eu cancelar uma assinatura amanhã, qual faz falta primeiro?
A última pergunta é excelente.
Ela revela prioridade.
Um scorecard simples para cada assinatura
Eu usaria uma tabela de 0 a 5.
| Critério | Pergunta |
| — | — |
| Frequência | Uso isso em quantos dias da semana? |
| Ganho de tempo | Economiza tempo real ou apenas muda onde gasto tempo? |
| Qualidade | O resultado final fica melhor? |
| Exclusividade | Faz algo importante que minha outra ferramenta não faz? |
| Integração | Está dentro do meu fluxo de código/trabalho? |
| Receita | Ajuda a vender, entregar ou suportar mais? |
| Aprendizado | Melhora minha capacidade ou me torna dependente? |
| Confiabilidade | Consigo revisar e confiar no processo? |
Depois some.
Uma ferramenta que custa US$ 20 e marca 35 pontos pode valer muito mais que uma de US$ 100 que marca 18.
Preço absoluto engana.
Preço por utilidade é o que importa.
Minha configuração conceitual para um dev hoje
Se eu estivesse montando do zero para um programador profissional, eu não começaria com quatro assinaturas premium.
Começaria assim:
1. uma IA geral forte
2. uma IA integrada ao código
3. orçamento pequeno de API
4. ferramenta especializada somente quando surgir caso recorrente
Depois aumentaria gasto em resposta a gargalos.
Não em resposta a lançamentos.
Essa distinção fica mais importante porque as próprias ferramentas estão se transformando em plataformas multi-modelo.
O GitHub já permite seleção de modelos e acesso a agentes de terceiros em planos pagos. Cursor também vende acesso a modelos de ponta dentro do mesmo ambiente. Produtos desse tipo podem reduzir a necessidade de comprar várias assinaturas apenas para ter variedade.
Ao mesmo tempo, um chat geral pode oferecer capacidades que o IDE não substitui bem:
- pesquisa longa;
- documentos;
- análise de arquivos;
- conexão com outras ferramentas;
- memória;
- escrita.
É por isso que eu gosto da combinação generalista + coding + API.
Cada componente precisa justificar uma função diferente.
O orçamento deveria crescer junto com sua capacidade de capturar valor
Existe uma diferença enorme entre estas duas pessoas:
Dev A
assina US$ 200 de IA
usa para tirar dúvidas e gerar snippets
Dev B
assina US$ 200 de IA
delega triagem, pesquisa, testes, revisão,
documentação e partes de implementação
com métricas e supervisão
O preço é o mesmo.
A economia é completamente diferente.
Quanto mais caro fica o plano, mais eu esperaria ver:
- workflows repetíveis;
- tarefas delegáveis;
- critérios de aceite;
- logs de uso;
- roteamento entre modelos;
- limites humanos claros;
- medição.
A partir de certo ponto, comprar IA deixa de ser uma decisão de consumidor.
Vira uma decisão de engenharia.
O paradoxo: aprender a gastar menos pode exigir gastar um pouco
Existe um motivo pelo qual eu não recomendaria ficar para sempre apenas no gratuito para alguém que trabalha profissionalmente com software.
Sem experimentar:
- modelos diferentes;
- APIs;
- agentes;
- limites;
- custo;
- contexto;
- falhas;
você corre o risco de aprender IA apenas como interface de chat.
Para um dev, isso é pouco.
A habilidade valiosa não é apenas “pedir código”.
É entender:
quando usar IA
+
qual nível de modelo usar
+
como validar
+
quanto custa
+
quando escalar
+
quando uma regra simples é melhor
Às vezes pagar US$ 20 ou US$ 50 por mês é parte do laboratório profissional.
Mas laboratório tem hipótese.
Coleção de assinaturas não.
Minha resposta: quanto um dev deveria investir?
Se eu precisasse resumir tudo em uma política:
até aproximadamente US$ 20/mês, compre acesso e aprendizado.
Entre US$ 20 e US$ 60/mês, monte um stack profissional enxuto.
Entre US$ 60 e US$ 150/mês, exija evidência de impacto em entrega, qualidade ou receita.
Acima de US$ 150/mês, trate IA como infraestrutura: orçamento, observabilidade e ROI.
Esses números não são tetos morais.
Um dev pode ganhar muito dinheiro com uma assinatura de US$ 200.
Outro pode desperdiçar US$ 20.
A pergunta correta continua sendo a mesma do capítulo anterior:
qual é o custo por resultado válido?
Só que agora aplicamos essa pergunta à nossa própria carteira.
E talvez esse seja o melhor antídoto contra o FOMO desta fase da IA.
Não tentar ter todas as ferramentas.
Construir uma stack que consiga explicar por que cada uma está ali.
Para quem quer levar essa discussão do orçamento pessoal para a engenharia de sistemas — comparando agent, chat e API, medindo custo, usando fallback e colocando IA apenas onde o ROI fecha — esse é exatamente um dos problemas trabalhados na AIStack.
No próximo capítulo, a pergunta muda de dinheiro para conhecimento:
se a IA já escreve código, ainda vale aprender programação e continuar lendo código profundamente?
