Mindset IA-First

Mindset IA-First — aula do módulo IA para Devs, na trilha Fundamentos Práticos de IA da formação Inteligência Artificial Aplicada.

Leitura de aproximadamente 4 minutos.

Módulo: IA para Devs · Curso: Fundamentos Práticos de IA · Formação: Inteligência Artificial Aplicada

Mindset IA-First: Da Programação Tradicional à Orquestração de Modelos

O que você vai aprender

A mudança de paradigma: de programador digitador de sintaxe para engenheiro especificador e auditor de sistemas.
Como decompor problemas complexos em especificações claras (contratos, invariantes e casos de teste) para modelos de IA.
O ciclo de feedback contínuo: especificação, geração assistida, validação determinística e auditoria de segurança.

Conteúdo

Conceito principal

Na programação tradicional, o desenvolvedor atua como o compilador humano do pensamento abstrato: gasta 80% do tempo convertendo lógica mental em sintaxe detalhada (loops, manipulação de strings, boilerplate de banco de dados e rotas HTTP).

No paradigma IA-First, essa relação se inverte: 1. O desenvolvedor se torna o arquiteto e auditor: define requisitos, arquitetura de dados, restrições não-funcionais, segurança e critérios de aceitação. 2. A IA atua como o motor de síntese: gera implementações preliminares, converte formatos de dados, cria fixtures de teste e sugere correções de bugs. 3. O código gerado é tratado como premissa não confiável até ser validado: nenhum código de IA entra em produção sem testes automatizados, verificação de tipos e checagem de vulnerabilidades.

A habilidade central do dev moderno não é mais memorizar sintaxes obscuras de bibliotecas, mas sim formular restrições precisas e orquestrar fluxos com baixo retrabalho.

Na prática

Considere a criação de uma função utilitária para sanitização e validação de slugs de URLs com suporte a caracteres acentuados.

Em vez de escrever expressões regulares manuais do zero, o desenvolvedor IA-First define uma especificação formal com testes antes de solicitar a implementação ao modelo.


// especificação / contrato de teste (invariantes esperados)
import { describe, it, expect } from 'vitest';
import { generateSafeSlug } from './slug-utils';

describe('generateSafeSlug', () => {
  it('deve converter caracteres acentuados e pontuações em slugs limpos', () => {
    const input = 'Inteligência Artificial Aplicada & Devs (2026)!';
    const expected = 'inteligencia-artificial-aplicada-devs-2026';
    expect(generateSafeSlug(input)).toBe(expected);
  });

  it('deve evitar múltiplos hífens consecutivos e hífens nas bordas', () => {
    const input = '---guia---rapido---';
    const expected = 'guia-rapido';
    expect(generateSafeSlug(input)).toBe(expected);
  });

  it('deve truncar strings excessivamente longas sem quebrar palavras', () => {
    const input = 'Um texto extremamente longo para teste de limite máximo de caracteres no slug';
    const result = generateSafeSlug(input, { maxLength: 30 });
    expect(result.length).toBeLessThanOrEqual(30);
    expect(result).not.toMatch(/-$/);
  });
});

Com o contrato definido, a instrução para a IA é cirúrgica:


Prompt para o Copiloto/Modelo:
"Implemente a função generateSafeSlug em TypeScript compatível com os testes acima.
Requisitos:
- Utilize apenas APIs padrão do Node.js/navegador (sem dependências externas pesadas).
- Remova diacríticos via normalize('NFD').
- Trate nulos, strings vazias e limites de tamanho de forma defensiva."

Código resultante gerado e auditado:


// slug-utils.ts
export interface SlugOptions {
  maxLength?: number;
}

export function generateSafeSlug(text: string, options: SlugOptions = {}): string {
  if (!text || typeof text !== 'string') {
    return '';
  }

  const { maxLength = 80 } = options;

  let slug = text
    .normalize('NFD')
    .replace(/[\u0300-\u036f]/g, '') // remove acentuação
    .toLowerCase()
    .replace(/[^a-z0-9]+/g, '-') // substitui caracteres não alfanuméricos por hífen
    .replace(/^-+|-+$/g, '') // remove hífens do início e fim
    .replace(/-{2,}/g, '-'); // colapsa múltiplos hífens

  if (slug.length > maxLength) {
    slug = slug.substring(0, maxLength).replace(/-+$/, '');
  }

  return slug;
}

Security check ⚡

Não confie cegamente na saída: LLMs frequentemente inventam métodos inexistentes de bibliotecas (alucinação) ou usam versões deprecadas de funções de criptografia.
Risco de Regex DoS (ReDoS): Expressões regulares geradas por IA para validação de e-mails ou parsing de texto podem conter quantificadores aninhados vulneráveis a ataques de negação de serviço.
Verificação obrigatória: Execute linter estático e suíte de testes antes de qualquer commit de código gerado.

Exercício

1. Crie uma especificação em markdown com 3 regras de negócio para uma função de validação de CPF ou identificador de documento. 2. Utilize seu assistente de IA preferido para gerar a implementação em TypeScript/JavaScript. 3. Crie 4 casos de teste que tentem propositalmente "quebrar" o código gerado com entradas malformadas (entradas nulas, injeção de caracteres de controle, strings com 10.000 dígitos). 4. Registre quantas correções manuais ou iterações de prompt foram necessárias para atingir 100% de cobertura nos testes.

Recapitulando

O paradigma IA-First prioriza especificação, arquitetura e verificação em vez de digitação manual de código.
Testes automatizados e contratos claros são os guardrails mais eficazes contra alucinações de modelos.
Segurança e auditoria de código gerado continuam sendo responsabilidade intransferível do engenheiro de software.

Próximos passos

Na próxima aula, vamos dissecar o funcionamento interno dos modelos de linguagem: Anatomia de um LLM: Tokens, Context Window, Latência e Custo.