As 17 Competências do Desenvolvedor AI-Native

O que são as 17 competências

As 17 competências AI-native são a espinha dorsal operacional do modelo de Desenvolvedor AI-Native de 7 níveis. Os níveis indicam quão maduro você é (de L1 Chat-Assistido a L7 Criador Universal de IA); as 17 competências indicam o que você faz concretamente para chegar lá. Cada competência está associada ao nível em que se torna a norma, tem um KPI numérico que revela se você a pratica de verdade e vem com as ferramentas que a ProCoders recomenda para executá-la bem.

Leia as competências como uma progressão, não como uma lista plana. A competência #1 (programar através de um agente) ativa-se no L2. O conjunto do L3 torna o agente confiável: MCP, skills e plugins, memória de projeto, planeamento, verificação. O grande conjunto do L4 transforma-o de programador em diretor: pesquisa, harnesses, agentes paralelos, roteamento de modelos, evals, worktrees, controlo remoto, portas de segurança, revisão de código e demos. A competência #12 (orquestração autónoma completa de PRD até resultado) é o marco do L5.

As 17 competências num relance

#	Competência	Norma a partir de	O que prova
1	Tenho o Claude (ou equivalente) e não escrevo código manualmente	L2	O agente é o seu mecanismo de produção principal, não um consultor de chat
2	MCP instalado	L3	O agente está ligado às suas fontes reais: docs, repositório, BD, issues
3	Skills e plugins instalados	L3	Um fluxo de trabalho repetível, não prompts ad-hoc
4	Memória de projeto como parte do repositório	L3	O conhecimento do projeto vive no repositório, não só na sua cabeça
5	Planear antes de programar	L3	Nenhuma implementação começa sem um plano aprovado
6	Skills de playground e deep-research durante o planeamento	L4	Tarefas difíceis são investigadas e prototipadas antes do código
7	Constrói harnesses específicos do projeto; transforma repetições em skills	L4	Você produtiza problemas recorrentes em vez de fazer re-prompting
8	Agentes paralelos / desenvolvimento orientado por subagentes	L4	Você gere uma equipa de funções, não um único chat
9	Harness de verificação — a IA testa-se a si mesma	L3	Evidência sobre confiança: o agente prova o seu trabalho
10	Roteamento de modelos por velocidade e tokens	L4	O modelo certo para cada tarefa, registado e justificado
11	Melhoria orientada por evals / ciclo de critérios de aceitação	L4	Cada ticket tem critérios de aceitação que o agente deve cumprir
12	Orquestra um ciclo autónomo completo de PRD a resultado (>5h)	L5	O agente executa um ciclo de entrega enquanto você supervisiona
13	Desenvolvimento concorrente via worktrees	L4	Múltiplas tarefas correm isoladas, sem conflitos de ficheiros
14	Modo remoto com notificações / controlo por telemóvel	L4	Você dirige agentes de longa duração a partir de qualquer lugar
15	Configura hooks / permissões / portas de segurança	L4	Guardrails determinísticos, zero segredos expostos
16	Revisão de código por IA como processo separado	L4	O autor nunca é o revisor
17	Demonstração de resultado: vídeo demo, relatório interativo	L4	A entrega inclui mostrar o resultado, gerado por IA

As 17 competências em profundidade

Programação agêntica e roteamento de modelos (competências 1, 10)

1. Tenho o Claude (ou equivalente) e não escrevo código manualmente (L2). Você usa um agente de IA como mecanismo principal para escrever, alterar e refatorar código; toca no teclado apenas para correções cirúrgicas, patches críticos ou decisões de arquitetura. KPI: a base é pelo menos 80% do código de rotina através do agente, o forte é 100%, com um mínimo de um PR gerado por IA por semana. Ferramentas: Claude Code como padrão, com Codex, Cursor ou Antigravity como aceitáveis; os artefactos são PRs, logs de agente e resumos de diff. Consulte o mapa de ferramentas de programação agêntica.

10. Roteamento de modelos por velocidade e tokens (L4). Você escolhe o modelo adequado para a tarefa: um modelo de raciocínio forte para arquitetura e depuração, um rápido para implementação, um modelo de código para programação e revisão, um económico para docs e resumos. KPI: para tarefas com mais de 2 horas a escolha do modelo é registada, com um mínimo de 2 tiers de modelo; seniores executam 3+ modelos/rotas mais um log de custo/tempo por PR. Ferramentas: Claude Opus/Sonnet, Codex, modelos do Cursor, Antigravity. Mais sobre roteamento no guia de ferramentas.

Ferramentas e contexto (competências 2, 3, 4)

2. MCP instalado (L3). Você liga o agente a fontes de trabalho: documentação, GitHub, base de dados, Linear/Jira, o browser, Context7, Supabase/Postgres, logs, CI/CD — e compreende permissões e raio de blast. KPI: pelo menos 2 MCP em funcionamento por projeto, 4+ para seniores (incluindo pesquisa de docs/biblioteca e acesso a issues/repositório), com 0 segredos expostos. Ferramentas: .mcp.json, Context7 MCP, GitHub MCP, Supabase/Postgres MCP, Playwright/browser MCP. Consulte o guia de ferramentas.

3. Skills e plugins instalados (L3). Você usa o sistema de skills/plugins como fluxo de trabalho padrão para planeamento, TDD, revisão, depuração, docs, harnesses e deploy. KPI: pelo menos 5 skills ativas, com pelo menos 3 efetivamente usadas nas últimas 5 tarefas; seniores podem criar a sua própria skill. Ferramentas: o plugin Superpowers (marketplace oficial da Anthropic), anthropics/claude-code-skills, Superpowers-V, Claude /skills, skills/plugins do Codex; os artefactos são skills/*/SKILL.md e um log de uso de skills.

4. Memória de projeto como parte do repositório (L3). Você mantém a memória do projeto — arquitetura, regras, convenções, problemas conhecidos, comandos de teste, decisões de biblioteca, factos de domínio — e atualiza-a após tarefas, erros e revisões. KPI: cada repositório de produção tem um AGENTS.md ou CLAUDE.md, com pelo menos 1 atualização após cada PR significativo, e a memória nunca fica desatualizada por mais de 14 dias. Ferramentas: AGENTS.md, CLAUDE.md, .github/copilot-instructions.md, docs/superpowers/*.

Planeamento e pesquisa (competências 5, 6)

5. Planear antes de programar (L3). Antes de qualquer código, o agente estuda o repositório e produz um plano: mapa de ficheiros, riscos, critérios de aceitação, estratégia de testes, estratégia de rollback. Sem plano, sem código. KPI: 100% das tarefas com mais de 2 horas têm um artefacto de plano (objetivo, ficheiros afetados, tarefas, verificação, rollback), e a implementação não pode começar sem um plano aprovado. Ferramentas: Superpowers brainstorming e writing-plans, Claude Plan Mode, a skill de premortem; os artefactos ficam em docs/superpowers/plans/.

6. Skills de playground e deep-research durante o planeamento (L4). Para trabalho complexo ou desconhecido, você investiga primeiro — docs, APIs, concorrentes, dor do utilizador, casos extremos, versões recentes de bibliotecas, riscos de depreciação — e pode construir um PoC ou playground antes da implementação. KPI: para tarefas com mais de 4 horas ou num domínio desconhecido, pelo menos 1 nota de pesquisa mais 3 fontes/docs verificadas ou um PoC, e 0 decisões construídas sobre bibliotecas desatualizadas sem justificação. Ferramentas: Superpowers brainstorming, o Playground Tool e AskUserTool, e Context7 para validação de documentação.

Verificação e qualidade (competências 9, 11, 16)

9. Harness de verificação — a IA testa-se a si mesma (L3). Você deixa de gastar o seu tempo em testes manuais e constrói um harness onde o agente executa testes, evals, build, lint, typecheck e verificações de segurança, e depois corrige-se até passar. KPI: 80% dos PRs têm verificações por evidência (90–95% para seniores), QA manual é no máximo 20% do tempo da tarefa, e um PR sem evidência não está concluído. Ferramentas: Superpowers test-driven-development e verification-before-completion, nizos/tdd-guard, Claude /run e /verify, mais CI, Jest/Vitest/Pytest e Playwright.

11. Melhoria orientada por evals / ciclo de critérios de aceitação (L4). O agente executa um ciclo: implementar, correr verificações, comparar com critérios de aceitação e evals, corrigir, re-executar, produzir evidência. Não "concluído e confiado" mas "provado e aprovado." KPI: cada ticket tem critérios de aceitação; funcionalidades de IA/RAG/agênticas têm 5–20 casos de eval; a taxa de aprovação de evals críticos é de pelo menos 95%, e ciclos falhados são registados. Ferramentas: Superpowers executing-plans, Promptfoo/evals, scripts de eval personalizados em CI; os artefactos são evals/ e acceptance.md.

16. Revisão de código por IA como processo separado (L4). Você separa produção de controlo: o implementador nunca é o revisor. Um revisor verifica a especificação e a qualidade do código; um agente de tester/segurança verifica o harness, regressões e vulnerabilidades. KPI: para qualquer PR além de uma alteração pequena, 100% recebem uma revisão de IA independente; PRs críticos recebem 3 agentes (escritor, revisor, tester/segurança), e fazer merge sem relatório de revisão está proibido. Ferramentas: Superpowers requesting-code-review e receiving-code-review, o plugin oficial Anthropic Code Review (/code-review), revisão do Codex, CodeRabbit.

Orquestração e autonomia (competências 7, 8, 12, 13, 14)

7. Constrói harnesses específicos do projeto; transforma repetições em skills (L4). Quando um problema se repete, você não faz re-prompting — constrói uma skill, plugin ou harness reutilizável (técnico, especialista, QA, segurança, migração, refatoração, docs). KPI: após 2–3 repetições do mesmo problema deve existir uma skill/playbook/harness; um repositório maduro tem pelo menos 3 skills específicas do projeto. Ferramentas: Superpowers writing-skills, test-driven-development, systematic-debugging; os artefactos são SKILL.md, scripts/ e references/.

8. Agentes paralelos / desenvolvimento orientado por subagentes (L4). Você lança um grupo de funções — investigador, planeador, implementador, revisor, tester, revisor de segurança, redator de docs — que permanecem independentes e não contaminam o contexto uns dos outros. KPI: uma tarefa complexa usa pelo menos 3 funções de agente (4–6 para seniores), com pelo menos 1 revisor independente por PR significativo. Ferramentas: Superpowers subagent-driven-development e dispatching-parallel-agents, ruvnet/ruflo, wshobson/agents, subagentes do Claude.

12. Orquestra um ciclo autónomo completo de PRD a resultado, com mais de 5 horas (L5). Você executa um ciclo de entrega: PRD, decomposição, tickets, alocação de agentes, implementação, verificação, revisão, resultado pronto para PR — enquanto você apenas supervisiona e desbloqueia. KPI: uma execução autónoma de 5+ horas com no máximo 3 intervenções humanas, e pelo menos 2 ciclos autónomos concluídos por programador por mês. Ferramentas: Claude Code com Superpowers e Superpowers-V, mais um operator-shell; os artefactos abrangem PRD, tickets, plano, logs de agente, evidência e PR.

13. Desenvolvimento concorrente via worktrees (L4). Você usa espaços de trabalho e branches isolados para que múltiplos agentes/tarefas não colidam; você particiona conjuntos de ficheiros e faz merge dos resultados de forma limpa. KPI: pelo menos 2 worktrees ativos para tarefas sénior (3–5 para trabalho avançado) com 0 conflitos de ficheiros deixados sem documentação. Ferramentas: Git worktrees, branches, tmux, devcontainers, Superpowers using-git-worktrees; os artefactos são um mapa de worktrees e relatório de particionamento.

14. Modo remoto com notificações / controlo por telemóvel (L4). Você inicia agentes de longa duração e dirige-os remotamente: aprovar, redirecionar, inspecionar output e receber notificações quando estão bloqueados ou concluídos. KPI: notificações ativas para tarefas com mais de 1 hora, cada bloqueio gera um alerta, e a resposta a um bloqueio é dentro de 30 minutos durante o horário de trabalho. Ferramentas: Claude Remote Control, Claude mobile/web, e hooks Notification com push para desktop/telemóvel.

Segurança e operações (competência 15)

15. Configura hooks / permissões / portas de segurança (L4). Você constrói guardrails determinísticos: formatar após edição, testes antes de commit, bloquear segredos, proteger .env, exigir aprovação para migrações/eliminações/comandos de produção e auditar chamadas MCP. KPI: 100% dos repositórios têm portas base (scan de segredos, ficheiros protegidos, gate de pré-commit/teste), 0 segredos expostos, e comandos perigosos requerem aprovação. Ferramentas: hooks do Claude (PostToolUse, Notification, hooks de comando), AgentShield, .claude/settings.json, .cursor/hooks.json, proteção de branches, scanners de segredos.

Ofício e universalidade (competência 17)

17. Demonstração de resultado: vídeo demo, relatório interativo (L4). Você não só faz o trabalho — empacota-o e mostra-o: grava um vídeo demo da UI, monta um relatório interativo ou gera uma visão geral narrada. O demo faz parte da Definição de Concluído, em formato interativo e gerado por IA. KPI: cada funcionalidade/PR significativo é entregue com um artefacto de demo (um vídeo abaixo de 3 minutos ou um relatório interativo); para funcionalidades de cliente e resultados de reuniões isso é 100%, e o demo é gerado por uma skill, não manualmente. Ferramentas: claude-ui-recorder (gravar, narrar, renderizar para demo.mp4), skills do Remotion, resumos de áudio do NotebookLM, Loom.

Como as competências se aprofundam por nível

A mesma competência aprofunda-se à medida que sobe. De L2 a L5:

• Programar através do agente: L2 experimenta e verifica tudo manualmente → L3 executa pelo menos 80% da rotina através do agente → L4 ~90%, programação manual apenas nas partes críticas → L5 100% da rotina, definindo a norma da equipa.
• MCP: L2 um MCP básico → L3 2+ MCPs em funcionamento → L4 4+ MCPs cobrindo docs e repositório → L5 governação e política de MCP.
• Skills / plugins: L2 instala prontos → L3 5 ativos, 3 em uso → L4 cria skills de projeto → L5 gere um marketplace interno.
• Memória de projeto: L2 lê CLAUDE.md/AGENTS.md → L3 mantém e atualiza → L4 define o padrão do repositório → L5 define a nível de empresa.
• Planear antes de programar: L2 planeia as grandes tarefas → L3 planeia 100% das tarefas com mais de 2h → L4 desenha o fluxo de trabalho → L5 é dono dos templates de planeamento.
• Deep research / playground: L2 por pedido → L3 para tarefas desconhecidas → L4 nota de pesquisa + PoC como norma → L5 uma plataforma de investigação.
• Harnesses / skills reutilizáveis: L2 ainda não → L3 usa os de outros → L4 constrói os seus próprios (3+) → L5 o harness torna-se um produto.
• Agentes paralelos: L2 um chat → L3 2–3 funções → L4 4–6 funções → L5 orquestração de frota.
• Harness de verificação: L2 verificações manuais → L3 80% dos PRs com evidência → L4 90–95% dos PRs, auto-correção → L5 uma plataforma de evals.
• Roteamento de modelos: L2 um modelo → L3 2 tiers → L4 3+ rotas com log de custo → L5 uma política de roteamento e dashboard.
• Ciclo de eval / aceitação: L2 aceitação manual → L3 CA em cada ticket → L4 5–20 evals em CI → L5 uma plataforma de evals da empresa.
• Ciclo autónomo: L2 ainda não → L3 1–2 horas supervisionadas → L4 5+ horas → L5 orquestração de múltiplos tickets.
• Worktrees: L2 uma branch → L3 1–2 worktrees → L4 3–5 em paralelo → L5 um padrão de particionamento.
• Remoto / notificações: L2 ainda não → L3 alertas básicos → L4 controlo remoto completo → L5 modo operator-shell.
• Hooks / portas de segurança: L2 padrões → L3 portas base → L4 uma política completa → L5 perímetros de segurança da empresa.
• Revisão de código por IA: L2 auto-revisão → L3 revisão de IA independente → L4 divisão escritor/revisor/tester → L5 o padrão de revisão no SDLC.
• Demonstração de resultado: L2 screenshot ou texto → L3 vídeo demo manual → L4 demo automático via skill, 100% das funcionalidades de cliente → L5 um padrão de demo com templates de marca.

As métricas que revelam o seu nível real

Alguns números expõem o seu nível real mais rapidamente do que qualquer auto-avaliação. Estes são os que a ProCoders mede e acompanha ao longo do tempo.

Métrica	L2	L3	L4	L5
% de código através do agente	experimenta	≥80%	~90%, programação manual apenas no crítico	=100% da rotina
Execução autónoma (execução ininterrupta mais longa)	<30 min	1–2 h	5+ h	ciclo de múltiplos tickets
Intervenções humanas / execução	constantes	frequentes	≤3	apenas supervisão
Plano / orçamento de tokens (subscrição que o nível exige)	Pro (~$20)	Max 5× (~$100)	Max 20× ($200)	Max 20× ($200) + API
Log de custo / tempo (rastreio de tokens e tempo por tarefa)	—	—	por PR	dashboard de equipa/projeto

A lógica: quanto maior o nível, mais agentes paralelos, horas autónomas e evals você executa — o que aumenta o consumo de tokens e o tier de plano com ele. A partir do L4 a norma é Max 20× ($200), porque você está a executar vários agentes em worktrees e ciclos de verificação em simultâneo. No L5 adiciona medição de custos (log de custo para dashboard) para que o gasto seja deliberado. (Preços e nomes de planos mudam; isto reflete o mapeamento interno atual da ProCoders, não uma lista de preços oficial.)

Os comportamentos acima são exatamente o que a nossa avaliação classifica. Faça o teste gratuito para ver quais das 17 você já domina e em que nível se situa.