Liderança Situacional na Era da IA: Você Já Lidera Agentes e Nem Percebeu

O déjà vu que mudou minha perspectiva

Há alguns meses, eu estava revisando o output (resultado) de um agente de IA que configurei para gerar código em um projeto real. O código estava razoável, mas fora do padrão. Não seguia as convenções do projeto, ignorava decisões de arquitetura que tomamos meses atrás e, sinceramente, parecia aquele código genérico de tutorial que qualquer ferramenta cospe por padrão.

Eu parei. Respirei. E pensei: “Já vivi isso antes.”

Não com uma IA. Com pessoas.

Lembrei de um desenvolvedor júnior que entrou no meu time anos atrás. Brilhante, motivado, cheio de energia, mas que produzia código fora do padrão, ignorava convenções do projeto e trazia soluções genéricas de Stack Overflow. Não porque era ruim, mas porque lhe faltava contexto, maturidade e direcionamento.

E o que eu fiz com ele? Direcionei. Expliquei padrões. Revisei pull requests. Aos poucos, fui dando mais autonomia. Até que um dia, ele estava tocando features complexas sozinho, com qualidade impecável.

Foi aí que caiu a ficha: eu estava liderando agentes de IA exatamente como lidero pessoas. E, mais importante, o modelo que uso para desenvolver liderados funcionava perfeitamente para desenvolver agentes.

Esse modelo tem nome: Liderança Situacional.

O modelo que você já conhece (mas talvez não aplique assim)

A *Situational Leadership* (Liderança Situacional), criada por Paul Hersey e Ken Blanchard, é um dos modelos de liderança mais conhecidos do mundo. A ideia central é simples e poderosa: não existe um único estilo de liderança que funcione para todos. O estilo certo depende da maturidade de quem você está liderando.

O modelo define quatro níveis de maturidade do liderado:

• D1 — Iniciante Entusiasmado: Baixa competência, alto comprometimento. Quer fazer, mas não sabe como.
• D2 — Aprendiz Desiludido: Alguma competência, baixo comprometimento. Começou a ver a complexidade real e perdeu parte da confiança.
• D3 — Capaz, mas Cauteloso: Alta competência, comprometimento variável. Sabe fazer, mas ainda hesita em decisões mais autônomas.
• D4 — Autossuficiente: Alta competência, alto comprometimento. Pronto para receber uma tarefa e entregar com qualidade, sem microgerenciamento.

E para cada nível de maturidade, existe um estilo de liderança correspondente:

1. S1 — Dirigir: Alta direção, baixo suporte. Você diz o quê e como fazer.
2. S2 — Orientar (Coach): Alta direção, alto suporte. Você explica, ensina e acompanha de perto.
3. S3 — Apoiar: Baixa direção, alto suporte. Você está disponível, mas deixa a pessoa conduzir.
4. S4 — Delegar: Baixa direção, baixo suporte. Você entrega a responsabilidade e confia no resultado.

A beleza do modelo é que ele não é estático. A maturidade evolui, e o líder precisa acompanhar essa evolução, ajustando seu estilo. Tratar um D4 como D1 gera frustração. Tratar um D1 como D4 gera desastre.

“Poxa, Hugo, mas isso eu já sei. O que isso tem a ver com IA?”, diz o Leitor

Tudo. Absolutamente tudo!

A grande sacada: agentes de IA também têm níveis de maturidade

Pense no seguinte: quando você abre o Claude Code, o GitHub Copilot ou qualquer agente de código pela primeira vez em um projeto, o que acontece?

Ele não conhece suas convenções. Não sabe quais padrões de arquitetura você adotou. Não entende por que vocês escolheram uma lib em vez de outra. Ele é, literalmente, um D1 — Iniciante Entusiasmado. Tem uma capacidade absurda (o “comprometimento” aqui é o poder computacional), mas zero contexto sobre o seu projeto.

E o que a maioria das pessoas faz? Trata esse agente D1 como se fosse D4. Joga um prompt vago, “crie o endpoint de usuários”, e reclama que o resultado veio genérico, fora do padrão, sem considerar as decisões do projeto.

Isso é como delegar uma tarefa complexa para um júnior no primeiro dia. Claro que não vai funcionar!

A grande sacada está aqui: você precisa evoluir a maturidade do seu agente de IA da mesma forma que evolui a maturidade de um liderado. Isso não acontece com um prompt mágico. Acontece com um processo estruturado de construção de contexto, especificações e padrões.

O agente D1: muito poder, nenhum contexto

Vamos ser honestos: a maioria dos líderes técnicos hoje está preso no estágio D1 com seus agentes de IA. E a culpa não é da ferramenta, é da falta de investimento em maturidade.

Um agente D1 é como aquele desenvolvedor júnior brilhante que acabou de chegar. Ele é capaz? Sim, extremamente. Mas quando você pede “implementa o serviço de notificações”, ele vai entregar algo que funciona, mas que não segue o padrão de services do projeto, usa uma estrutura de pastas diferente, escolhe uma abordagem de error handling (tratamento de erros) que ninguém do time usa e ignora completamente o padrão de logging que vocês definiram.

O que você faz com esse desenvolvedor júnior? Dirige. Senta do lado, explica os padrões, mostra exemplos, revisa linha por linha.

Com o agente D1, é a mesma coisa: você precisa ser extremamente diretivo nos prompts, especificar cada detalhe, e revisar tudo. É trabalhoso, é lento, e muitas vezes você pensa: “era mais rápido eu mesmo ter feito.”

E sabe o que mais? Esse pensamento é exatamente o mesmo que muitos líderes têm com liderados D1. Mas líderes maduros sabem que o investimento inicial se paga exponencialmente depois.

Os frameworks que aceleram a evolução: AgentSkills, OpenSpec e OpenCode

Assim como no desenvolvimento de pessoas em que nós usamos PDIs (Plano de Desenvolvimento Individual), one-on-ones, feedbacks estruturados e programas de mentoria, no desenvolvimento de agentes de IA existem frameworks que estruturam a evolução da maturidade.

Na minha experiência, três se destacam, e usados em conjunto, são transformadores:

AgentSkills: O que o agente sabe fazer

O *AgentSkills* é um framework que define as habilidades e capacidades do agente no contexto do seu projeto. Pense nele como a “matriz de competências” que muitas empresas usam para guiar a carreira dos desenvolvedores.

Quando você estrutura as skills (habilidades) do agente, está dizendo: “Você sabe fazer isso, siga essas regras ao fazer aquilo, e quando encontrar esse cenário, use essa abordagem.”

É o equivalente a mapear as competências de um liderado e definir expectativas claras para cada uma.

OpenSpec: O contexto e as decisões do projeto

O *OpenSpec é onde vivem as especificações do projeto, as decisões de arquitetura, os trade-offs* (prós e contras) que foram feitos, os requisitos não-funcionais, as regras de negócio fundamentais.

Se o AgentSkills é “o que o agente sabe fazer”, o OpenSpec é “o que o agente precisa saber sobre o projeto”.

É como aquele documento de onboarding que você prepara para um novo membro do time, mas estruturado para consumo de uma IA. Inclui:

• Decisões de arquitetura e suas justificativas
• Padrões adotados e por que foram escolhidos
• Contexto de negócio relevante para decisões técnicas
• Restrições técnicas e organizacionais

O papel do OpenSpec no meu fluxo de trabalho é planejar. Antes de qualquer Agente sair codificando, é preciso que existam artefatos (specs) que descrevem exatamente o que precisa ser feito. Aqui é essencial o uso de modelos de IA mais “poderosos” para criação de artefatos ricos e detalhados, para que na codificação possamos economizar.

OpenCode: O executor do trabalho

O *OpenCode complementa o trio definindo como o código deve ser escrito. Não é apenas executor, mas também o orquestrador que escolhe as habilidades necessárias para a execução da demanda, consultando specs e skills*:

• Padrões de nomenclatura
• Estrutura de arquivos e pastas
• Design patterns (padrões de projeto) preferidos
• Como tratar erros, logs, testes
• Tarefas a serem executadas, bem como seu andamento

Pense assim: se o AgentSkills é o currículo do agente, o OpenSpec é a especificação do projeto e o OpenCode é o que da vida a funcionalidade. Juntos, eles transformam um agente D1 em um agente D3 com potencial D4.

De D1 a D4: o caminho na prática

Vou compartilhar como funciona a evolução, baseado na minha experiência com Claude Code e GitHub Copilot.

De modo proposital não pretendo explicar no detalhe cada ferramenta, elas tem uma documentação abrangente e esse não é o objetivo do artigo.

Estágio 1: Dirigir (D1 → D2)

No início, o agente não tem nada. Você começa criando as bases:

• Documente as decisões de arquitetura no OpenSpec: não precisa ser perfeito, precisa existir em openspec/config.yaml. Depois você evolui.

schema: spec-driven

context: |
  Tech stack: .NET 10, ASP.NET Core Web API, C#
  Architecture: Feature Folder with Vertical Slice Architecture
  ORM: Entity Framework Core (PostgreSQL / SQL Server
  Auth: Keycloak with JWT Bearer tokens
  Events: Dapr pub/sub integration events
  Testing: xUnit with Arrange-Act-Assert pattern
  API docs: Scalar (OpenAPI)
  We maintain backwards compatibility for all public APIs
  ... 
  to be continued

rules:
  proposal:
    - Include rollback plan for risky changes
  specs:
    - Use Given/When/Then format for scenarios
    - Reference existing patterns before inventing new ones
  design:
    - Include sequence diagrams for complex flows
  task:
    - Break down implementation into checkboxed tasks.

• Configure o OpenCode: Faça com que ele conheça o que um executor precisa conhecer. Regras do projeto: CLAUDE.md no diretório do seu projeto (usado se não existir AGENTS.md)

# Sample Project

## Architecture Overview

This is a .NET 10 Web API using **Feature Folder with Vertical Slice Architecture** and **CQRS pattern**. 

### Feature Folders (Business Logic)
Each feature is self-contained under `Features/{FeatureName}/` with use-case slices:

Features/{FeatureName}/ ├── {Entity}.cs # Domain entity ├── I{Entity}Repository.cs # Repository interface ├── {Entity}Repository.cs # Repository implementation ├── {Entity}Configuration.cs # EF Core entity config ├── {FeatureName}Controller.cs # API Controller ├── {Entity}ViewModel.cs # ViewModels ...

### Code Standards

- Prefer file-scoped namespace declarations and single-line using directives.
- Ensure that the final return statement of a method is on its own line.
- Use pattern matching and switch expressions wherever possible.
- Use nameof instead of string literals when referring to member names.
- Always use is null or is not null instead of == null or != null.

### Database
- Supports **SQL Server** and **PostgreSQL** (switch via `DatabaseProvider` in appsettings)
- Migrations auto-apply on startup via `ApplyDatabaseMigrations()`
- Local default: SQL Server LocalDB; Docker: PostgreSQL
... 
to be continued

• Defina as primeiras skills no AgentSkills: as tarefas mais comuns que você quer delegar. O OpenCode pesquisa nesse local: .opencode/skills/<name>/SKILL.md

---
name: api-endpoint
description: Creates API controller endpoints with proper routing, authorization, documentation. Use when adding new HTTP endpoints, REST APIs, or when the user asks to create a controller or API route.
metadata:
  author: hugo
  version: "1.0"
---

# API Endpoint Skill

This skill guides the creation of API controllers following the project's patterns with MediatR and proper documentation.

## Controller Structure

Location: `Features/{FeatureName}/{FeatureName}Controller.cs`
... 
to be continued

Neste estágio, você ainda está dirigindo: cada prompt é detalhado, cada resultado é revisado linha por linha, e você frequentemente corrige e ajusta. É trabalhoso, mas é aqui que a fundação é construída.

Observe que os exemplos são simples, nesse estágio o objetivo é entender como o fluxo está sendo executado e se as coisas simples aplicadas estão sendo “absorvidas” pelo agente.

Estágio 2: Orientar (D2 → D3)

Com os frameworks básicos no lugar, o agente começa a produzir resultados mais consistentes, mas ainda precisa de orientação forte. Você:

1. Refine a forma como as especificações são geradas com base nos erros que observa. Não se preocupe em ter as definições de projeto em vários lugares, pois são usadas por ferramentas diferentes em momentos diferentes. Ainda há espaço pra melhorar.
2. Adicione exemplos reais do projeto ao System Prompt do OpenCode. Se as especificações estão corretas, mas a implementação saiu torta, verifique onde faltou contexto para a execução do OpenCode.
3. Expanda as skills com cenários mais complexos. Modelos tem limite de contexto, portanto separar bem as skills e rodar em SubAgents é um trunfo.
4. Dar feedback ao agente através de correções no uso do workflow do frameworks

É como fazer coaching com um liderado D2: “Olha, ficou bom aqui, mas nessa parte você precisa seguir esse padrão. Veja esse exemplo.”

Estágio 3: Apoiar (D3 → D4)

Aqui a mágica começa. O agente já produz código dentro do padrão na maioria dos casos. Seu papel muda: em vez de dirigir cada passo, você revisa e valida. Faz code review do que o agente produziu, assim como faria com um desenvolvedor sênior.

Você ainda está presente, mas a dinâmica inverteu: o agente conduz, você apoia.

Estágio 4: Delegar (D4)

Este é o estágio que mudou minha produtividade. Quando o agente atinge a maturidade D4, com AgentSkills, OpenSpec e OpenCode bem estruturados, você pode delegar tarefas com confiança.

Na minha experiência, quando chego nesse estágio, algo impressionante acontece: os resultados dos Modelos de IA ficam muito similares entre si. Respeitam o estilo de codificação, seguem as decisões técnicas do projeto e produzem código que parece ter sido escrito pelo time.

E tudo isso em um tempo drasticamente menor.

O resultado que comprova o modelo

Quero ser bem direto aqui, porque sei que muitos líderes técnicos são (justificadamente) céticos com promessas de produtividade da IA.

Quando você evolui a maturidade dos agentes com esses frameworks, o resultado não é apenas “código mais rápido”. É código consistente. É código que respeita as decisões do projeto. É código que parece ter sido escrito por alguém que entende o contexto.

Na prática, o que observei foi:

• Modelos de IA (GPT Codex e Claude Opus, obrigado Github Copilot por liberar ambos os modelos em uma única assinatura) produzem resultados muito similares quando recebem os mesmos artefatos de maturidade. Isso mostra que a qualidade do output não depende tanto da ferramenta, mas da qualidade do contexto que você fornece
• O estilo de codificação é respeitado, nomenclaturas, padrões de projeto, estrutura de arquivos
• As decisões técnicas são seguidas, a IA não tenta reinventar a roda quando já existe uma roda definida. Mesmo que não esteja tão redonda, situação da maioria dos projetos de software.
• O tempo de desenvolvimento cai drasticamente, tarefas que levariam dias são entregues em horas ou até minutos, com qualidade de review.

A grande sacada não é qual IA você usa. A grande sacada é o processo de evoluir a maturidade do agente a ponto de poder delegar. Assim como na liderança de pessoas, o investimento em maturidade é o que gera autonomia.

A armadilha que todo líder precisa evitar

Existe um erro clássico na Liderança Situacional com pessoas que se repete identicamente com agentes de IA: tratar todos os contextos com o mesmo estilo.

Assim como um líder que só sabe delegar vai frustrar um júnior, e um líder que só sabe dirigir vai sufocar um sênior, você precisa calibrar sua interação com o agente de acordo com o estágio de maturidade em que ele está para aquele projeto específico.

Repare: eu disse “para aquele projeto específico”. Assim como um desenvolvedor pode ser D4 em uma linguagem e D1 em outra, um agente pode ser D4 no seu projeto backend (onde você investiu nos frameworks) e D1 no seu projeto frontend (onde ele tem pouco ou nenhum contexto).

A maturidade não é global. É contextual.

Outra armadilha: achar que o D4 é permanente. Projetos evoluem. Novas decisões de arquitetura são tomadas. Se você não atualiza o OpenSpec, o OpenCode e o AgentSkills, o agente regride. É como um colaborador que parou de receber atualizações e feedback, ele vai ficar desatualizado.

Como começar amanhã

Se você é um líder técnico e quer aplicar esse modelo, aqui vai um caminho prático:

1. Identifique o projeto mais crítico, aquele onde a produtividade do agente teria mais impacto
2. Comece pelo OpenSpec, documente as 5 decisões de arquitetura mais importantes do projeto. Não precisa ser perfeito, precisa existir
3. Depois, crie o OpenCode, registre as 10 convenções de código mais críticas. Inclua exemplos reais do próprio projeto
4. Configure o AgentSkills, defina as 3 tarefas mais comuns que você quer delegar ao agente
5. Teste com Modelos de IA, dê a mesma tarefa para modelos diferentes, com os mesmos artefatos, e compare os resultados
6. Itere, a cada resultado fora do padrão, se pergunte: “O que faltou no OpenSpec, no OpenCode ou no AgentSkills para que ele acertasse?”

Esse ciclo de iteração é exatamente o ciclo de desenvolvimento de um liderado. Cada erro é uma oportunidade de refinar o contexto. E a cada refinamento, o agente sobe um degrau na escada de maturidade.

A liderança que ninguém te ensinou

Quando estudamos Liderança Situacional, ninguém imaginou que um dia aplicaríamos esse modelo a agentes de inteligência artificial. Mas se pararmos para pensar, faz todo sentido.

Liderar é, em essência, sobre desenvolver capacidade em quem você lidera para que, eventualmente, essa pessoa (ou agente) possa atuar com autonomia. O veículo muda, de pessoas para IAs, mas o princípio permanece:

• Contexto gera consistência
• Investimento em maturidade gera autonomia
• O estilo de liderança precisa se adaptar ao nível de maturidade

Os líderes técnicos que vão se destacar nos próximos anos não serão apenas aqueles que sabem usar Claude Code ou GitHub Copilot. Serão aqueles que entendem que a ferramenta é o meio, e a maturidade é o fim. Que sabem construir AgentSkills, OpenSpec e OpenCode (ou ferramentas futuras) de forma estruturada. Que aplicam, conscientemente, os mesmos princípios de liderança que já funcionam com pessoas.

Porque no final das contas, o problema nunca foi a IA. O problema sempre foi a falta de um processo de maturidade.

E isso, caro leitor, é algo que todo bom líder já sabe resolver. Você só precisa aplicar o que já sabe em um novo contexto.

Conclusão: os pontos que importam

Para não perder o fio da meada, aqui vai o resumo do que conversamos:

• A Liderança Situacional (Hersey & Blanchard) define 4 níveis de maturidade (D1 a D4) e 4 estilos de liderança correspondentes (S1 a S4)
• Agentes de IA também têm maturidade, e ela começa em D1 (sem contexto) em todo projeto novo
• Três frameworks aceleram a evolução: AgentSkills (habilidades), OpenSpec (especificações do projeto) e OpenCode (convenções de código)
• A maturidade é contextual, o mesmo agente pode ser D4 em um projeto e D1 em outro
• Quando o agente atinge D4, ferramentas como Claude Code e GitHub Copilot produzem resultados surpreendentemente similares e consistentes com o estilo do projeto
• A grande sacada não é qual IA usar, mas investir no processo de evolução da maturidade do agente

E aí, você já parou para pensar em que estágio de maturidade estão os agentes de IA nos seus projetos? Está dirigindo, orientando, apoiando ou delegando? Deixe sua opinião nos comentários, quero muito ouvir como tem sido a experiência de vocês liderando essas “novas mentes” do time! 👍🚀😃

Artigos relacionados que podem te interessar:

• Arquétipos da Liderança Técnica
• O papel da empresa e dos líderes na evolução de carreira dos liderados
• Contribuidor Individual ou Gestão de Pessoas