Do Código para Linguagem Natural. Criando um MVP com Spec-Driven Development e GitHub Copilot
- Erik Aceiro Antonio
- há 21 horas
- 11 min de leitura
TL;DR
Aqui você vai aprender sobre:
As capacidades básicas do Visual Studio Code com IA
Diferenças entre Agent Mode, Plan Mode e Subagentes
MCP (Model Context Protocol)
Impactos no mercado
Exemplo de uso do MCP do Miro no VS Code para Gerar um Diagrama de Fluxos
Vibe Coding como novo Paradigma de Desenvolvimento
Spec-Driven Development como futuro do desenvolvimento assistido por IA
Exemplo de Spec-Driven Development com Behaviour-Driven Development
Entre no Link e acesse a comunidade VIP Architect+ e Arquitetura de Valor
Acompanhe o lançamento do Livro Arquitetura de Valor
Capacidades do Visual Studio Code com IA
O ambiente de desenvolvimento evolui de um editor de código para um orquestrador de agentes.
Dentro do VS Code, o desenvolvimento passa a ser conduzido por capacidades agentivas que combinam planejamento, execução e automação contínua.
Entre as principais capacidades estão o Agent Mode, que executa tarefas complexas em múltiplas etapas, o Plan Agent, responsável por estruturar planos antes da execução, e os Parallel Agents, que permitem dividir o trabalho em subtarefas executadas simultaneamente. Há também suporte para execução em segundo plano, delegação para a nuvem e modernização incremental de código existente.
Além dessas capacidades, o ambiente incorpora uma camada extensível de ferramentas. É possível criar agentes customizados, conectar servidores MCP, definir skills, prompts e hooks, além de estruturar instruções reutilizáveis. O uso de subagentes paralelos permite distribuir tarefas como análise, geração e revisão de código, enquanto o navegador integrado amplia a coleta de contexto.
Esse modelo cria um ciclo contínuo de desenvolvimento orientado por agentes. O fluxo deixa de ser linear e passa a ser iterativo: planejar, construir, testar, revisar, otimizar, delegar, implantar e orquestrar. Cada etapa pode ser executada automaticamente pelos agentes, com o desenvolvedor atuando mais como coordenador do processo do que como executor manual.
Na prática, o ambiente se transforma em uma plataforma de desenvolvimento agentivo, onde o código, as ferramentas e os fluxos de trabalho são coordenados por IA de forma integrada, permitindo automatizar tarefas complexas e acelerar a entrega de software.
Agent Mode - Enfrente tarefas complexas e com múltiplas etapas. O modo agente lê sua base de código, sugere edições em vários arquivos, executa comandos no terminal e responde a falhas de compilação ou testes — tudo em um loop até que o trabalho seja concluído. Refine ainda mais o modo agente para se adaptar ao fluxo de trabalho da sua equipe com extensões do VS Code e servidores MCP (Model Context Protocol).
Agent Plan - O agente de planejamento integrado colabora com você para criar planos detalhados de implementação antes de executá-los. Isso garante que todos os requisitos sejam considerados e tratados antes de qualquer alteração no código. O agente de planejamento não realiza nenhuma mudança até que o plano seja revisado e aprovado por você. Após a aprovação, você pode delegar o plano ao agente padrão ou salvá-lo para refinamento adicional, revisão ou discussões com o time.
Subagents - Ao trabalhar em tarefas complexas, você pode delegar subtarefas para subagentes. Um subagente é um agente de IA independente que executa trabalhos específicos, como pesquisar um tema, analisar código ou revisar alterações, e depois reporta os resultados ao agente principal. Como cada subagente roda em sua própria janela de contexto, ele não adiciona ruído à conversa principal. O VS Code também pode executar vários subagentes em paralelo para acelerar tarefas com múltiplas partes.
Automatizando workflows com MCP (Model Context Protocol)
Estamos entrando em uma fase em que tarefas complexas deixam de exigir o aprendizado de múltiplas ferramentas. Em vez disso, passamos a descrever o que queremos em linguagem natural, e agentes de IA executam o trabalho orquestrando diferentes sistemas.
Esse movimento só é possível porque os modelos de linguagem evoluíram de simples geradores de texto para agentes capazes de raciocinar, usar ferramentas e coordenar ações em múltiplas etapas. Para que isso funcione de forma consistente, surge a necessidade de um padrão de comunicação entre o modelo e os sistemas externos. É nesse ponto que entra o MCP.
O que é MCP
Protocolos, de forma geral, são conjuntos de regras que garantem que sistemas diferentes consigam trocar informações de maneira compatível.
O Model Context Protocol é um protocolo que padroniza a comunicação entre modelos de IA e aplicações externas.
Sem um padrão, cada ferramenta teria seu próprio formato de entrada, saída e invocação de funções. Isso exigiria integrações específicas para cada caso, aumentando drasticamente a complexidade. O MCP resolve esse problema ao definir uma forma única de interação entre o modelo e qualquer ferramenta conectada.
Como o MCP funciona
O MCP estabelece três papéis principais:
Host MCP: o modelo de IA que orquestra a execução
Servidor MCP: camada intermediária que expõe funções das ferramentas
Ferramentas externas: serviços, bancos de dados ou APIs
Quando o servidor é configurado, o modelo recebe um catálogo das funções disponíveis. A partir daí, ele decide qual função utilizar com base na intenção do usuário.
Por exemplo, ao receber uma pergunta, o modelo identifica que precisa consultar uma ferramenta específica, escolhe a função adequada e a invoca por meio do protocolo. O servidor executa a chamada e retorna o resultado ao modelo, que então responde ao usuário.
Sem esse padrão, cada função precisaria ser descrita e integrada manualmente. O MCP elimina essa sobrecarga e transforma a integração em algo mais próximo de plug-and-play.
Cada sistema possui sua própria forma de:
receber parâmetros
executar operações
retornar resultados
tratar erros
Generalizar essas diferenças manualmente é inviável em escala. O MCP cria uma camada comum que abstrai essas variações e permite que o modelo interaja com múltiplos sistemas de forma uniforme.
Isso simplifica a automação e torna possível construir agentes que coordenam várias ferramentas sem necessidade de integrações específicas para cada uma.
Arquitetura resumida
O usuário descreve a tarefa em linguagem natural
O modelo identifica quais ferramentas podem ajudar
O modelo seleciona a função adequada no catálogo MCP
O servidor executa a chamada na ferramenta externa
O resultado retorna ao modelo
O modelo responde ou continua a execução
Esse fluxo pode se repetir várias vezes até que a tarefa seja concluída.
Exemplo de uso com automação de repositórios
Ao configurar um servidor MCP com acesso a repositórios, o modelo passa a ter acesso a funções como:
criar repositórios
ler conteúdo
modificar arquivos
abrir pull requests
automatizar workflows
A partir disso, tarefas passam a ser descritas em linguagem natural, e o agente executa as ações necessárias utilizando as funções expostas pelo servidor.
Implicações técnicas
O MCP amplia a capacidade dos modelos ao permitir que interajam com múltiplos sistemas de forma padronizada. Isso viabiliza agentes mais sofisticados, com execução em múltiplas etapas e integração com diferentes ferramentas.
À medida que mais sistemas adotam esse padrão, a automação tende a se tornar mais simples e previsível.
Implicações de mercado
A adoção de um protocolo comum cria oportunidades para que produtos digitais sejam projetados já compatíveis com agentes. Isso abre espaço para novos tipos de integração e para profissionais especializados em arquiteturas orientadas a agentes.
Com isso, o MCP se posiciona como uma peça importante na evolução de sistemas baseados em IA, conectando modelos, ferramentas e workflows em uma mesma camada de orquestração.
Gerando um diagrama no Miro via MCP no VS Code
Você também pode usar MCP para gerar diagramas automaticamente no Miro diretamente do modo Agent no VS Code. A ideia é conectar o VS Code a um MCP Server do Miro e deixar o agente criar o diagrama a partir de uma descrição em linguagem natural.
Exemplo de configuração no @mcp.json do vsconde.
{
"servers": {
"io.github.miroapp/mcp-server": {
"type": "http",
"url": "https://mcp.miro.com/",
"gallery": "https://api.mcp.github.com",
"version": "1.0.2"
}
},
"inputs": []
}Após configurar o MCP do Miro, o agente passa a ter acesso a funções como criar boards, adicionar formas, textos e conexões. Com isso, basta descrever a arquitetura desejada no chat.
Exemplo de prompt:
Crie um diagrama no Miro que contenha a visão geral do projeto com os principais arquivos e modulos do portfolio.
O agente cria automaticamente:
um board no Miro
os componentes da arquitetura
conexões entre eles
layout visual organizado
Em poucos segundos, o diagrama é gerado e o link do board é retornado no chat.
Esse fluxo permite transformar descrições em linguagem natural em diagramas visuais, integrando o VS Code, o modo Agent e o Miro por meio do MCP.
Vibe Coding como Novo Paradigma de Desenvolvimento
A FIgura a seguir mostra a mudança do desenvolvimento tradicional para o Vibe Coding, destacando como a intenção humana passa a ser mediada.
No modelo tradicional, o humano define a intenção e precisa traduzi-la diretamente em código. Essa mediação é determinística: a pessoa escreve instruções explícitas, o compilador processa e o computador executa.
No Vibe Coding, a intenção continua sendo humana, mas é expressa em linguagem natural. Um modelo de linguagem interpreta essa intenção de forma probabilística, gera o código correspondente e, a partir daí, o fluxo volta a ser determinístico — compilação e execução.
Em resumo:
Antes: humano → código → compilador → execução
Agora: humano → linguagem natural → IA → código → compilador → execução
A principal mudança está na mediação da intenção: sai a tradução manual para código e entra a interpretação probabilística por IA, enquanto o processamento final da máquina continua determinístico.
Fonte: Meske, C., Hermanns, T., von der Weiden, E., Loser, K.-U., & Berger, T. (2025). Vibe coding as a reconfiguration of intent mediation in software development: Definition, implications, and research agenda. IEEE Access, 13, pp. 213242-213259. https://doi.org/10.1109/ACCESS.2025.3645466
Spec-Driven Development como futuro do desenvolvimento assistido por IA
No spec-driven development, o código passa a ser um detalhe de implementação da especificação — não o contrário. A especificação declara a intenção; o código apenas a concretiza.
No Spec-Driven Development, a discussão deixa de ser apenas como escrever código e passa a ser qual é a fonte da verdade do sistema. Existe um espectro que vai do modelo tradicional, centrado no código, até um modelo onde a especificação se torna a principal referência.
Na Figura abaixo, pode-se verificar o extremo Code-First, o código é escrito primeiro e a documentação vem depois. Com o tempo, é comum ocorrer divergência entre o que foi implementado e o que está documentado. Nesse modelo, o código é a única fonte confiável.
Em um estágio intermediário, Spec-First, a especificação orienta a construção inicial, mas não necessariamente é mantida. Ela ajuda no início, porém pode ser abandonada conforme o sistema evolui.
No modelo Spec-Anchored, a especificação passa a ser mantida junto com o código. Há uma tentativa explícita de sincronização entre ambos, reduzindo o desvio entre intenção e implementação.
Por fim, no modelo Spec-as-Source, a especificação se torna a fonte da verdade. O código é gerado a partir dela e deixa de ser editado diretamente. A intenção declarada na especificação guia a implementação, os testes e a evolução do sistema.
À medida que avançamos nesse espectro, aumenta a autoridade da especificação sobre o código. O desenvolvimento deixa de ser centrado na implementação e passa a ser orientado pela intenção declarada, com o código atuando apenas como a materialização dessa especificação.
Fonte: Piskala, D. B. (2026). Spec-driven development: From code to contract in the age of AI coding assistants. arXiv. https://arxiv.org/abs/2602.00180
Workflow com SDD
A Figura a seguir ilustra as principais etapdas dentro do ciclo de desenvolvimento com SDD no Spek-kit do Copilot.
Fonte: Piskala, D. B. (2026). Spec-driven development: From code to contract in the age of AI coding assistants. arXiv. https://arxiv.org/abs/2602.00180
Se você olhar com cuidado, eles seguem uma lógica Princípios → Especificação → Plano → Tarefas → Execução
/speckit.constitution — princípios do sistema
Aqui você define as regras do jogo e como o sistema deve ser pensado.
Exemplos:
arquitetura (DDD, modular, monolito, etc.)
padrões (API-first, event-driven…)
qualidade (testes, segurança, performance)
decisões estruturais
modelo inicial, se é um MVP, PoC ou um projeto complexo existente
modelo green-field ou brown-field
É o que evita que o projeto vire um “big ball of mud”.
Na prática. Você está dizendo: “qual é a filosofia desse sistema?”
/speckit.specify — o que será construído
Aqui entra a especificação com BDD + intenção do produto.
Define:
o problema
o usuário
o comportamento esperado
critérios de aceite
Com SDD é possível combinar a abordagem Behaviour-Driven Development (BDD) para uma narrativa em história de usuário. No BDD ele traz o “Como / Quero / Para”, mas está genérica e não explicita bem o comportamento esperado como uma feature narrativa completa.
Uma narrativa SDD + BDD envolve,
SDD + BDD = Feature + Valor + Contexto + Intenção
/spec Criar uma spec BDD de Product Manager para um website pessoal profissional de um engenheiro de software.
Feature: Website pessoal profissional
Como visitante interessado no perfil de um engenheiro de software
Quero acessar um website com informações sobre sua trajetória, portfólio, artigos de tecnologia, palestras e agenda
Para avaliar sua experiência, conhecer seus projetos, consumir seus conteúdos e acompanhar suas atividades
Gerar histórias de usuário e cenários em formato Given, When, Then para as seções Sobre, Artigos, Palestras e Agenda.É onde você transforma ideia em comportamento.
Na prática: “o que precisa existir e como deve se comportar?”
/speckit.plan — como construir
Aqui sai do “o quê” e entra no “como”.
Gera:
arquitetura sugerida
componentes
fluxos
decisões técnicas
Aqui começa a engenharia de verdade.
Na prática: “qual é o caminho técnico para chegar lá?”
/speckit.tasks — quebrar em trabalho real
O plano vira execução.
Gera:
tasks pequenas
sequenciadas
executáveis
Exemplo:
criar componente X
implementar endpoint Y
adicionar teste Z
Isso elimina ambiguidade.
Na prática: “o que eu faço agora, passo a passo?”
/speckit.implement — execução assistida
Aqui o Copilot entra pesado.
Ele:
cria código
edita arquivos
implementa tasks
É onde a IA deixa de ser “consultor” e vira executor.
Na prática: “vamos construir de fato”
Exemplo
Para rodar o Spec-kit do Copilot no Visual Studio Code você precisa seguir os passos a seguir
Baixe o projeto manualmente ou através do grenciador de pacote
Usando o comando uvx que é um gerenciador de pacotes nativo para Python desenvolvido pela Astral que instala e gerencia pacotes e dependencias localmente de maneira temporária os recursos e dependências.
# Crie um novo projeto - modifique para última release
uvx --from git+https://github.com/github/spec-kit.git@vX.Y.Z specify init <PROJECT_NAME>Em seguida abra o projeto no Visual Studio Code e navegue pelas pastas e dependências para entender o projeto. Dica, peça para o Agent mode do copilot realizar essa tarefa de onborading para você.
Fonte: Próprio autor.
Definir os princípios - Comece alinhando o “espírito” do site.
/speckit.constitution Criar um website pessoal simples, responsivo, com foco em conteúdo e clareza. Arquitetura leve, fácil de manter e evoluir. Separação clara entre conteúdo (artigos, palestras) e apresentação. Performance e legibilidade como prioridades. Crie o essencial para que esse projeto inicie rápido como um MVP.Definir o que será construído (BDD)
/speckit.specify Criar um website pessoal com Sobre, Artigos, Palestras e Agenda. Como visitante, quero conhecer o perfil profissional, ver projetos, ler artigos de tecnologia, acessar palestras e acompanhar agenda, para avaliar experiência e acompanhar conteúdos. Gerar cenários Given, When, Then.Gerar o plano técnico
/speckit.plan Gerar plano técnico para um website pessoal simples usando framework web moderno (ex: Next.js), com páginas para Sobre, Artigos, Palestras e Agenda, estrutura de componentes reutilizáveis e suporte a conteúdo dinâmico.Quebrar em tarefas executáveis
/speckit.tasks Gerar tarefas para implementar o website pessoal com páginas Sobre, Artigos, Palestras e Agenda, incluindo criação de layout, componentes, rotas e estrutura de conteúdo.Implementar
/speckit.implement Implementar as tarefas geradas para o website pessoal.Conclusão
Esse tutorial foi utilizado no GitHub Copilot Dev Day e teve como objetivo servir de guia de referência para a construção de um MVP. Nessa referência exploramos o uso das capacidades básicas do Visual Studio Code com IA, diferenças entre Agent Mode, Plan Mode e Subagentes, MCP (Model Context Protocol), Impactos no mercado, exemplo de uso do MCP do Miro no VS Code para Gerar um Diagrama de Fluxos, Vibe Coding como novo Paradigma de Desenvolvimento, Spec-Driven Development como futuro do desenvolvimento assistido por IA e Exemplo de Spec-Driven Development com Behaviour-Driven Development.
Referências
Böckeler, B. (2025). Understanding Spec-Driven Development: Kiro, spec-kit, and Tessl. Martin Fowler. https://martinfowler.com/articles/exploring-gen-ai/sdd-3-tools.html
Piskala, D. B. (2026). Spec-driven development: From code to contract in the age of AI coding assistants. arXiv. https://arxiv.org/abs/2602.00180
Meske, C., Hermanns, T., von der Weiden, E., Loser, K.-U., & Berger, T. (2025). Vibe coding as a reconfiguration of intent mediation in software development: Definition, implications, and research agenda. IEEE Access, 13, pp. 213242-213259. https://doi.org/10.1109/ACCESS.2025.3645466
Entre para a comunidade VIP Architect+ e Arquitetura de Valor
Acompanhe o lançamento do Livro Arquitetura de Valor
Comentários