Desenvolvimento de Software com IA: Limites e o Poder do DDD

As ferramentas de inteligência artificial (IA), como o Cursor, prometem revolucionar o desenvolvimento de software, mas um estudo recente levanta questões sobre sua eficácia real. Publicado em https://metr.org/blog/2025-07-10-early-2025-ai-experienced-os-dev-study/, um estudo conduzido pela Model Evaluation and Threat Research (METR) analisou o impacto do Cursor na produtividade de desenvolvedores experientes. Este artigo explora os principais resultados, perspectivas de especialistas e implicações para o uso de IA no desenvolvimento de software.

A METR recrutou 16 desenvolvedores experientes para corrigir 13 problemas reais em repositórios de código aberto, pagando US$ 1.500 por hora. Alguns usaram ferramentas de IA, principalmente o Cursor (com modelos Sonnet 3.5 ou 3), enquanto outros não usaram IA. A análise foi feita a partir de 146 horas de gravações de tela, revelando insights surpreendentes.

Principais Descobertas

• Produtividade Geral: Contrariando as expectativas, desenvolvedores que usaram IA levaram 19% mais tempo para completar as tarefas do que aqueles sem IA. Embora a IA tenha reduzido o tempo gasto em codificação, pesquisa e testes, o tempo adicional em atividades como criação de prompts, espera pela geração de código, revisão de resultados e “overhead” no ambiente de desenvolvimento (IDE) anulou esses ganhos.
• Percepção x Realidade: Antes do estudo, os desenvolvedores esperavam que a IA aumentasse a produtividade em 24%. Mesmo após a experiência, eles acreditavam que a IA os havia acelerado em 20%, apesar de os dados mostrarem o contrário.
• Exceção Notável: Um desenvolvedor com mais de 50 horas de experiência com o Cursor obteve um aumento de 38% na velocidade, sugerindo que a familiaridade com a ferramenta pode levar a melhores resultados. No entanto, com uma amostra de apenas um, a generalização é limitada.

Simon Willison, um engenheiro de software respeitado e especialista em ferramentas de IA, interpretou os resultados no contexto da curva de aprendizado. Ele sugere que a queda de produtividade reflete o tempo necessário para integrar a IA aos fluxos de trabalho existentes. Segundo Simon: “é preciso muito esforço para aprender, explorar e experimentar” com ferramentas de IA, sem guias claros para orientar os desenvolvedores. Ele acredita que os participantes do estudo estavam ainda na fase inicial de adaptação, o que impactou negativamente seu desempenho.

Quentin Anthony: Estratégias para o Sucesso com IA

Quentin Anthony, o desenvolvedor com mais de 50 horas de experiência com o Cursor, oferece uma perspectiva prática. Como estudante de doutorado e desenvolvedor de pré-treinamento, ele argumenta que o sucesso com IA depende menos da habilidade técnica e mais da capacidade de evitar “modos de falha” – tanto do modelo de linguagem quanto do fluxo de trabalho humano. Ele sugere três pontos-chave:

1. Evitar a mentalidade de “solução mágica”: muitos desenvolvedores tratam os modelos de linguagem (LLMs) como uma solução instantânea, o que leva a frustrações quando os resultados não atendem às expectativas. Anthony enfatiza que LLMs são ferramentas, não atalhos universais.
2. Conhecer as limitações dos LLMs: LLMs são eficazes em tarefas com abundância de dados de treinamento, como escrita de código genérico ou compreensão de código desconhecido. No entanto, são menos confiáveis em áreas especializadas, como código de baixo nível (ex.: kernels de GPU ou sincronização de comunicação). Anthony recomenda usar LLMs apenas para tarefas nas quais são confiáveis.
3. Gerenciar o Tempo de Geração: O tempo de espera pela geração de código pode levar a distrações, como navegar em redes sociais. Ele sugere preencher esse tempo com atividades produtivas (ex.: responder e-mails, planejar próximas perguntas) e adotar hábitos de higiene digital, como bloqueadores de sites e modo “não perturbe”.

Desafios do uso de ferramentas de IA.

Curva de Aprendizado

O estudo reforça que ferramentas como o Cursor exigem prática significativa. Dos participantes, 44% nunca haviam usado o Cursor antes, e a maioria tinha até 50 horas de experiência. Isso sugere que a falta de familiaridade contribuiu para a queda de produtividade. Pesquisas adicionais com base em 200 engenheiros, indicaram que aqueles com menos de seis meses de uso de IA tendem a ter uma percepção negativa, muitas vezes abandonando as ferramentas quando elas não atendem às expectativas iniciais. (https://arxiv.org/abs/2507.09089).

Capacidades Inconsistentes dos LLMs

Os LLMs têm desempenho “spiky” (altamente variável). Eles são bons em tarefas com muitos dados de treinamento, mas falham em áreas especializadas devido à escassez de dados ou à falta de benchmarks adequados. Isso exige que os desenvolvedores sejam seletivos ao decidir quando usar IA.

https://www.linkedin.com/embeds/publishingEmbed.html?articleId=7752633118720465228&li_theme=light

Context Switching: Um Obstáculo Subestimado

Um dos insights mais intrigantes é o impacto do context switching (troca de contexto). Ferramentas de IA forçam os desenvolvedores a alternar entre codificação, revisão de código gerado e outras tarefas, interrompendo o estado de “flow” – o foco profundo essencial para a produtividade. O documento levanta a hipótese de que desenvolvedores sem IA podem superar aqueles que usam IA, pois conseguem manter o foco por mais tempo. Isso sugere que o estado de “flow” pode ser uma vantagem competitiva em relação aos ganhos de tempo da IA.

Implicações para a Indústria.

O estudo também reflete tendências mais amplas na indústria de tecnologia:

• Custos Crescentes de LLMs: A imposição silenciosa de limites no plano “ilimitado” do Cursor gerou insatisfação, indicando que os custos de uso de LLMs estão aumentando. A redução de subsídios de capital de risco pode limitar o acesso a essas ferramentas no futuro.
• Riscos em Produção: Um incidente com o Replit AI deletando dados de produção destaca os perigos de depender de ferramentas de IA em ambientes críticos.
• Outages Tecnológicos: Problemas como a queda do 1.1.1.1 e outages causados por uma atualização no systemd do Ubuntu (afetando empresas como Heroku, OpenAI e GitLab) mostram a fragilidade de sistemas dependentes de tecnologia.

Apesar de críticas, sou a favor da adoção.

Se você quer se tornar indispensável no mundo da IA, comece dominando a arte de pensar sistemas — não apenas programá-los.

Imagine que, antes de escrever qualquer linha de código, você documenta exatamente o que o sistema deve fazer, por quê, como saber se está funcionando, como testar, qual comportamento esperar da IA, e até como o sistema deve reagir a ambiguidades.

Isso é uma especificação — mas não qualquer uma: uma especificação executável, ou seja, um documento claro o suficiente para que:

• Um humano entende o que precisa ser feito;
• Um modelo de IA consiga agir com base nele (como gerar código, fazer sugestões, validar respostas);
• E você consiga testar automaticamente se o sistema ou modelo está fazendo o que foi pedido.

Com o avanço dos modelos, o que separa um bom sistema de um sistema ruim não é o código em si, mas sim a clareza com que os requisitos foram pensados, escritos e testados.

Quando você documenta intenções e critérios como especificações, você cria um ponto central de verdade, que:

• Evita retrabalho e desalinhamento;
• Permite reaproveitar as mesmas intenções para gerar código, testes, documentação e até conteúdo de IA;
• Te posiciona como alguém que pensa o sistema como um todo — não só alguém que “programa”.

O que eu, particularmente, recomendo é aprender Domain-Driven Design (DDD) no contexto de Inteligência Artificial (IA) o que é um diferencial brutal para quem quer criar sistemas inteligentes, confiáveis e mantíveis. Abaixo explico de forma direta por que DDD é essencial para IA moderna.

Livro recomendado:

https://www.linkedin.com/embeds/publishingEmbed.html?articleId=7804892448095401961&li_theme=light

DDD é um conjunto de práticas para modelar o software com base no domínio de negócio, com foco em clareza, linguagem comum e separação de responsabilidades.

Por que DDD é essencial para projetos com IA

1. Delimita o que a IA pode ou não fazer.

Com DDD, você define:

• Bounded Contexts: a IA age só dentro de uma área clara (ex: classificação de produto, geração de resumo).
• Ubiquitous Language: o prompt usa exatamente os termos que o time técnico e de negócio entendem.

2. Separa IA da Regra de Negócio.

Você define interfaces claras entre:

• Aplicação: controla quando e como chamar a IA.
• Domínio: define regras imutáveis (ex: “produto sem categoria não pode ser salvo”).
• IA (serviço externo): só sugere, nunca decide.

💡 Isso te permite testar e substituir a IA se necessário (ex: por regras fixas ou outro modelo).

3. Permite usar IA como componente plugável no domínio

Em vez de codar regra hardcoded ou dar controle total à IA, você faz algo como:

const categoria = await IA.sugerirCategoria(produto);

if (!Categoria.valida(categoria)) {
  throw new CategoriaInvalida();
}

produto.categorizarComo(categoria);

🧩 A IA vira uma peça do domínio, mas o controle permanece no core.

4. Facilita versionamento e testes automatizados

Com DDD, sua spec executável (como vimos acima) descreve:

• Entradas válidas.
• Comportamento esperado da IA
• Regras de fallback.

E você consegue escrever testes baseados em casos reais, como:

test('IA sugere categoria correta para smartwatch', () => {
  const entrada = new Produto('Smartwatch XYZ', 'Relógio com batimentos');
  const categoria = ia.sugerirCategoria(entrada);
  expect(categoria).toBe('Eletrônicos > Wearables');
});

Em resumo:

1. IA sem DDD = código frágil
2. IA com DDD = sistema confiável, modular, inteligente

Como será o papel do desenvolvedor?

O desenvolvedor do futuro será um orquestrador de inteligência, não apenas um digitador de código.

Vai fazer:

• Especificar comportamentos esperados
• Definir limites do sistema (com DDD)
• Ensinar a IA com dados e exemplos
• Garantir segurança, rastreabilidade e qualidade
• Construir integrações entre IA + APIs + banco

Vai evitar:

• Repetir código boilerplate
• Implementar lógica simples (validações, conversões)
• Traduzir requisitos ambíguos manualmente

Um dev com IA eficaz não é aquele que apenas escreve código. É aquele que modela intenções, coordena sistemas inteligentes e alinha pessoas, negócios e máquinas.

Os introspectivos precisarão se adaptar

Hoje, um bom dev é avaliado por:

• Saber codar bem
• Conhecer frameworks
• Resolver bugs

No futuro (que já começou), será avaliado por:

• Saber expressar intenções de forma clara
• Colaborar com pessoas e máquinas
• Criar alinhamento entre negócio, design e tecnologia
• Analisar, revisar e adaptar o que a IA gera

Por isso, os chamados “soft Skills”, preciso “human Skills”. como:

1. Comunicação clara e precisa

Se você não consegue explicar o que quer que o sistema faça, nem humanos nem IAs vão entregar.

• Escrever especificações compreensíveis
• Criar prompts com contexto
• Ser claro em reuniões: “O que isso significa no fluxo real?”

2. Colaboração entre pessoas e IA

Times que criam sistemas inteligentes precisam co-criar, não competir.

• Explicar para o time o que a IA pode ou não fazer
• Pedir feedback de negócios e usuários sobre os comportamentos da IA
• Corrigir ou reescrever prompts com base em testes reais

3. Curiosidade e aprendizado contínuo

A IA está evoluindo. Você precisa se adaptar, testar, experimentar.

• Testar novas formas de usar prompts
• Acompanhar modelos e frameworks emergentes (ex: function calling, agents, specs dinâmicas)
• Compartilhar descobertas com o time

4. Pensamento crítico

A IA vai gerar sugestões o tempo todo. Nem todas são boas.

• Saber dizer “isso não faz sentido”
• Comparar alternativas com base em domínio de negócio
• Validar com dados, testes ou comportamento de usuário real

5. Criatividade

A IA executa. A criatividade direciona.

• A IA executa o que você pede — então você precisa ser criativo no que pedir.
• Criatividade ajuda a modelar comportamento, resolver problemas complexos e criar experiências melhores.
• Times com IA nivelam o jogo técnico — o diferencial será quem pensa diferente.

Resumo Rápido:

• IA ainda exige curva de aprendizado.
• Produtividade só vem com domínio da ferramenta.
• Especificações claras + DDD = IA útil de verdade.
• Soft skills vão definir os bons devs do futuro.

LIVRO RECOMENDADO: https://amzn.to/44QXhAN

CURSO RECOMENDADO: https://huggingface.co/learn/agents-course/unit0/introduction (Não apenas para agentes de IA, mas utilizar o https://ollama.com/ para baixar estes modelos em sua máquina e ter um conhecimento mais profundo e economia $$ no uso de LLMs. Uma vez que modelos open-source estão cada vez mais próximos dos modelos comerciais).

Para refletir

Você está pronto para ser um engenheiro de sistemas inteligentes ou vai continuar apenas pedindo código para a IA?

Escrito com muito café. Apoie compartilhando.

Publicado originalmente em: https://www.linkedin.com/pulse/produtividade-com-ia-mito-ou-realidade-ramos-de-souza-janones-6kmpf/