"This is the only slide that we have," announced Salih Gueler as he kicked off DEV310, the final session of re:Invent’s first day. True to his word, what followed was pure live coding: Building a complete full-stack Generative AI application from scratch in under an hour.

Salih Gueler (Senior Developer Advocate, AWS) and Matt Goldberg (Senior Principal Engineer, AWS Developer Tools) didn’t just talk about building AI applications. They built one live on stage. Their demo showcased the modern developer workflow: Using Kiro (an agentic IDE), deploying with AWS CDK, integrating Amazon Bedrock, and leveraging the newly announced AWS MCP server.

The application? A gaming platform inspired by Salih’s personal need: "I play a lot of games and one thing that I was missing was a platform to exchange games or sell games or see what my friends played. I love Goodreads... I wanted to have a version of that for games."

Watch the full session:

The Evolution of AI-Assisted Development

Before diving into the demo, Salih reflected on how rapidly AI-assisted development has evolved.

Two years ago: Developers marveled at autocomplete creating simple functions like "two plus two" in Java.

Last year (2024): Developers copied and pasted entire applications from ChatGPT or Claude.

Today (2025): We’re living in the age of agents. AI systems can build, deploy, and iterate on applications with minimal human intervention.

But Salih emphasized a critical point: "Agents are as smart as you tell them to be. If I just sit down here and say build me a game platform, they will probably build the most ugliest and most unstructured app that you will ever see. But if you tell more and more information, it’ll be understanding what you mean."

Building the Front End with Kiro

Starting with Context

Salih began by creating a React application with Vite, but immediately addressed a common challenge: large language models have cutoff dates and may not have the latest library versions.

His solution? Model Context Protocol (MCP) servers. He added the Context7 MCP server to provide up-to-date documentation for Shadcn UI, which wasn’t in the knowledge of the LLMs that Kiro uses.

The prompt was simple but specific: Create a React application with Vite, use Tailwind CSS for styling, and leverage Shadcn UI for components. Kiro went to work, calling Context7 to fetch the latest documentation and building the project structure.

The Power of Steering Files

One of Kiro’s most valuable features is steering files: rules that define boundaries for your application. Salih’s steering files included:

• For React projects: Always ensure npm run build\ runs successfully
• For TypeScript projects: Never use any\ type

These rules act as guardrails, ensuring the agent follows best practices and catches errors early. During the demo, when an error occurred, the steering file caught it immediately, and Kiro automatically fixed it.

Iterative Development

Salih broke the development into small, manageable steps:

1. Create the basic React project
2. Add CSS and UI components
3. Create TypeScript interfaces and mock data
4. Build layout components (header, footer, responsive design)
5. Create authentication page
6. Add AI chat functionality
7. Style and polish the UI

Each iteration took approximately 2-3 minutes. The key insight? Break prompts into small steps rather than asking the agent to do everything at once. This approach yields more reliable results.

Describing What You Want

When creating the authentication page, Salih didn’t just say "create a login page." He provided detailed guidance: center the card layout, use specific colors for the signup button, include email and password fields, and ensure responsive design.

"Everything that I explained here... is coming from what I have envisioned," Salih noted. The more specific your vision, the better the agent can execute it.

Deploying to AWS with CDK

The MCP Server Approach

Matt Goldberg took over to demonstrate deployment using his custom MCP server. Rather than breaking deployment into small steps, Matt’s MCP server returned a comprehensive prompt that guided the agent through a complete deployment workflow.

The prompt included a checklist of steps:

1. Make the code base agent-friendly
2. Generate AWS CDK infrastructure
3. Deploy to AWS
4. Set up CI/CD pipeline (for production)

Best Practice #1: Agent-Friendly Code Base

Matt created an agents.md\ file that provides guidance to AI agents working on the project:

• References to design documentation in docs/design/component.md\
• Git commit message guidelines
• Skills for common tasks (like finding logs in CloudWatch)

This documentation helps agents understand the project context and diagnose issues independently. When errors occur during deployment, the agent knows to check CloudWatch logs rather than guessing.

Best Practice #2: Infrastructure as Code

Matt emphasized the importance of using infrastructure as code (specifically AWS CDK) when building with agents:

"If you don’t use infrastructure as code and you ask the agent to add an S3 bucket or add a database, it’s probably going to use the AWS CLI to make calls. But once it’s made the call, when you ask it to do something else, it’s not gonna know that that resource was there."

By using CDK, the agent has complete context about existing infrastructure in the code base. It can see S3 buckets, CloudFront distributions, Lambda functions, and IAM policies, all defined in TypeScript.

The generated CDK code included:

• S3 bucket for front-end assets
• CloudFront distribution for content delivery
• Proper IAM resource policies
• Tags for organization and cost tracking

Best Practice #3: Deterministic Deployment Scripts

Matt created a deploy.sh\ script to ensure consistent deployments. The script includes logic for different environments. Here’s a simplified example of the concept Matt demonstrated:

\``if [ "$ENVIRONMENT" = "preview" ]; then // Use hot-swap fallback for faster local development cdk deploy --hotswap-fallback else // Use full CloudFormation deployment for production cdk deploy fi \``\

The hot-swap fallback feature updates Lambda functions and S3 buckets directly without waiting for full CloudFormation deployments. This is perfect for rapid local iteration. But in production, you want CloudFormation’s guarantees of consistency and correctness.

By putting deployment logic in a script, Matt removed non-determinism. The agent calls the script rather than constructing deployment commands each time, ensuring consistent behavior.

Best Practice #4: CI/CD Pipelines

While not demonstrated in the session due to time constraints, Matt stressed the importance of CI/CD pipelines when working with agents:

"Eventually these agents are gonna do things that you don’t expect. They might have generated code that you didn’t want... Occasionally we get lazy. Occasionally we have teammates that might not have done that. This is gonna happen."

CI/CD pipelines provide safety nets:

• Automated testing to catch bugs
• Security scanning for vulnerabilities
• Cost analysis to prevent runaway expenses
• Code review requirements

These checks ensure that even if an agent generates problematic code, it won’t reach production.

Integrating Amazon Bedrock

With the application deployed, Matt integrated Amazon Bedrock to power the AI chat functionality. He used a prompt (generated by another agent!) that included a detailed checklist:

1. Add Bedrock SDK to the project
2. Create Lambda function for Bedrock integration
3. Update CDK infrastructure
4. Connect front-end to new API
5. Test the integration

The agent worked through each step, updating the CDK stack to include a new Lambda function with proper IAM permissions to call Bedrock. After deployment, the chat interface came alive. Instead of returning mock responses, it now provided real AI-powered game recommendations using Amazon Bedrock.

The AWS MCP Server

Matt demonstrated the newly announced AWS MCP server (launched in preview on Sunday of re:Invent). This remote MCP server consolidates three capabilities:

1. AWS CLI Integration

Helps agents construct better AWS CLI commands with proper syntax and parameters.

2. AWS Documentation

Provides live access to AWS documentation, best practices, and blogs, ensuring agents have up-to-date information about services like AWS CDK.

3. Standard Operating Procedures (SOPs)

Pre-built workflows for common AWS tasks:

• Create EC2 instance profiles
• Set up Amazon Aurora DB clusters
• Configure API Gateway with Lambda
• Add CloudWatch alarms
• Create AWS Budgets
• Secure S3 buckets

Matt demonstrated adding CloudWatch alarms to the Lambda function. The agent called the AWS MCP server, retrieved the SOP for creating alarms, and automatically added error, throttle, and duration alarms to the CDK stack.

Meta Prompting: Prompts for Prompts

One of Matt’s most valuable insights was about meta prompting: using agents to write better prompts for agents.

"I didn’t write this prompt, I’m gonna be honest," Matt admitted, showing a complex deployment prompt. Instead, he had taken rough notes about what he wanted and asked Kiro to turn those notes into a well-structured prompt that an agent would understand.

His advice:

• When an agent doesn’t do what you want, ask: "What would’ve been more clear in my original message to have made you do that?"
• Use agents to refine your prompts before giving them to other agents
• This iterative approach yields more reliable results

Key Takeaways

For Building with Agents

🔧 Break prompts into small steps. Don’t ask agents to do everything at once. Iterate through manageable tasks.

📋 Use steering files. Define rules and boundaries for your project so agents follow best practices automatically.

📝 Be specific about your vision. The more detail you provide about UI, structure, and behavior, the better the results.

🔄 Commit frequently. Have agents commit after each change so you can easily roll back if needed.

🎯 Use MCP servers. Extend agent capabilities with up-to-date documentation and custom tools.

For Deploying to AWS

🏗️ Infrastructure as code is essential. Use AWS CDK or Terraform so agents have full context about your infrastructure.

📜 Create deterministic scripts. Put deployment logic in scripts to remove non-determinism from agent behavior.

⚡ Hot-swap for dev, CloudFormation for prod. Use fast deployments locally but ensure correctness in production.

🛡️ CI/CD pipelines are safety nets. Automated checks catch issues that slip through code review.

📚 Document for agents. Create agents.md\ files with project context, skills, and troubleshooting guidance.

For Working with AWS MCP Server

🔌 Use SOPs for common tasks. Pre-built workflows for CloudWatch alarms, budgets, security, and more.

📖 Live documentation access. Always get the latest AWS service information and best practices.

🤖 Meta prompting works. Use agents to write better prompts for other agents.

The Future of Development

Salih and Matt’s demo showcased a future where developers focus on vision and architecture while agents handle implementation details. But they emphasized that understanding remains critical:

"Everything that we do, we have to understand why and how we do it because agents are as smart as you tell them to be."

The session proved that with the right tools (Kiro, AWS CDK, Amazon Bedrock, MCP servers) and the right practices (small steps, steering files, infrastructure as code, CI/CD), developers can build and deploy production-ready Generative AI applications in minutes rather than days.

As Matt noted when the Bedrock integration worked on the first try: "How many people were surprised that that worked?" The future is here, and it’s surprisingly reliable when you follow best practices.

---

About This Series

This post is part of DEV Track Spotlight, a series highlighting the incredible sessions from the AWS re:Invent 2025 Developer Community (DEV) track.

The DEV track featured 60 unique sessions delivered by 93 speakers from the AWS Community - including AWS Heroes, AWS Community Builders, and AWS User Group Leaders - alongside speakers from AWS and Amazon. These sessions covered cutting-edge topics including:

• 🤖 GenAI & Agentic AI - Multi-agent systems, Strands Agents SDK, Amazon Bedrock
• 🛠️ Developer Tools - Kiro, Kiro CLI, Amazon Q Developer, AI-driven development
• 🔒 Security - AI agent security, container security, automated remediation
• 🏗️ Infrastructure - Serverless, containers, edge computing, observability
• ⚡ Modernization - Legacy app transformation, CI/CD, feature flags
• 📊 Data - Amazon Aurora DSQL, real-time processing, vector databases

Each post in this series dives deep into one session, sharing key insights, practical takeaways, and links to the full recordings. Whether you attended re:Invent or are catching up remotely, these sessions represent the best of our developer community sharing real code, real demos, and real learnings.

Follow along as we spotlight these amazing sessions and celebrate the speakers who made the DEV track what it was!