At this year’s GitHub Universe, we set out to answer a simple question:

What would it take to go from an idea to production in under 30 minutes – using only natural language, your editor, and AI? On stage, we built a cloud-native, intelligent app from scratch using Visual Studio Code, GitHub Copilot, and the Microsoft Agent Framework. In this post, we’ll walk through the journey step-by-step:

1. From spec to code – generating a working app from a simple prompt
2. Adding intelligence and agents – building AI into your workflow
3. Letting an AI SRE keep things humming in production

From spec to code

Modern greenfield apps aren’t just “hosted in the cloud” anymore – they’re born there. They’re expected to be cloud-native and auto-scaling. The table stakes have been raised, and they should now be intelligent and self-healing by default too. But getting there shouldn’t require weeks of trawling docs or endless click-ops.

The only scalable path is to move from writing instructions to defining intent.

That’s where GitHub Spec Kit comes in. You describe what you want – the problem you’re trying to solve, the expected users you’re aiming to support, the outcomes you want to achieve, and your preferences in how to approach the work – and then you let AI generating the scaffolding. We showed how you can initialize a new project using Spec Kit’s CLI and a single high-level prompt:

uvx --from git+https://github.com/github/spec-kit.git specify init Octopets

Then, directly inside VS Code, we guided the build with structured commands:

• /constitution – establish principles like code quality, testing standards, user experience consistency, and performance baselines
• /specify – describe your app; Spec Kit expands it into a product spec .prd file, user stories, and success criteria.
• /plan – choose your tech stack (say, node.js on Azure Functions + React) and get a full technical design.
• /tasks – auto-generate a backlog of tasks (“create an API endpoint” or “set up database schema”, etc.)

From there, Copilot’s implementation phase kicks in, writing and refining each task. You review, steer, and commit. It’s like running a mini AI-powered scrum team.

Because Spec Kit integrates with the Azure Model Context Protocol (MCP) Server, Copilot understands your environment – regions, databases, configs, best practices. This makes it a super powerful tool so that you can use natural language prompts and agentic workflows to:

• Configure cloud resources and CI / CD
• Align code generation with your performance and compliance targets
• Deploy the whole app, end-to-end

What used to take hours of boilerplate setup now happens in minutes. When your intent is unambiguous, AI can generate not just code – but a working, deployable project.

Adding intelligence and AI-powered agents

Next, we made the app smart.

Agents aren’t just functions — they’re systems that perceive, reason, and act. Building them requires orchestration, not just code.

That’s why we built the AI Toolkit for VS Code – so you can have all the tools at your fingertips to build great intelligent applications. From within your code editor, you can use natural language to help you:

• Explore over 200 models in the catalog and select the right models for your use case
• Compose multi-agent workflows
• Add observability and agent traces
• Evaluate response quality and add guardrails

In our demo, we built a vision-and-language agent that takes a pet photo and answers questions about it. Inside VS Code you can literally watch its reasoning trace—calling the vision model, interpreting results, querying the LLM, and returning the final answer. Debugging AI logic now feels as natural as debugging regular code.

One thing that really helps is that the toolkit traces and visualizes an agent’s thought process.

And just like CI for traditional software, you can add CI for your agents using the new Azure AI Agent Evaluation SDK. Every push triggers automated tests against example inputs and expected behaviors. If your agent regresses, the build fails. Continuous integration – but now for AI behavior.

Letting an SRE agent run ops

Shipping is only half the story. Anyone who’s been on call for a cloud service knows the stress of late-night alerts and the grind of troubleshooting issues under pressure. Running production services is where things get real.

Enter the Azure SRE Agent – your tireless, code-capable teammate for operations.

We demo’d this by breaking our own app on stage, causing HTTP 500 errors in one of the APIs. Normally, this would page an engineer and lead to a scramble. But here’s what happened instead – automatically and autonomously:

1. The agent detected a spike in HTTP 500s, parsed the logs, and recognized a pattern from the exceptions
2. It opened a detailed GitHub issue with stack traces and timestamps
3. It diagnosed a NullReferenceException in the location validation code (our code wasn’t handling a missing coordinate properly)
4. It took a mitigation action immediately – scaling out the affected service on Azure Container Apps to reduce the error rate and keep the app responsive.
5. It proposed and committed a fix for the bug and opened a pull request on our GitHub repo with the code change. (Yes, our SRE Agent has coding capabilities, via Copilot!)
6. Finally, once the fix was applied, it verified recovery and closed the incident

Here’s a snippet of the log that the SRE Agent produced, which pretty much tells the story:

1 // SRE Agent: 500 errors detected in Octopets pet-locations-api service
2 // Time: Saturday, 6:17 AM
3 // Action: Analyzed logs and identified NullReferenceException in location validation code
4 // Root cause: Incorrect handling of null coordinates in location filter
5 // Resolution: Applied hotfix to properly validate location parameters before processing
6 // Status: Deployed to production, error rate returned to normal
7 // GitHub Issue #4728 created with full incident report and fix details

This is agentic DevOps in action: systems that not only observe but act—while keeping humans in the loop. The SRE Agent doesn’t replace engineers; it handles the repetitive, high-pressure tasks so you can focus on architecture, quality, and user experience.

The developer’s new role

The craft of software development is evolving – from typing code to articulating intent.

When your source of truth is what you want built, not just how it’s written, AI becomes an amplifier. Developers evolve into orchestrators: designing specs, guiding agents, and validating outcomes. It’s not less creative – it’s more creative.

You spend less time wrestling with scaffolding and ops, and more time shaping ideas that matter.

Developers build the future – and with AI, we can build it faster, better, and with a lot more fun.

We can’t wait to see what you create when your editor becomes an intelligent workspace and your agents become collaborators.

Try it yourself!

All the tools we showed are available today:

• GitHub Spec Kit – open source on GitHub, contributions welcome!
• VS Code AI Toolkit – build and test agents directly in your editor
• Microsoft Agent Framework –learn the basics of how to build and orchestrate agents and workflows and experiment locally
• Azure AI Foundry – the platform for making models, agents, tools, and context work together
• Azure SRE Agent – preview now and start training your tireless AI SRE that can take those 2am live site calls for you

See it in action

Watch as we explain and build this out live in our GitHub Universe presentation, Build apps & agents that scale with VS Code, GitHub Copilot, and Agent Framework.