Papéis e Novas Skills no Time AI-Native: Do Senior Engineer ao AI Systems Designer

English summary (PT-BR article): An AI-native team is not about replacing developers with prompts. It is about new specializations emerging around agent loops — AI Engineer, Context Designer, Evals Owner, AI Reviewer, Platform/AI Infra Engineer — and reshaping the developer career from T-shaped to comb-shaped with new skills like prompt writing, context engineering, evals literacy, and AI security awareness.
No manifesto sobre equipes AI-native, definimos AI-native como um modelo de organização onde a IA não é uma ferramenta ocasional, mas a camada operacional que molda arquitetura, processo, papéis e cultura. A pergunta que fica pendente é a mais difícil de responder:
Quem faz isso acontecer?
A resposta curta é: ninguém sozinho. A resposta longa é que a reorganização de um time AI-native não substitui a figura do engenheiro por um "prompt operator". Ela faz emergir novas especializações em torno de loops de agentes, context windows, evals e infraestrutura de LLM. O senior engineer tradicional não some. Ele ganha novas ferramentas, novas responsabilidades e novos vizinhos de profundeza técnica.
Este artigo é o segundo da série sobre times AI-native. Vamos mapear os papéis que estão se consolidando em 2026, redesenhar a carreira do desenvolvedor de T-shaped para comb-shaped, listar as skills que sobem e descem de valor, e mostrar um exemplo concreto de como um AI Engineer descreve uma tarefa para um agente.
A primeira tentação quando se fala em IA é pensar em redução de cabeça. O LinkedIn Workforce Report 2026 e o World Economic Forum Future of Jobs 2025 mostram um movimento mais interessante: o número de títulos com "AI" cresceu muito mais rápido que a redução de títulos tradicionais. O que está acontecendo não é substituição líquida, é reorganização.
Em um time AI-native maduro, as mesmas pessoas que antes codavam 100% do tempo agora dividem o trabalho entre codar, desenhar context windows, escrever evals, revisar saídas de agentes e manter a infraestrutura de IA. O trabalho de escrever código de produção não desaparece. Ele é complementado por um trabalho novo que não existia antes: o de orquestrar, avaliar e proteger sistemas probabilísticos.
A Stack Overflow Developer Survey 2024 já mostrava que mais de 70% dos desenvolvedores usavam ferramentas de IA no fluxo de trabalho. O passo seguinte, que é o tema deste artigo, é entender que usar a ferramenta não basta. É preciso ter pessoas cuja responsabilidade é desenhar o sistema em volta dela.
Os títulos variam entre empresas, mas as responsabilidades são recorrentes. Abaixo, os cinco papéis que aparecem com mais força em times AI-native maduros em 2026.
O AI Engineer é o papel mais próximo do que a Anthropic chama de AI engineer: alguém responsável por desenhar sistemas que usam LLMs de forma confiável. Isso inclui desenhar loops de agentes, decidir quando usar workflow versus agent, escolher onde o contexto vive, como o estado é passado adiante, quando há intervenção humana e como o sistema se recupera.
Esse papel não é o "prompt engineer" de 2023. O prompt é só uma das variáveis. O AI Engineer pensa no contrato do loop: estado, decisão, ação, evidência, parada. Ele é quem decide, por exemplo, se uma task deve rodar como um único agente com três tools ou como um orquestrador com workers especializados — decisão que vimos em detalhe no artigo sobre loops de agentes.
Skills-chave: system design, context engineering, evals literacy, leitura crítica de saídas probabilísticas, conhecimento de ferramentas como Model Context Protocol, SDKs de agentes e frameworks de evals.
O prompt engineer virou context designer. A diferença é crucial: o prompt é uma string; o contexto é um sistema. Hoje a maior parte do trabalho de "escrever prompts" é, na verdade, desenhar a context window completa — system prompt, exemplos recuperados via RAG, histórico de turno, schemas de ferramentas, memória de longo prazo, arquivos do repositório, saídas de tools anteriores.
O Context Designer é responsável por decidir o que entra na janela, em qual ordem, com qual prioridade, e quando deve sair. Esse trabalho é parte engenharia, parte curadoria editorial. Ele define políticas de compressão, priorização de fontes, exclusão de ruído e injeção de contexto dinâmico por tarefa.
Skills-chave: prompt writing avançado, retrieval design, curadoria de conhecimento, design de schemas de tool, consciência de janela de tokens, compressão de contexto.
Se o código determinístico tem QA, o sistema com LLM tem Evals Owner. Esse papel é o dono do ciclo de qualidade de saídas probabilísticas. Enquanto o QA clássico verifica que o código faz o que a spec diz, o Evals Owner verifica que o modelo se comporta bem o bastante em uma distribuição de entradas que ninguém consegue enumerar por completo.
Suas responsabilidades incluem construir golden sets, definir métricas (task success, evidence coverage, recovery rate, cost per success), rodar avaliações automáticas antes de deploy, monitorar regressão comportamental e desenhar avaliação humana para casos ambíguos. A documentação da Anthropic sobre evals para agentes é uma boa base, mas a tradução para o produto precisa de alguém dedicado.
Skills-chave: estatística aplicada, design de experimentos, métricas de qualidade de LLM, ferramentas como promptfoo e LangSmith, escrita de rubricas, modelos como juiz (LLM-as-judge).
Toda empresa que usa IA para gerar código precisou criar uma nova classe de revisor. Esse papel é diferente do code reviewer tradicional porque ele precisa detectar três classes de problema específicas de saída de IA:
O AI Reviewer não revisa apenas o que o código faz. Ele revisa de onde veio, o que carrega embutido e quais riscos introduz.
Skills-chave: leitura crítica de código, conhecimento de vulnerabilidades de LLM (OWASP Top 10 for LLM), consciência de licenças open source, capacidade de detectar raciocínios longos falhos.
Por último, alguém precisa cuidar do servidor. Em escala, chamar um LLM direto da aplicação não escala — você precisa de roteamento entre providers, cache semântico, rate limiting, observabilidade de custo, retries com fallback, controle de versão de prompt, pipelines de embedding, vector store e RAG infra.
O Platform AI Infra Engineer é o SRE da camada de IA. Ele desenha a infraestrutura que mantém o resto do time produtivo sem torrar orçamento nem comprometer latência.
Skills-chave: serving de LLM (vLLM, TGI), observabilidade (LangSmith, Helicone, Arize), cache semântico, RAG (pgvector, Pinecone, Qdrant), controle de custo, segurança de API keys.
| Papel | Responsabilidade principal | Skills-chave | Ferramentas representativas |
|---|---|---|---|
| AI Engineer / AI Systems Designer | Desenhar loops de agentes e orquestração | System design, context engineering, evals literacy | Claude Agent SDK, OpenAI Agents SDK, Model Context Protocol |
| Context Designer (ex-Prompt Engineer) | Construir context windows e políticas de contexto | Prompt writing, retrieval design, curadoria | LangChain, LlamaIndex, embeddings, vector stores |
| Evals Owner / AI Quality Engineer | Qualidade de saídas probabilísticas e regressão | Estatística, design de experimentos, LLM-as-judge | promptfoo, LangSmith, OpenAI Evals, Braintrust |
| AI Reviewer / Code Reviewer Especializado | Revisar código gerado por IA (lógica, segurança, IP) | Leitura crítica, OWASP LLM Top 10, licenças | ferramentas de SAST, scanners de segredos, diff semantics |
| Platform / AI Infra Engineer | Serving, RAG infra, observabilidade de LLM | SRE aplicado a IA, cache semântico, custo | vLLM, Helicone, Arize, pgvector, Pinecone, OpenLLMetry |
O desenvolvedor T-shaped clássico tem uma profundeza (backend, frontend, dados) e uma largura razoável em áreas adjacentes. Esse modelo funcionou bem por uma década, mas ele pressupõe que o trabalho de largura é secundário.
Em um time AI-native, isso muda. A largura deixa de ser opcional porque as ferramentas de IA obrigam o dev a tocar simultaneamente em camadas que antes eram separadas: prompt (texto), retrieval (dados), tool schema (API), eval (estatística), observabilidade (infra). Um dev que só sabe backend e se recusa a escrever prompt ou eval acaba isolado em uma ilha de código determinístico, perdendo a alavanca que o resto do time tem.
A metáfora que tem funcionado é a de comb-shaped (pente): múltiplas profundezas menores, com 1-2 profundezas fortes. O dev continua especialista em uma coisa, mas ganha profundeza prática em três a cinco áreas adjacentes necessárias para fechar o loop de IA.
O ponto de chegada não é obrigatoriamente "AI Systems Designer". Muitos devs vão permanecer comb-shaped sem virar especialistas. O que muda é que a porta de saída da transição não é "virar gerente" nem "continuar codando como antes". É um espectro de papéis com diferentes misturas de profundeza.
Free and paid products to turn ideas into a foundation you can actually ship.
13 products availableContinue exploring similar topics

English summary: AI-native teams redesign how work crosses boundaries: context, decision rights, evaluation, and human accountability become explicit so autonomy can grow without h

English summary: AI-native organizations need a measurement operating system, not an AI-usage leaderboard. This article starts with a minimal outcome event and dashboard, then conn

--- title: "QA e DevOps AI-Native: Evals em Produção, Testes Probabilísticos e IaC Gerada por IA" subtitle: "O que muda em qualidade, integração contínua e observabilidade quando o
A practical checklist to validate security, cost, evals, and observability before you ship your AI app to production.
Production-tested templates trusted by developers. Save weeks of setup on your next project.
Independente do papel final, existe um conjunto de skills que se tornou básico para qualquer engenheiro de software trabalhando com IA. Quem não tem essas skills perde alavancas quem tem, trabalha mais rápido e melhor.
A regra prática: tudo que é determinístico, repetitivo e bem especificado desce de valor. Tudo que é julgamento, arquitetura, leitura crítica e design sobe.
Para concretizar a diferença entre um dev tradicional e um AI Engineer, vamos olhar como o AI Engineer descreve uma tarefa para um agente. A unidade de trabalho não é mais uma Jira com três linhas; é uma especificação explícita de objetivo, contexto, ferramentas, critérios de saída e guardrails.
type AITaskDefinition = {
goal: string;
successCriteria: string[];
context: {
files: string[];
docs: string[];
history?: string[];
};
tools: {
name: string;
scope: 'read' | 'write' | 'execute';
permission: 'auto' | 'human_required';
timeoutSeconds: number;
}[];
guardrails: {
maxSteps: number;
maxTokenCost: number;
blockedActions: string[];
requireHumanApprovalFor: string[];
};
evals: {
kind: 'unit' | 'integration' | 'behavioral' | 'human';
command: string;
threshold: number;
}[];
};
const task: AITaskDefinition = {
goal: 'Corrigir o bug de renovação de token de refresh sem quebrar a sessão ativa',
successCriteria: [
'Teste auth/refresh.spec.ts passa',
'Nenhum teste em auth/ regrediu',
'Logs de auditoria continuam registrando o evento',
],
context: {
files: ['src/auth/refresh.ts', 'src/auth/session.ts', 'tests/auth/refresh.spec.ts'],
docs: ['docs/auth.md', 'docs/security-tokens.md'],
},
tools: [
{ name: 'read_file', scope: 'read', permission: 'auto', timeoutSeconds: 10 },
{ name: 'run_tests', scope: 'execute', permission: 'auto', timeoutSeconds: 120 },
{ name: 'edit_file', scope: 'write', permission: 'human_required', timeoutSeconds: 5 },
],
guardrails: {
maxSteps: 8,
maxTokenCost: 50_000,
blockedActions: ['deploy', 'database_migration', 'send_external_request'],
requireHumanApprovalFor: ['merge_to_main', 'edit_security_policy'],
},
evals: [
{ kind: 'unit', command: 'pnpm test auth/refresh.spec.ts', threshold: 1 },
{ kind: 'integration', command: 'pnpm test:e2e auth-flow', threshold: 1 },
{ kind: 'behavioral', command: 'pnpm eval:auth-regression', threshold: 0.95 },
],
};
Note que essa estrutura não é só para o agente. Ela é também um contrato entre o AI Engineer, o AI Reviewer (que vai revisar a saída), o Evals Owner (que vai medir se os critérios são bons) e o Platform Infra (que vai observar custo e latência). Um task definition bem escrito é o ponto onde os cinco papéis se encontram.
Esse medo paralisante aparece em dois extremos: o dev que recusa usar IA por princípio e o gestor que corta cabeça antes de entender o ganho real. A evidência empírica de relatórios como o Future of Jobs 2025 do WEF não suporta nenhuma das duas leituras. O que se observa é deslocamento de tarefas, não de profissões, e criação líquida de novos papéis.
Reduzir a transição a "todo dev agora escreve prompt" é um erro de abstração. O prompt é uma camada; o sistema em volta dele é onde a maioria do valor está. Um time que trata só do prompt e ignora context, evals, infra e review acaba com demos bonitas e produtos frágeis.
O anti-pattern mais comum — e o mais caro. Times que pulam a camada de evals ficam reféns de "parece bom" e descobrem regressões só depois do incidente em produção. Evals Owner existe exatamente para isso.
São trabalhos diferentes. O Context Designer pensa a janela inteira, não só o system prompt. Confundir os dois reduz o contexto a uma string e perde a alavanca de retrieval, memória e ferramentas.
O AI Reviewer não está ali para dizer "o código está bonito". Ele é a última barreira contra prompt injection, vazamento de dados, IP de terceiros e raciocínios longos falhos. Tratá-lo como opcional é a mesma classe de erro que tratar SRE como infraestrutura cosmética.
Nenhum time acorda AI-native numa segunda-feira. A transição acontece em fases, e cada fase tem habilidades novas que se tornam críticas. O fluxograma abaixo mostra a progressão típica.
O erro mais comum é pular fases. Times que tentam ir direto para arquitetura de agentes (Fase 4) sem ter padronização (Fase 2) e especialização (Fase 3) acabam com arquiteturas bonitas no whiteboard que ninguém consegue operar.
Se você é um dev em transição, comece por onde você já está:
Se você é líder de time, escolha a próxima fase da maturidade e desenhe um experimento interno. Comece pela padronização de prompts e contextos compartilhados — é o ganho mais barato e o que mais reduz fricção.
A transição para um time AI-native não é uma troca de pessoas por ferramentas. É uma reorganização em torno de novas responsabilidades que não existiam antes. Os cinco papéis — AI Engineer, Context Designer, Evals Owner, AI Reviewer, Platform/AI Infra — não são modismo de organograma. São a resposta estrutural ao fato de que sistemas com LLMs exigem desenho de loop, curadoria de contexto, qualidade probabilística, revisão especializada e plataforma de serving.
Para o desenvolvedor, isso significa redesenhar a própria carreira. O T-shaped foi suficiente quando o trabalho de largura era secundário. O comb-shaped é necessário quando a IA atravessa todas as camadas do produto. Ninguém precisa ser especialista em tudo, mas ignorar prompt, context, evals e segurança de IA deixa o dev isolado em uma ilha determinística enquanto o resto do time alavanca a parte probabilística.
A boa notícia é que essas skills se aprendem com prática deliberada. A má notícia é que ignorá-las não é mais uma opção neutra. Em dois ou três anos, a diferença entre o dev comb-shaped e o dev T-shaped resistente será a mesma diferença que existia nos anos 2010 entre o dev que aprendeu Git e o que continuou mandando patch por email.
O próximo artigo da série entra no código: como codar AI-native no frontend e no backend, com padrões concretos de context, evals e observabilidade.