Meu setup de MCPs para programar com IA

Com certeza já te aconteceu: pedes à tua IA para implementar uma feature, ela começa a escrever código, parece estar a perceber tudo, e de repente… usa uma API que já não existe. Ou faz algo completamente diferente do que tinhas em mente. Ou começa a repetir as mesmas perguntas às quais já respondeste há cinco mensagens.

Por que isso acontece? Muito simples: a IA trabalha às cegas. Não sabe como o teu projeto está estruturado. Não sabe o que decidiste usar e o que não. Não sabe que aquela biblioteca mudou a API na versão 4. Tu sabes, mas ela não.

E isso tem solução. Na verdade, tem várias. Neste post vou contar-te as ferramentas e MCPs que uso para que a IA tenha todo esse contexto desde o início e o resultado seja muito, muito melhor.

Planeia antes de começar a programar: Spec-Kit + Grill-with-Docs

A primeira ferramenta não é um MCP, mas vem antes de tudo o resto. O problema do vibe coding - aquele de “vamos lá, faz-me uma app de gestão de tarefas” e ver no que dá - é que a IA improvisa. E a IA improvisa bem, mas não faz ideia das tuas restrições, das tuas decisões de arquitetura nem da stack que queres usar. No final, acabas por a corrigir constantemente.

A solução chama-se Spec-Kit, do GitHub. Tem mais de 114.000 estrelas, por isso não é propriamente uma ferramenta underground, mas muita gente ainda não a usa porque não percebe bem o que é.

O Spec-Kit dá-te um fluxo de trabalho estruturado para que tu e a IA estejam sempre na mesma página. Instalas com um comando, inicializas o teu projeto e ficas com uma série de slash commands ou skills, consoante o agente que uses.

O fluxo é este:

Crias uma constituição: um ficheiro com as regras inegociáveis do teu projeto - stack, padrões de código, o que precisares.
Usas /speckit.specify para descrever o que queres construir.
Usas /speckit.plan para o plano técnico.
Usas /speckit.tasks para dividir em tarefas.
Quando tudo isso está validado, usas /speckit.implement para a IA começar a implementar.

A diferença em relação a fazer o prompt diretamente é enorme. A IA não inventa: executa uma especificação que tu reviste. É a resposta séria ao vibe coding.

E aqui entra o que combina perfeitamente com o Spec-Kit: Grill-with-Docs, do Matt Pocock. Isto não é uma ferramenta que instalas, é uma skill, uma técnica. A ideia é que, antes de escreveres uma única linha de especificação, a IA te entreviste sobre o teu projeto. Faz-te perguntas para que definam juntos a linguagem do projeto - o que é um “utilizador”, o que é uma “sessão”, o que significa “publicar” no teu contexto específico. E enquanto isso acontece, vai construindo um ficheiro CONTEXT.md com todo aquele vocabulário partilhado.

Por que é que isso importa? Porque a partir desse momento a IA não tem de reinventar os conceitos de cada vez. Sabe exatamente do que lhe estás a falar. E o código que gera vai refletir exatamente essa terminologia. Se procurares “pitches” na tua codebase, aparece tudo o que está relacionado. Sem ambiguidades, sem ter de adivinhar.

A minha recomendação: primeiro Grill-with-Docs para definir a linguagem e o domínio, e depois Spec-Kit para o fluxo de desenvolvimento. Eles andam de mãos dadas.

Dá contexto do teu código: CocoIndex-Code e CodeGraph

Já temos o planeamento. Agora o problema do meio: a IA também não conhece a tua codebase. Quando lhe pedes para alterar algo, tem de ir lendo ficheiro a ficheiro, a fazer greps, a procurar… e isso come tokens aos molhos e demora imenso.

Há duas ferramentas que resolvem isto. São parecidas mas não iguais, por isso vou contar-te as duas e escolhes a que mais te convém.

A primeira é CocoIndex-Code. É um motor de pesquisa semântica de código baseado em AST - ou seja, na árvore de sintaxe do teu código, não em texto simples. Instalas num minuto, zero configuração, e a partir daí funciona como MCP ou skill no teu agente. O que faz é indexar o teu projeto e permitir que a IA encontre código por conceito, não por nome exato. Por exemplo: “onde é que se gere a autenticação dos utilizadores?” E ela encontra. Os próprios benchmarks dizem que poupa 70% de tokens. E é completamente local, sem serviços externos.

A segunda é CodeGraph. Esta vai um passo mais além: constrói um grafo de conhecimento do teu código. Não procura só, compreende relações. Que funções chamam esta outra função? O que é afetado se eu mudar isto? Os benchmarks com Claude Code são bastante impressionantes: 94% menos de tool calls e 77% mais rápido na exploração de código. Também 100% local, usa SQLite. Instalas com npx e configuras o MCP no Claude Code.

Então, qual usar?

Se o teu projeto não é enorme e queres algo que simplesmente funcione desde o primeiro minuto → CocoIndex-Code.
Se tens um projeto grande com imensas dependências entre módulos e queres que a IA compreenda o impacto de cada alteração → CodeGraph.

Não faz muito sentido ter os dois ao mesmo tempo. Escolhe um.

Documentação atualizada de bibliotecas: Context7

Terceiro problema: a IA usa a versão da biblioteca que viu no treino. E isso pode ser de há um ano ou mais. Já te aconteceu gerar código com uma API que já não existe? Isso é exatamente isto.

Context7 resolve isto de forma muito elegante. É um MCP que, quando lhe pedes algo sobre uma biblioteca, vai buscar a documentação oficial atualizada e mete-a diretamente no contexto da IA. Basta adicionares “use context7” ao teu prompt e ela já tem as docs da versão correta.

Instala-se com npx ctx7 setup, autenticas por OAuth e pronto. Tem um tier gratuito mais do que suficiente para uso pessoal.

Gere o teu repo sem sair do editor: GitHub MCP

Este já é mais conhecido, mas incluo-o porque uso diariamente e faz uma diferença brutal. O MCP oficial do GitHub permite-te gerir todo o teu repositório a partir do Claude Code sem abrir o navegador. Criar issues, rever PRs, ver o estado das Actions, fazer commits… tudo em linguagem natural a partir do terminal.

O melhor é que tem um endpoint remoto já pronto, por isso não precisas de instalar nada localmente. OAuth e pronto. E por ser oficial do GitHub, é bem mantido e atualizado.

Automação de navegador: Playwright MCP

Para fechar o bloco principal, o MCP do Playwright, da Microsoft. Se alguma vez quiseste que a IA interagisse com um navegador real - que navegasse num site, preenchesse um formulário, verificasse que a tua app funciona - isto é o que precisas.

O interessante é que não usa capturas de ecrã. Trabalha com snapshots de acessibilidade, ou seja, lê a estrutura da página da mesma forma que um leitor de ecrã o faria. É muito mais eficiente em tokens e mais robusto do que as soluções baseadas em imagens.

É perfeito para testing end-to-end, para automatizar tarefas repetitivas na web ou para fazer scraping de forma fiável.

Bónus 1: Oh My OpenAgent (para utilizadores de OpenCode)

Primeiro bónus, e antes de mais tenho de esclarecer algo importante: esta ferramenta não é para Claude Code. É para OpenCode, que é outro agente de programação no terminal, o rival direto do Claude Code. Se não sabes o que é o OpenCode, explico noutro vídeo, mas basicamente é o mesmo conceito mas agnóstico ao modelo: podes usar Claude, GPT, Gemini…

Se usas OpenCode, existe o Oh My OpenAgent. É um plugin que transforma completamente a experiência: adiciona agentes especializados que trabalham em paralelo, ferramentas de refactoring a nível de AST, ciclos de trabalho automáticos… é como transformar o OpenCode numa equipa inteira de IAs. Tem mais de 62.000 estrelas no GitHub, por isso não é pouca coisa.

E aqui vem o detalhe chave: o Oh My OpenAgent já inclui o Context7 por dentro. Por isso, se usares este plugin, não precisas de instalar o Context7 separadamente. Já vem integrado.

Bónus 2: Coolify MCP (se tens servidor próprio)

O segundo bónus é para quem tem um servidor com Coolify. O Coolify, caso não saibas, é uma plataforma de self-hosting open source - como um Heroku mas teu, no teu VPS. Tenho vídeo no canal sobre isso.

Existe o MCP do Coolify, que embora não seja oficial do projeto, está muito bem mantido. Tem 42 ferramentas para gerir todo o teu servidor: fazer deploy de aplicações, gerir bases de dados, ver logs, gerir projetos… tudo a partir do Claude Code, em linguagem natural. Se já usas Coolify, instala diretamente.

Resumo: o meu setup passo a passo

Vamos a um resumo rápido do que ficas a levar:

Para quê	O que uso
Planear e especificar	Spec-Kit + Grill-with-Docs
Contexto do código	CocoIndex-Code ou CodeGraph
Documentação atualizada de bibliotecas	Context7
Gestão do repo	GitHub MCP
Automação de navegador	Playwright MCP
Se usas OpenCode	Oh My OpenAgent
Se usas Coolify	Coolify MCP

Atenção a uma coisa: não instales tudo de uma vez. Com mais de cinco ou seis MCPs ativos ao mesmo tempo, o agente começa a confundir-se a escolher ferramentas. Começa pelos que mais encaixam no teu dia a dia e vai adicionando.

Conclusão

A IA não tem de trabalhar às cegas. Com o setup correto de MCPs podes dar-lhe o contexto de que precisa para deixar de improvisar e começar a executar sobre especificações claras, código indexado e documentação atualizada.

Não se trata de ter mais ferramentas, trata-se de ter as que realmente usas. Começa por uma ou duas, integra-as no teu fluxo e vai escalando a partir daí. A diferença na qualidade do código que a IA gera é abismal.

Se chegaste até aqui e achaste útil, partilha o post com alguém que esteja a lutar com a IA todos os dias. E se tens alguma ferramenta que não mencionei, deixa-a nos comentários do vídeo - interessa-me imenso.

Referências

O que você achou?

Deixe sua opinião, pergunta ou sugestão. Os comentários são sincronizados com GitHub Discussions .