CodeSteer

CodeSteer: Inteligência guiada por contexto.

CodeSteer — operação de engenharia com IA dentro da IDE

Dê direção à IA antes de dar o código.

O volante da sua operação de engenharia com IA. O CodeSteer Squad instala no seu repositório agents, skills, rules, memória e checkpoints para que a IA trabalhe com contexto, sequência e rastreabilidade, sem improvisar arquitetura ou pular etapas.

Framework instalado no repositório. Operação executada dentro da IDE.

IDEs suportadas

Cursor
Cursor
Claude Code
Claude Code
GitHub Copilot
GitHub Copilot
Antigravity (Gemini)
Antigravity (Gemini)
Codex (OpenAI)
Codex (OpenAI)
Kiro (AWS)
Kiro (AWS)
Roda dentro da sua IDE
Organiza contexto antes da execução
Dê direção à IA antes de dar o código.

Pipeline SDD

Teaser do mecanismo interno: contexto, fases e handoffs explícitos governando a execução dentro da IDE.

Definição

Início
Orch.
Know.
Spec
Spec rev.

Checkpoint humano — Spec

✓ Spec

Planejamento

Plan
Plan rev.
Arch.
Tasks

Checkpoint humano — Plano

✓ Plano

Construção & qualidade

Dev
Debug
Test
Review

Verificação & conhecimento

Verif.
Close
Know. upd.

6 fases · 2 checkpoints humanos · 19 etapas

0
agentes
0+
skills
0
fluxos
0
IDEs
Operação na IDE

Como o CodeSteer opera na IDE

Você instala o CodeSteer no repositório e usa a IDE que já faz parte do seu fluxo. A IA lê o contrato do projeto, recebe contexto antes de agir e trabalha por fases com handoffs explícitos.

Sem camada operacional

  • O assistente recebe prompts isolados e perde contexto entre sessões.
  • Arquitetura, regras e decisões ficam implícitas, então a IA improvisa.
  • Ambiguidades e lacunas só aparecem depois que o código já foi escrito.
  • O time depende de memória humana para retomar riscos, testes e decisões.
  • Cada IDE acaba operando de um jeito diferente e difícil de alinhar.

Com CodeSteer na IDE

  • Instala uma camada operacional no repositório: agents, skills, rules e workflows.
  • A IA lê o contrato do projeto antes de agir e respeita o contexto local.
  • Contexto relevante é carregado antes da execução, não só depois do erro.
  • Ambiguidades, gaps e riscos aparecem antes de virar código.
  • O mesmo sistema operacional é projetado para múltiplas IDEs.

O que o CodeSteer injeta no repositório

  • Contrato local do projeto via AGENTS.md, lido antes de qualquer edição
  • Skills e rules operacionais que transformam arquitetura em instrução prática
  • Memória local por execução e conhecimento curado entre sessões
  • Handoffs, checkpoints e gates explícitos para cada fase do trabalho
  • Uma base canônica projetada para diferentes IDEs sem perder alinhamento

Sem CodeSteer vs. Com CodeSteer

De prompt solto para contexto validado e execução governada.

Comparativo entre um fluxo sem CodeSteer e um ciclo governado com CodeSteer.
Sem CodeSteerCom CodeSteer
Prompt solto em cada sessãoExecução por fases com handoffs e checkpoints explícitos
Sem contexto estruturadoContrato do projeto, memória e rules carregados antes da ação
IA adivinha arquitetura e convençõesIA recebe contexto validado e respeita o contrato local
Ambiguidade vira retrabalhoGaps, riscos e lacunas aparecem antes de virar código
Código sem rastreabilidadeCada mudança rastreia até spec → plano → task
Review depende só de disciplina manualReview, verification e policies fazem parte do fluxo
Conhecimento se perde entre sessõesMemória local + conhecimento curado preservam contexto e intenção
8
Policies de governança
9
Tags semânticas (Tagger)
13
Templates de artefatos
3
Agents de engenharia reversa
Dentro da IDE

O mesmo sistema operacional de agents, onde sua equipe já trabalha

CodeSteer roda dentro de Cursor, GitHub Copilot e Antigravity e projeta a mesma base canônica para as demais plataformas suportadas. Você mantém um único modelo operacional no repositório e troca apenas o target.

Cursor

.cursor/

agents, skills, rules, commands

Claude Code

.claude/

CLAUDE.md, agents, rules, skills (workflow-skills incluídas)

GitHub Copilot

.github/

agents, instructions, prompts, skills

Antigravity (Gemini)

.agents/

skills, rules, workflows

Codex (OpenAI)

.codex/

agents, skills, policies, workflows, templates, checkpoints

Kiro (AWS)

.kiro/

agents, skills, steering complementar

Context Engineer

O mecanismo que prepara a IA para agir com segurança

Context Engineer é o mecanismo do CodeSteer que prepara contexto útil, reduz ruído, explicita regras e remove ambiguidades antes da execução.

Em vez de jogar mais prompt em cima da IA, o CodeSteer organiza o contexto certo antes da execução. Isso reduz ruído, explicita contratos e evita que lacunas virem código.

Carrega o contexto certo

Seleciona o mínimo contexto necessário para a tarefa: contrato local, memória da execução, regras e referências relevantes.

Transforma arquitetura em instrução operacional

Converte padrões, workflows e convenções do repositório em agents, skills e rules que a IDE consegue executar.

Expõe ambiguidades antes do código

Detecta lacunas, riscos e contradições cedo, para que a IA não precise adivinhar política, fluxo ou contrato.

Mantém continuidade entre sessões

Conecta memória local da execução com conhecimento curado, para que decisões e aprendizados não se percam no próximo ciclo.

Resultado operacional

Contexto preparado antes do código, não durante o retrabalho

Menos prompt improvisadoMenos refactor cegoMais continuidade operacional
Metodologia

Spec-Driven Development (SDD)

É o mecanismo interno que governa a execução dentro da IDE. Cada fase recebe contexto, produz artefatos rastreáveis e entrega o próximo handoff com checkpoints humanos explícitos.

Mapa do pipeline

Seis fases com ritmo próprio: definição, dois gates humanos explícitos, planejamento, entrega com qualidade e fechamento com memória curada.

SDD • governança por artefatos

Definição

Normalizar o pedido, recuperar conhecimento e fechar a especificação com revisão interna.

SolicitaçãoOrchestratorKnowledge RetrievalSpecSpec Review

Checkpoint humano — Spec

Aprovação explícita antes de qualquer planejamento formal.

✓ Spec

Planejamento

Plano executável, revisão crítica, arquitetura quando necessário e quebra em tarefas.

PlannerPlan ReviewArchitectTask Decomposer

Checkpoint humano — Plano

Validação do plano e escopo antes da execução no código.

✓ Plano

Construção & qualidade

Implementação, diagnóstico quando preciso, testes e gate de code review.

DevDebuggerTestCode Review

Verificação & conhecimento

Aderência a spec/plano, encerramento da execução e promoção do aprendizado curado.

VerificationClosureKnowledge Update

Cada transição produz artefatos em .memory-bank/ — handoffs explícitos, orchestration viva e policies ativas em toda a trilha.

20 agents

A squad completa

Cada agent tem papel, momento de atuação e responsabilidade explícitos. Isso distribui o trabalho, reduz improviso e aumenta previsibilidade em vez de concentrar tudo num único assistente.

Por que uma arquitetura multiagente?

Um agente único tende a misturar planejamento, implementação e revisão na mesma conversa, com mais decisões implícitas e sobrecarga contextual. O CodeSteer separa papéis: quem especifica, quem planeja, quem executa e quem valida entra no fluxo nos pontos certos, com handoffs e gates que mantêm a operação governada.

Orchestrator

Governa workflow, fase, policies e gates Quando atua: Início obrigatório de toda execução

Quick Plan

Consolida discovery, plano e tasks em um único passo Quando atua: Mudanças L1–L2 sem cerimônia formal

Knowledge Retrieval

Recupera conhecimento reutilizável e reduz ruído Quando atua: Antes da especificação

Spec

Converte request em especificação formal Quando atua: Features que exigem definição precisa

Spec Review

Critica a spec para expor ambiguidades e gaps Quando atua: Antes do checkpoint humano

Planner

Produz plano executável (inclui quick-planner) Quando atua: Após spec aprovada ou intake (minor)

Plan Review

Revisa plano para expor falhas de sequência e premissas Quando atua: Antes do checkpoint humano

Architect

Orientação arquitetural para mudanças estruturais Quando atua: Quando fronteiras ou contratos mudam

Task Decomposer

Quebra plano em tarefas executáveis com dependências Quando atua: Após plano aprovado

Dev

Implementa mudanças no código Quando atua: Fase de execução

Debugger

Diagnostica bugs complexos e isola causa raiz Quando atua: Chamado pelo Dev ou em hotfixes

Test

Desenha, adiciona e executa testes Quando atua: Após implementação

Code Review

Gate técnico de qualidade Quando atua: Antes de verificação final

Verification

Gate final de aderência à spec, plano e evidência Quando atua: Trilhas formais

Closure

Encerramento com resumo e candidatos a aprendizado Quando atua: Final de trilhas completas

Knowledge Update

Promove conhecimento validado para a base global Quando atua: Último passo do pipeline

Legacy Mapper

Mapeia arquitetura real de projetos legados Quando atua: Trilha de enablement

Framework Author

Converte discovery em skills específicas do projeto Quando atua: Após discovery

Framework Validator

Valida se skills funcionam com cenários reais Quando atua: Após autoria

E2E Playwright

Automação E2E: discovery, cobertura, geração e estabilização Quando atua: Trilha dedicada

Cada card resume função e momento de atuação; a lista completa dos 20 agents está alinhada ao AGENTS.md do repositório.

9 tags

CodeSteer Tags — documentação viva para IA

Use CodeSteer Tags apenas quando elas adicionarem contexto que não está claro no código, no nome das entidades ou no contrato já expresso pela estrutura do projeto.

Exemplo de Tags

SnippetTypeScript
// @MindContext: Autenticação de usuários para sistema de e-commerce
// @MindFlow: Receber credenciais → Validar formato → Buscar usuário → Verificar senha → Gerar JWT → Retornar
// @MindDeps: bcrypt, jsonwebtoken, UserModel, config/jwt

import bcrypt from "bcrypt";
import jwt from "jsonwebtoken";
import { UserModel } from "@/models/User";
import { JWT_SECRET } from "@/config/jwt";

// @MindSpec: Input: {email: string, password: string} | Output: {token: string, user: User} | Error: 401
export async function login(email: string, password: string) {
  // @MindWhy: Validar formato antes de consultar DB para economizar queries
  if (!email.includes("@")) {
    throw new Error("Email inválido");
  }

  // @MindRisk: Retornar mensagem genérica para evitar enumeration attack
  const user = await UserModel.findByEmail(email);
  if (!user) throw new Error("Credenciais inválidas");

  // @MindDecision: Usar bcrypt.compare (timing-safe) ao invés de comparação direta
  const isValid = await bcrypt.compare(password, user.hashedPassword);
  if (!isValid) throw new Error("Credenciais inválidas");

  // @MindTest: __tests__/auth/login.test.ts:20-65
  return {
    token: jwt.sign({ userId: user.id }, JWT_SECRET, { expiresIn: "24h" }),
    user,
  };
}

Impacto na acurácia

  • Entende o domínio sem precisar adivinhar
  • Respeita decisões anteriores em vez de refatorar sem necessidade
  • Conhece os riscos antes de modificar código sensível
  • Localiza testes e dependências rapidamente
  • Preserva contratos públicos durante mudanças

Catálogo de tags

@MindContext

Contexto de negócio/domínio

// @MindContext: Autenticação de usuários via JWT para e-commerce

@MindFlow

Fluxo lógico sequencial

// @MindFlow: Validar → Buscar → Verificar → Gerar JWT → Retornar

@MindSpec

Contrato Input/Output/Error

// @MindSpec: Input: {email, password} | Output: {token, user} | Error: 401

@MindDeps

Dependências técnicas

// @MindDeps: bcrypt, jsonwebtoken, UserModel

@MindRisk

Riscos técnicos/segurança

// @MindRisk: Duplicação de pedido se timeout — usar idempotency key

@MindWhy

Razão de implementação específica

// @MindWhy: bcrypt.compare é timing-safe por design

@MindDecision

Decisão arquitetural importante

// @MindDecision: Usar bcrypt ao invés de argon2 por compatibilidade

@MindTest

Localização de testes

// @MindTest: __tests__/auth/login.test.ts:20-65
Repository-native

Um repositório que a IA realmente entende

CodeSteer torna o repositório legível para agentes: `_codesteer/` como base canônica, `AGENTS.md` como contrato local e memória segmentada entre execução e organização.

SnippetPlaintext
projeto/
├── _codesteer/                    # ← Pasta canônica do CodeSteer
│   ├── agents/                   # 20 agents especializados
│   ├── skills/                   # 58+ skills reutilizáveis
│   ├── workflows/                # 9 workflows adaptáveis
│   ├── rules/                    # Policies de execução
│   ├── templates/                # Templates de artefatos SDD
│   ├── targets/                  # Configuração por IDE
│   └── docs/                     # Documentação arquitetural
├── .memory-bank/{spec-slug}/     # Memória local da execução
├── .knowledge/                   # Conhecimento organizacional curado
├── AGENTS.md                     # Contrato local do projeto
└── scripts/                      # Bootstrap e higiene operacional

Memória local da execução

  • Artefatos transitórios de uma execução específica
  • orchestration.md com estado do fluxo
  • Request, spec, plan, architecture, task breakdown

Conhecimento organizacional

  • Conhecimento reutilizável e curado
  • Patterns, anti-patterns, lessons, decisões
  • Escrita apenas pelo Knowledge Update Agent

Rastreabilidade completa

SnippetPlaintext
Solicitação do Usuário
  └── 01-request.md (normalizado pelo Orchestrator)
       └── 02-knowledge-retrieval.md
            └── 03-specification.md
                 └── 05-plan.md
                      └── 07-architecture.md
                           └── 08-task.md
                                └── Código implementado
                                     └── Testes automatizados
                                          └── Verificação final
                                               └── Conhecimento atualizado
9 workflows calibrados

Rigor proporcional, não burocracia

O Orchestrator escolhe o menor rito ainda seguro. Cada workflow responde ao risco real da mudança, sem cerimônia genérica.

“O menor rito ainda seguro.”

Selecione a complexidade

L1
L1Mudança trivial, um arquivo, sem contrato
Rito recomendadoquick-plan-delivery

code-review-fast-loop

Review/remediação com task file e relatório canônico

Baixa (L1)

Code Review (08-task + 09-report) → Dev/Debugger → Code Review

quick-plan-delivery

Mudanças pequenas e bem delimitadas

Baixa (L1)

Quick Plan → Dev → Code Review → Verification

feature-delivery

Features novas ou mudanças relevantes

Alta (L3–L4)

Spec → Review → Plan → Architect → Dev → Test → Verification

minor-change-delivery

Mudanças pequenas a médias, não triviais

Média (L1–L2)

Intake → Plan (quick-planner) → Dev → Code Review

epic-delivery

Trabalho multi-fase coordenado

Muito Alta (L4)

Múltiplas fases de feature-delivery

architecture-change

Mudanças estruturais centrais

Muito Alta (L4)

ADR → Architect → Plan → Dev → Verification

bug-debugging

Diagnóstico de bugs

Variável

Reprodução → Causa Raiz → Correção → Validação

hotfix-delivery

Correções imediatas de escopo mínimo

Urgente

Debugger → Dev → Code Review

e2e-automation

Automação Playwright (test-only)

Média

Discovery → Cobertura → Geração → Estabilização

legacy-enablement

Habilitar projetos legados

Alta

Mapper → Author → Validator → Knowledge

Corrigir um typo em um label (L1)

quick-plan-delivery: Quick Plan → Dev → Code Review → Verification. Minutos, sem spec formal e com task artifact unico.

Nova feature de pagamento (L3)

feature-delivery: Spec → Spec Review → checkpoint → Planner → Plan Review → Architect → Task Decomposer → checkpoint → Dev → Test → Code Review → Verification. Ciclo completo com governança total.

legacy-enablement

Projetos legados — engenharia reversa com IA

Terra incógnita vira mapa navegável: três agents especializados e skills de discovery antes de qualquer entrega arriscada.

O desafio (terra incógnita)

  • Inventa arquitetura em vez de respeitar a existente
  • Quebra contratos sem perceber
  • Ignora componentes proprietários
  • Gera código que não se integra ao codebase
Passo 1

Legacy Mapper

  • Entende a arquitetura real do código (não a desejada)
  • Entrypoints, fronteiras, contratos, integrações e hotspots
  • Componentes proprietários e golden paths
Passo 2

Framework Author

  • Converte discovery em skills específicas do projeto
  • Guardrails backend, frontend e fullstack
  • Componentes proprietários como parte do contrato
Passo 3

Framework Validator

  • Valida o skill pack com cenários reais
  • Detecta ambiguidades, gaps e framework drift
  • Libera ou reenfileira a autoria

Entregáveis do enablement

  • Mapa arquitetural do legado
  • Catálogo de componentes proprietários do frontend
  • Skill pack específico do projeto
  • Referências navegáveis para contratos, padrões e anti-patterns
  • Relatório de validação do skill pack
O LLM consegue identificar o componente correto para uma mudança, contratos são preservados, componentes proprietários são usados conforme a convenção local e as skills evitam defaults genéricos de framework.
58+ skills curadas

Especialização por categoria

Skills curtas, especializadas e combináveis para orquestração, design, debugging, testes e governança.

Skills em destaque

squad-orchestration

A mais central

Governa todo o pipeline SDD — da escolha do workflow ao último handoff. Precedência determinística e reenfileiramento por falha.

codesteer-tagger

O diferencial exclusivo

9 tags semânticas inline. A IA lê @MindWhy, @MindRisk e @MindDecision e entende o raciocínio por trás de cada decisão.

legacy-architecture-mapping

O desbravador

Mapeia a arquitetura real de legados — entrypoints, fronteiras, contratos e hotspots — sem inventar o que não existe.

quick-planner

O acelerador

Fast path L1/L2: plano enxuto e verificável sem cerimônia desnecessária.

root-cause-analysis

O investigador

Isola causa raiz com evidência e descarte de hipóteses — prova onde está o bug.

contract-preservation

O guardião

APIs, eventos, schemas e integrações não quebram silenciosamente.

coverage-gap-analysis

O auditor

Lacunas entre risco da mudança e evidência de teste — o que falta provar.

knowledge-retrieval

O memorizador

Snapshot contextual da base .knowledge/ focado na execução atual.

Lista de skills da categoria selecionada com suas respectivas funções.
SkillFunção
squad-orchestrationGoverna pipeline: workflow, fase, policies, handoffs
codesteer-complexityClassifica tasks em L1–L4 para calibrar rigor

Policies que sustentam a operação

execution-policy

Regras globais de execução

context-loading-policy

Carregamento mínimo de contexto necessário

memory-policy

Escrita e leitura de artefatos

review-policy

Critérios de review e requeue

verification-policy

Gate final de aderência

debug-escalation-policy

Quando escalar para Debugger

e2e-automation-policy

Regras da trilha E2E

subagents-protocol

Protocolo de comunicação entre agents

CodeSteer

Instale no repositório. Opere dentro da IDE.

Pronto para operar Cursor, Copilot ou Antigravity com contexto e governança?

Instale o CodeSteer no repositório e use a sua IDE como superfície de execução. O resultado é uma operação de engenharia com contexto, handoffs e checkpoints: spec, plano, execução, review e knowledge update com rastreabilidade.