The AWS Developers Podcast

Amazon Web Services

Stay updated on the latest AWS news and insights for developers, wherever you are, whenever you want.

Play

Open in

21 episodes
weekly
Avg 57 min
English

Episodes 21

Newest Oldest Longest

All20 Unplayed20 In progress0 Played0

Counted on this page — what you have heard stays on this device, so it is not something the list can be paged by.

#220
Wednesday · 50 min
Harness engineering: are you controlling your AI agents?
What happens when you strip the model from an agent? Everything left is the harness — and engineering that harness is the new discipline every AI builder needs to master. In this episode, Romain sits down with Mike Chambers, Senior Developer Advocate for Generative AI at AWS, fresh from speaking at the AI Engineers World's Fair 2026. They dig into harness engineering — what it means, why it matters, and how it changes whether you're building or using agents. Mike introduces “slop ops” (his term for unconstrained agent deployments), explains the difference between Strands Agents SDK and AgentCore Harness, and shares why small language models are his next big bet. Key takeaways: • Harness engineering is the discipline around everything left when you remove the model from an agent — including tools, skills, memory, context, observability, evaluations, and the agentic loop • The agent you use and the agent you build require different harness thinking — personal coding agents can optimize for productivity, while production agents must manage context, cost, scale, and reliability • AgentCore Harness removes undifferentiated orchestration code — provide a model, system prompt, tools, and skills through configuration, and the service creates and runs the agentic loop • Avoid “slop ops” — agents should generate infrastructure as code rather than directly creating unconstrained cloud resources, keeping deployments repeatable, reviewable, and owned by the team • Evaluation must evolve alongside an agent — it is difficult to retrofit and cannot be treated as a one-time prerequisite or an afterthought • FOMAT, the fear of missing agent time, can push developers toward unhealthy always-on behavior — faster execution still requires space to think deeply about which problems are worth solving • Kiro for iOS enables mobile-first agentic workflows — Mike uses walks to think, dictate ideas, delegate experiments, and return to working prototypes • Small language models can make focused agentic workloads faster and more cost-effective once teams understand the task well enough to specialize the model With Mike Chambers, Senior Developer Advocate for Generative AI at AWS AI Engineers World's Fair 2026 Strands Agents SDK Strands Agents on GitHub Strands Agents Harness SDK Amazon Bedrock AgentCore Harness Kiro for iOS Latent Space Podcast Mike Chambers on Coursera
#219
July 29 · 1 hr 11 min
How Prime Video's engineers manage agents, not code
Prime Video serves over 300 million monthly customers across 240+ territories and 8,000+ device types. Lilia Abaibourova leads the AI-native transformation there. Prime Video started early, adopting CodeWhisperer as soon as it became available in preview, progressing through Amazon Q Developer, and now using Kiro to put agentic development in the hands of engineers, product managers, and designers. Romain sits down with Lilia to trace that journey — from CodeWhisperer preview to Amazon Q Developer and now Kiro — and explore MCP as the organizational inflection point: teams run two-person pods with full decision autonomy, while managers oversee fleets of agents instead of just headcount. Key takeaways: • Prime Video adopted AI coding tools from day one — CodeWhisperer in preview, then Amazon Q Developer, and now Kiro — building institutional muscle even when specific features were later sunset • MCP was the inflection point for organizational (not just individual) transformation — connecting disciplines end-to-end and eliminating handoff bottlenecks • Code generation is now effectively solved; the new frontier is verification, validation, and code review at scale • Team structures are being actively experimented with — from 2-person pods with full autonomy to larger teams where managers leverage agent fleets • The biggest anti-pattern: waiting on the sidelines for a standard instead of learning through experimentation With Lilia Abaibourova, Principal Product Manager, AI-Native Transformation at Prime Video Lilia Abaibourova at AWS re:Invent 2025 Prime Video Kiro — AI-Powered Development Environment Amazon Bedrock AgentCore Strands Agents SDK — Open Source Introducing the Model Context Protocol (Anthropic) A Return to Two-Pizza Culture — Werner Vogels I, Robot — Isaac Asimov (Lilia's Book Recommendation) Lilia Abaibourova on LinkedIn
#218
July 22 · 53 min
Your AI platform isn't mature — here's what is
I keep hearing 'we're building an AI platform' from enterprises. Most are stitching together demos. Thomson Reuters has been doing AI for 30 years. I sat down with Laura Skylaki (VP AI Engineering, Thomson Reuters) at AWS Summit London — and the gap between what they're doing vs. what most companies call 'AI maturity' is striking. In this episode, Laura breaks down how Thomson Reuters built an enterprise AI platform that serves 30,000 employees across three user personas — from business users to AI creators to developers — with 16 internal services, a $200M/year AI commitment, and a healthy skepticism about when agentic is actually the right answer. Key takeaways: • Evaluation before building — 'It's increasingly harder to retrofit an evaluation framework to an agent capability you already deployed.' They build evaluation benchmarks first to force understanding of the business problem, then build the agent. LLM-as-a-judge with human-in-the-loop calibration — and the judges themselves need continuous regression checks. • Know when NOT to use agents — 'Where we can go and write deterministic code with a logical rule-based approach, I don't think it makes sense to rely on the agent.' Not everything needs to be agentic. When tools exceed a dozen or overlap semantically, specialize into multiple agents instead of overloading one. • Engineers haven't written code manually in 3-4 months — Not experimenting; their AI coding tooling is that far ahead. The shift is toward system design, architecture, and clear structuring for AI assistance. • AWS under the hood with AgentCore and Strands — The platform runs on AWS with API Gateway, Lambda, Step Functions, and Amazon Bedrock AgentCore for agent deployments (runtime, memory, MCP marketplace, code interpreter, browser tools, policy and identity governance). They use Strands Agents SDK to build agents. AgentCore removes the infrastructure burden of long-running agent sessions. • Rethink workflows, don't retrofit — Teams reimagining legacy workflows from scratch for AI rather than bolting generative AI onto systems not built for it. 'If I was building this now for the first time, how would I build it?' The companies that succeed with AI are not fitting it into existing processes — they're redesigning the process through AI. With Laura Skylaki, VP of AI Engineering at Thomson Reuters Thomson Reuters — AI & Technology CoCounsel — AI Assistant for Legal Professionals Amazon Bedrock AgentCore Strands Agents SDK AWS Summit London 2026 Automated Reasoning on AWS Extreme Ownership — Jocko Willink & Leif Babin (Laura's Book Recommendation) Laura Skylaki on LinkedIn
#217
July 15 · 1 hr 7 min
The Delivery Gap: Why 96% of Your AI Code Is Waste
Brenn reached out via LinkedIn to share his experience with AI-driven software development and his new book, The Delivery Gap. Romain read a copy during a business trip and found it deeply aligned with how he guides customers through their AI transformation — and discovered a few new angles worth exploring, including a convergence on cost tracking that maps directly to Amazon's internal cost to serve software metric. In this episode, Brenn — Senior Manager at Delivery Hero (one of the world's largest food delivery companies, operating in 65 countries) — breaks down why most companies fail to see returns from AI coding tools despite individual developers feeling more productive. The core insight: generating code 10x faster means nothing if your verification infrastructure can't keep up. You're just driving 10x faster into a wall. Key takeaways: • The 96% waste problem — If you generate 100 PRs and only 4 make it to production and stay there, the other 96 are waste. Measuring PRs created is meaningless; measure what ships and survives. • The verification triangle — Your delivery speed is governed by verification infrastructure, not generation speed. Banks can't release faster than they can audit. Find your constraint — that's where investment should go, not more coding tools. • Cost per accepted change — Total token costs + human time for all PRs, divided by changes that reach production and stay there. This single metric reveals where waste accumulates and aligns with Amazon's cost to serve software model. • Specs as alignment documents, not source code — Specs align humans and AI on intent and why, not for deterministic code generation. The same spec produces different software each time. Focus on why; let the AI document the what. • Keep agents small and focused — Every MCP server re-injected into context is a cost multiplier per turn. The smallest, tightest, most precisely aimed agent outperforms a Swiss Army knife agent on both cost and accuracy. Apply cost per accepted action to measure agentic ROI. With Brenn, Senior Manager at Delivery Hero & Author of The Delivery Gap The Delivery Gap — Brenn's Book Business Value of Developer Experience Improvements: Amazon's 15.9% Breakthrough Delivery Hero — Global Food Delivery Platform AWS DevOps Agent Kiro — AI-Powered Development Environment The Phoenix Project — Gene Kim, Kevin Behr, George Spafford (Book Recommendation) The DevOps Handbook — Gene Kim, Jez Humble, Patrick Debois, John Willis (Book Recommendation) Warp — AI-Powered Terminal (Brenn's Dev Tool Pick) Brenn on LinkedIn Episode 214 — AWS DevOps Agent: Can Your Pipeline Keep Up with AI?
#216
July 8 · 50 min
What are MCP apps and why should you care?
Most MCP tools today return text. But what if your agent could render a chart, a form, or a full dashboard right inside the chat? That's what MCP apps do — and they're already live on ChatGPT, Claude, and Amazon Quick. Romain sits down with Luigi Pederzani, co-founder of Manufact (the company behind mcp-use, 10K+ GitHub stars), to explore MCP apps — the first official extension of the MCP protocol that lets servers return interactive UI inside AI chat interfaces. Key takeaways: • What MCP apps are — Standard MCP returns text and actions; MCP apps let a server send back a piece of interface (a form, a chart, a dashboard) that renders right inside the chat. It became the first official extension of the protocol this year, growing out of MCP-UI. • UI drives retention — Amplitude saw 2x retention for users exposed to a chart-rendering MCP app versus text-only responses. UI lets software products stay experiences, not just systems of record. • AI apps are the new browsers — Extending Paul Graham's thesis, every software product will be rendered inside AI chats, pulling data and structure from different sources the way we switch tabs today. • Building with mcp-use — Reuse existing React components with minimal changes; the useMcp hook bridges tool arguments (filled by the agent) into component props. The server stays a normal MCP server, the client is the host, and the view runs in a sandboxed iframe. • Interactivity and safety — Iframes are battle-tested and the model-to-server communication is standardized. UI can send events back to the model, so clicking a chart element can trigger another tool call in the chat. OAuth is now standard for production MCP servers. • Tool design best practices — Don't wrap OpenAPI specs directly as MCP. APIs are granular and atomic; MCP tools should serve a task end-to-end so agents don't get confused on ordering. Limit the number of tools exposed; progressive disclosure is now handled by the major clients. • MCP as the A2A protocol — A2A never really landed, and MCP is becoming the agent-to-agent protocol, with companies embedding an agent as a single tool whose main argument is a prompt. • Getting to production — Start with a plain MCP server, then add UI. Skills are now part of the product, and Manufact focuses on agent-readiness of the SDK, testing across clients, deployment, auth, observability (OTEL), and per-tool analytics. • AWS integration — mcp-use can sit on the server side while AgentCore Gateway sits in front to handle enterprise concerns like auth policies and routing. • What's next — Exposing skills directly from MCP servers (rather than decoupled files), and the next stateless-by-default release of the protocol. With Luigi Pederzani, Co-founder of Manufact mcp-use SDK (GitHub) Manufact Cloud Ora.ai — Agent Readiness Scanner Amazon Bedrock AgentCore Gateway — MCP Server Targets AgentMail — Email Infrastructure for Agents Thinking, Fast and Slow — Daniel Kahneman (Luigi's Book Pick) Luigi Pederzani on LinkedIn
#215
July 1 · 56 min
5 Lessons Running AI Agents in Production
John Sexton and Aaron Tummon from Genesys join the show to share hard-won lessons from building and operating Cloud Copilot — an agentic AI layer serving 2 million users across 21+ AWS regions. Genesys powers customer experience for brands like Virgin Atlantic, Vodafone, and HSBC, and their copilot helps admins, supervisors, and agents work more efficiently through natural language. We cover the migration from Bedrock Inline Agents to Strands Agents, multi-agent orchestration with agents-as-tools, context management strategies, cost optimization, and the testing discipline required to keep agentic systems stable at scale. The 5 lessons: 1. Pick a framework that scales with you — Bedrock Inline Agents worked for 12–15 tools but became exponentially flakier beyond that. Strands Agents gave sensible defaults and room to grow without pinch points. 2. Separate orchestration from domain logic — Agents-as-tools creates a clean line between the orchestrator and sub-agents. You can pull functionality in and out per persona without destabilizing the system, and domain teams own their sub-agents independently. 3. Manage context aggressively — Long context windows for the orchestrator, stateless sub-agents, summarizing and sliding-window conversation managers, and strict control over what tools return. Every extra token in context degrades quality and increases cost. 4. Make prompt caching non-negotiable — System prompts, tool definitions, and conversation history rarely change between invocations. Enabling prompt caching delivered significant cost reductions with almost no effort. 5. Test relentlessly because prompt drift is invisible — One prompt change is never a breaking change; five accumulated changes are. A dedicated weekly Sentinel role investigates failures, and full test suites run on every single change. With Aaron Tummon, Software Engineer at Genesys ; With John Sexton, Engineering Manager at Genesys Genesys Cloud — Customer Experience Platform Strands Agents SDK — Open-Source AI Agent Framework Strands Agents — Agent Evaluation SDK Amazon Bedrock — Prompt Caching AWS Lambda — Serverless Compute Aaron Tummon on LinkedIn John Sexton on LinkedIn Thinking, Fast and Slow — Daniel Kahneman (Aaron's Book Pick) Mythos — Stephen Fry (John's Book Pick)
#214
June 24 · 46 min
AWS DevOps Agent: Can Your Pipeline Keep Up with AI?
Tipu Qureshi — Senior Principal Engineer at AWS — joins the show fresh from the AWS Summit NYC 2026 announcements to break down how DevOps Agent is changing the way teams handle operations and release management. After 14 years across EC2, Elastic Load Balancing, AWS Support, and Networking, Tipu moved into the Agentic AI organization to build the DevOps Agent and contribute to Agent Core. We explore how the agent investigates incidents autonomously, integrates with your IDE through Kiro and Claude, and validates code changes in sandboxes before they hit production. Key takeaways: • Reactive and proactive — DevOps Agent triggers on alarms and ServiceNow incidents, but Custom Agents now run on schedules to detect anomalies before they become outages. • Context is king — Customers who integrate their Git repos, metrics, and logs get significantly more accurate root causes. Native GitHub/GitHub Enterprise support plus bring-your-own MCP for custom observability. • IDE integration — Kiro powers and Claude plugins give on-call engineers the full agentic loop: investigate, root-cause, fix, and validate without leaving the editor. • Release management — The new readiness review inspects pipeline stages, past deployment failures, and integration tests to catch issues before merge, while sandbox testing validates proposed fixes. • Multi-cloud support — Native Azure integration via IDC with RBAC, plus bring-your-own MCP and A2A for on-premises and other clouds. • Custom agents and skills — Bring domain-specific knowledge (SAP HANA failure modes, proprietary tooling) via skills from GitHub repos or the assets API, with MCP tools for full customization. • A2A bi-directional — DevOps Agent can be engaged by other agents and can reach out to other agents, enabling multi-agent escalation workflows. • Transparency — Every tool call, skill invocation, and reasoning step is captured in a journal visible to customers via API and the operator console. • What's next — Deeper integrations, automated mitigation actions with safety policies, time-bound rules for agent escalation, and script execution coming soon. With Tipu Qureshi, Senior Principal Engineer at AWS AWS DevOps Agent AWS DevOps Agent — Release Management (Blog) AWS Context — Context Intelligence for Data and AI Agents at Scale AWS Summit NYC 2026 Announcements Tipu Qureshi on LinkedIn
#213
June 17 · 1 hr 6 min
KiroGraph: How a Local Code Graph Saves 80% of Your AI Tokens
Davide de Sio built KiroGraph as a personal side project to stop his AI agent from burning through credits just searching files. It turned into a community-driven, open-source MCP server that gives Kiro (and other AI agents) a semantic map of your codebase — reducing token usage by up to 80%. We dive into the architecture, security, and modules, how everything runs 100% locally, and how the AWS Community shaped the project's roadmap. Key takeaways: • Code graphs vs. grep — Tree-sitter and AST-based graph generation give AI agents a smarter navigation model, eliminating wasteful file searches. • Architecture module — Detects patterns and prevents drift by validating your codebase against its own structural rules. • Security module — Finds exposed secrets and vulnerabilities by tracing the call graph, born from an AWS Summit Milano talk. • Watchman module — Auto-generates Kiro skills from repetitive patterns, building persistent memory for your agent. • 100% local execution — Embeddings run with Nomic and summarization with Gemma 3, no data leaves your machine. • Spec-driven development — Davide built KiroGraph with Kiro itself, using specs to drive the entire development lifecycle. • Portability — Commit the graph to Git and share it across machines and team members. • Community-driven roadmap — CI/CD integration, validation hooks, and container deployment are next. With Davide de Sio, Head of Software Engineering at Eleva KiroGraph — Open-Source Code Knowledge Graph (GitHub) Kiro IDE — AI-Powered Development Environment Tree-sitter — Incremental Parsing System Nomic Embed — Local Text Embeddings AWS Community Builders Program Davide's Blog — Building KiroGraph KiroGraph-Sec — From AWS Summit Milano to a Cybersecurity Feature
#212
June 10 · 1 hr 20 min
Cutting Through the AI Developer Hype
An honest, no-filter conversation about where developers actually stand with AI today. Warren Parad — CTO at Authress, AWS Community Builder, and host of Adventures in DevOps — brings a contrarian 'LLM realist' perspective grounded in daily use, while Romain nuances with enterprise customer observations and the data behind the hype. Together they explore why 93% of devs feel productive but only 4% of enterprises see results — and what separates those who benefit from those who don't. Key takeaways: • AI is a multiplier, not a magic wand — The DORA 2025 report confirms AI amplifies your existing processes. If those processes are broken, AI makes them worse faster. • Spec-driven development beats instant responses — Long-form spec-based workflows let you disengage and return, avoiding the 'TikTok-ification' of software engineering where you're always context-switching. • Sub-agent opacity is a real problem — When agents delegate to sub-agents, you lose visibility into why decisions were made. Custom agents with explicit permissions and tool access help contain the blast radius. • Greenfield work is where LLMs struggle most — LLMs excel at refactoring and targeted feature changes where engineers already know the implementation. Open-ended new projects lead to scope creep and unfinished work. • Critical thinking erosion is measurable — Microsoft/Carnegie Mellon research shows knowledge workers self-report reduced cognitive effort when using AI. The long-term implications for engineering judgment are concerning. • Governance first, tools second — Enterprises that succeed with AI spend the first month on governance, AI registries, and codifying best practices before enabling tools across teams. • Software development was never the bottleneck — Unless AI solves handoffs, knowledge management, and organizational alignment, faster coding alone won't compress your roadmap. With Warren Parad, CTO at Authress & Host of Adventures in DevOps Authress — Login and Access Control for B2B Adventures in DevOps Podcast Warren Parad — Personal Site DORA 2025 Report Microsoft/CMU — The Impact of Generative AI on Critical Thinking Forgejo — Self-Hosted Git with Federation Rig — Rust AI Framework AWS Kiro — AI-Powered Development Environment AWS Strands Agents SDK Simon Wardley — Wardley Maps & PST Framework The Phoenix Project — Gene Kim, Kevin Behr, George Spafford The Magicians — Lev Grossman (Warren's Book Pick)
#211
June 3 · 44 min
Why Your Agent Evaluations Will Fail You (and How to Fix Them Before Production)
Anthropic deprecated Sonnet 3.5. Some of Xelix's pipelines migrated smoothly. Others broke — and customers noticed within hours. What separated the two? Evaluation. Paul Solomon and James Price Farr have spent 5+ years building AI systems that process millions of invoices for enterprise customers. In this episode, they share the evaluation-first framework that now saves them every time a model changes, an orchestration layer fails, or an agent picks the wrong tool. Key takeaways: • Evaluation-first, not evaluation-after — Retrofitting evaluation on an agent already in production is painful. Build your eval pipeline before you build the agent. • Monitor tool calls, not just outputs — If the agent isn't selecting the right tools, nothing downstream will be correct. Tool-call monitoring is your leading indicator. • 3 tiers of automation — Not everything needs an agent. Rules-based → single LLM call → agentic system. Pick the simplest tier that solves the problem. • Extended thinking tames token explosion — After migrating to newer, more verbose models, enabling extended thinking (with a budget) moved reasoning out of expensive output tokens and brought costs back under control. • Human-in-the-loop by default — Start with human review on every output, then earn trust toward touchless automation as customers gain confidence. • Pragmatism wins — Use whatever technology works best for the problem. Not every feature needs an LLM. Recorded live at AWS Summit London. With Paul Solomon, Head of AI Engineering at Xelix ; With James Price Farr, AI Engineering Team Lead at Xelix Xelix — AI-Powered Accounts Payable Platform Strands Agents SDK — Open Source Amazon Bedrock — Managed LLM Inference Amazon Bedrock AgentCore Strands Agents — Steering Files and Hooks for Agent Accuracy (Claire Liguori) Amazon SageMaker Fast.ai — Practical Deep Learning Courses (Book Recommendation) The Fifth Risk — Michael Lewis (Book Recommendation) Neurosymbolic AI and Automated Reasoning on AWS Kiro — AI-Powered Development Environment
#210
May 27 · 1 hr 1 min
5 Quality Gates That Let You Ship 250% Faster with AI Coding Agents
How do you give 120+ engineers AI coding agents — and NOT break production? Ryan Cormack, Principal Engineer at Motorway and AWS Community Builder (recognized as a Renaissance Developer by Werner Vogels), shares the exact system his team uses to ship 250% more deployments while keeping quality high. In this episode, we break down the 5 quality gates that let Motorway's engineering teams move faster without sacrificing reliability: spec-driven planning to catch design issues before a single line of code is written, AI-assisted code review to verify code matches the plan, deterministic tests (unit + integration) as an automated safety net at the boundary, cyclomatic complexity checks to keep code maintainable, and human review as the final gate that stays human. Ryan explains how cross-functional DevOps teams — organized like Amazon's two-pizza teams with full end-to-end ownership — enable faster AI adoption. He walks through running parallel agents to explore multiple solutions simultaneously, building custom tools on top of ACP (Agent Client Protocol), and sharing agent configurations across 120+ engineers via a Git + S3 pipeline. The conversation also covers the Renaissance Developer mindset that Werner Vogels introduced at re:Invent 2024: curiosity, ownership, systems thinking, communication, and experimentation. Ryan shares how Motorway embraces this philosophy by encouraging engineers to build their own tools, experiment with new technologies in parallel, and focus engineering time on design and planning rather than writing code. Whether you are scaling AI coding assistants across a large engineering org, building quality gates for agentic development, or rethinking how your team ceremonies and processes should evolve in the age of AI, this episode offers a practitioner's blueprint from someone delivering measurable results: 250% more deployments, 4x engineering throughput, and no uptick in production incidents. With Ryan Cormack, Principal Engineer at Motorway Ryan Cormack — Personal Website Ryan Cormack — Medium Ryan Cormack — GitHub ACP and Strands — An Open Source Match (Ryan Cormack) Motorway — UK's Fastest Growing Used Car Marketplace Werner Vogels — The Renaissance Developer (re:Invent 2024) The Phoenix Project — Gene Kim, Kevin Behr, George Spafford The Unicorn Project — Gene Kim The Architect Elevator — Gregor Hohpe Strands Agents SDK — Open Source Kiro — AI-Powered Development Environment
#209
May 20 · 49 min
Dark Factories: Why Your AI Coding Setup Is Already Outdated
You're using Copilot. Maybe you've tried Cursor or Claude Code. But what if that's already the tail end of the AI wave? In this episode, Romain sits down with Christian Weichel, CTO and co-founder of Ona (formerly Gitpod), to explore 'dark factories' — autonomous AI agents that pick up work, write code, open PRs, and ship fixes while you sleep. No laptop required. Chris shares how his team of ~20 engineers went from 450 open pull requests to a streamlined, auto-approving system — all while staying SOC 2 compliant. He walks through the 3 stages of AI in the SDLC (better autocomplete → software conductor → background agents), the governance model that makes background agents safe for regulated enterprises, and why terminal-based coding agents' days are numbered. The conversation covers the risk ladder approach to auto-approving PRs, how isolated cloud development environments provide the security and autonomy agents need to operate safely, multi-agent code review with meta-reflection, and why accelerating implementation without accelerating review creates a bottleneck that breaks teams. Christian also shares his perspective on architecture governance, cognitive load management when running parallel agents, and why the future of IDEs will look different but won't disappear. Whether you are adopting AI coding assistants, building governance frameworks for agentic development, or exploring how background agents can automate your SDLC end-to-end, this episode offers a practitioner's view from someone who's been shipping with autonomous agents in production. With Christian Weichel, CTO & Co-founder, Ona (formerly Gitpod) Christian Weichel — Personal Site Ona — Background Agents for Software Development The Phoenix Project — Gene Kim, Kevin Behr, George Spafford The Unicorn Project — Gene Kim The Origins of Efficiency — Matt Might (Book Recommendation) The Rise of the Software Conductor The Software Conductor's Handbook LM Studio — Run Local LLMs Ollama — Run Local Models
#208
May 13 · 50 min
LLM-as-a-Judge, Quotation Fidelity, and A/B Testing Models: AI Publishing at Scale
What happens when a data scientist builds a generative AI proof of concept — and it scales to 700,000 articles and 4 billion page views? Recorded live at AWS Summit London, Romain is joined by Lewis James, Senior Data Scientist at Reach PLC — the UK's largest commercial publisher with over 120 brands including the Mirror, the Express, and OK Magazine. Lewis shares the full journey from GPT-2 experiments to a production AI publishing platform called Launchpad that now assists with 20–30% of the portfolio's daily article output. We explore how the team earned journalist trust by focusing on mundane tasks first, how they built multi-model pipelines with quotation fidelity checks to avoid misquoting, and why working backwards from users — not pushing technology — drove adoption where others failed. The conversation covers the technical evolution from prompt engineering to fine-tuning, model distillation, and agentic workflows built with the Strands Agents SDK running on Amazon Bedrock AgentCore. Lewis also introduces the concept of 'vibe publishing' — giving journalists a chatbot interface with more creative freedom — and discusses how evaluation strategies differ when you're measuring editorial tonality versus factual accuracy. Whether you are building AI-assisted content pipelines, navigating enterprise AI adoption, or thinking about how to earn user trust for generative AI tools, this episode offers a rare look at what three years of production generative AI looks like at massive scale. With Lewis James, Senior Data Scientist at Reach PLC Reach PLC — UK's Largest Commercial Publisher Amazon Bedrock AgentCore Strands Agents SDK — Open Source Amazon Bedrock Model Distillation Amazon Bedrock LLM-as-a-Judge Evaluations The 4 Stages of Psychological Safety — Timothy R. Clark Werner Vogels — The Renaissance Developer (re:Invent 2025)
#207
May 5 · 51 min
AI Agents, Friction, and the Future of Developer Experience
AI agents are transforming how we write, test, and ship software — but are they actually improving the developer experience? Recorded live at AWS Summit London, Romain is joined by Tomasz Ptak — AWS AI Hero and Senior Engineer at Duco — for a candid conversation about developer experience friction in the age of AI agents. We explore what happens when teams adopt AI coding assistants without thinking about the developer workflow holistically — from context overload and broken feedback loops to the hidden costs of AI-generated code that nobody reviewed. The conversation draws on Werner Vogels' 'Renaissance Developer' keynote from re:Invent 2025, where he argued that developers need to be broader thinkers, not just faster coders. Tomasz shares his perspective on what great developer experience looks like when AI agents are part of the picture, how the AWS AI League is helping developers build real agent skills through gamified competition, and why critical thinking about AI adoption matters more than blind acceleration. We also discuss psychological safety in engineering teams — drawing on Brené Brown's work on vulnerability — and why the best developer tools are the ones you barely notice, as Don Norman taught us decades ago. Whether you are building AI agents, designing internal developer platforms, or evaluating how AI tools fit into your team's workflow, this conversation offers a grounded, human-centered perspective on reducing friction and improving developer experience in 2026 and beyond. With Tomasz Ptak, AWS AI Hero, Senior Engineer at Duco AWS AI League — Gamified AI Competition AWS AI League 2026 Championship — BuilderCenter Tomasz Ptak's Blog — mediocr.is Frictionless — Nicole Forsgren & Abi Noda Think Again — Adam Grant Rising Strong — Brené Brown The Design of Everyday Things — Don Norman Tomasz Ptak — AWS Machine Learning Hero
#206
April 29 · 46 min
The Evolution of Microservices: Agents, Monoliths, and the Patterns That Never Die
Recorded live at AWS Summit London, Matheus Guimaraes — Senior Developer Advocate at AWS and microservices specialist with over 25 years in tech — joins Romain to explore how agentic AI is reshaping the way we think about distributed systems architecture. From Martin Fowler's 2014 definition to agentic microservices in 2026, Matheus unpacks why the same distributed systems patterns — single responsibility, context dilution, failure modes — keep resurfacing in every new wave of architecture. The conversation covers the monolith vs. microservices debate as a deliberate architectural choice rather than accidental spaghetti, modular monoliths with Spring Modulith, and how AI coding assistants like Kiro are changing the architect's role from writing boilerplate to making higher-order design decisions. Matheus introduces his concepts of 'smart APIs,' 'monolithic agentic microservices,' and 'specialized agentic microservices' — and explains his talk 'Is It Agent?' on when to reach for agents vs. traditional applications. We dig into the serverless primitives purpose-built for agentic workloads: Amazon Bedrock AgentCore Runtime for long-running agent processes, AWS Lambda Durable Functions for multi-step workflows, and the AWS DevOps Agent for autonomous incident response. We also explore integration patterns with MCP and Google's A2A protocol, the 'lost in the middle' problem with context dilution, and why critical thinking about AI adoption matters more than ever. Whether you are decomposing a monolith or designing your first agentic system, this conversation connects the dots between a decade of microservices wisdom and the agentic future. With Matheus Guimaraes, Senior Developer Advocate, AWS Martin Fowler — Microservices (2014) Spring Modulith Amazon Bedrock AgentCore AWS Lambda Durable Functions AWS DevOps Agent Model Context Protocol (MCP) Agent-to-Agent Protocol (A2A) — Google Kiro — AI-Powered Development Environment Building Microservices — Sam Newman Monolith to Microservices — Sam Newman The Art of Game Design: A Book of Lenses — Jesse Schell Matheus Guimaraes — codingmatheus.com
#205
April 22 · 51 min
How Can AI Agents Cut Support Resolution Time by 95%?
CyberArk's support team was drowning in logs. With 40+ products across SaaS and self-hosted environments, each generating logs in different formats, support engineers were spending days just preparing data before they could even start investigating a customer issue. Complex cases took up to 15 days to resolve. Moshiko Ben Abu, a Software Engineer at CyberArk — now part of Palo Alto Networks — built an AI-powered system that changed all of that. In this episode, he walks us through the full architecture: replacing manual regex parsers with AI-generated grok patterns using Amazon Bedrock and Claude, storing structured data in Apache Iceberg tables via PyIceberg with automatic schema evolution, and querying everything through Athena — all while keeping PII masked and data encrypted in S3. But the real breakthrough came with agents. Moshiko describes how he moved from single-product Bedrock agents to a swarm of specialized AI agents built with the Strands framework, where agents investigating product A can autonomously call agents for product B and C to trace root causes across the entire stack. Cases that took 15 days now resolve in hours. Simple cases drop from 4-6 hours to 15-30 minutes. Engineers handle 4x more cases per day. We also dig into the security layer — Cedar policies and Amazon Verified Permissions for agent authorization, the identity integration with AgentCore, and what's coming next: S3 Tables, AgentCore in production, and cross-platform agent collaboration with Palo Alto. Moshiko's advice for developers getting started? Learn IAM first, then compute, then databases — and write everything in CDK. With Moshiko Ben Abu, Software Engineer, CyberArk (a Palo Alto Networks company) How CyberArk Uses Apache Iceberg and Amazon Bedrock to Deliver up to 4x Support Productivity — AWS Blog Apache Iceberg on AWS PyIceberg — Apache Iceberg Python Library Amazon Bedrock AgentCore Strands Agents — Open-Source Agentic Framework Cedar Policy Language Amazon Verified Permissions Amazon S3 Tables Kiro — AI-Powered Development Environment AWS CDK (Cloud Development Kit) Ran the Builder — Ran Isenberg's Serverless Blog Ran Isenberg — AWS Serverless Hero
#204
April 14 · 1 hr 10 min
Spec-Driven Development and the AI Unified Process — with Simon Martinelli
Simon Martinelli is a Java Champion, Vaadin Champion, and Oracle ACE Pro with over three decades of experience building enterprise software. In this episode, he introduces the AI Unified Process (AIUP) — a methodology he created that combines the rigor of the Rational Unified Process with modern AI-assisted development, and makes a compelling case for why specifications, not code, should be the source of truth. We explore the difference between system use cases and user stories, and why use cases — with their actors, preconditions, main flows, alternative flows, and business rules — give AI agents far better structure to generate working code. Simon walks through the four phases of AIUP: Inception, Elaboration, Construction, and Transition, showing how specs, code, and tests evolve together iteratively while staying in sync. On the architecture side, Simon advocates for Self-Contained Systems over microservices — vertical slices that include UI, backend, and database together, reducing cognitive load for both developers and AI agents. His tech stack of choice is Vaadin for full-stack Java UI, jOOQ for type-safe explicit SQL, and Spring Boot as the application framework — a combination he argues is uniquely well-suited for AI-driven development because it keeps everything in one language with no hidden behavior. We also dig into testing strategies with Karibu Testing for browserless Vaadin tests and Playwright for end-to-end coverage, how teams of two working on bounded contexts with trunk-based development are shipping faster than ever, and why the era of AI is bringing back the Renaissance developer — the generalist who understands the full stack from business requirements to production deployment. With Simon Martinelli, Java Champion, Vaadin Champion, Oracle ACE Pro — Software Architect & Trainer AI Unified Process (AIUP) Spec-Driven Development with AI — Simon Martinelli Why Vaadin Is Perfect for AI-Driven Development Why Vaadin and jOOQ Are a Natural Fit for AI-Driven Development Browserless Testing of Vaadin Applications with Karibu Testing Goodbye Microservices, Hello Self-Contained Systems — Simon Martinelli Self-Contained Systems Architecture Vaadin Framework jOOQ — Type-Safe SQL in Java Karibu Testing — GitHub Playwright — End-to-End Testing Simon Martinelli's Blog
#203
April 8 · 1 hr 7 min
Neurosymbolic AI: Combining GenAI with Mathematical Proof — with Danilo Poccia
What if you could combine the creative power of generative AI with the mathematical certainty of formal verification? In this episode, Danilo Poccia — Principal Developer Advocate at AWS — breaks down automated reasoning, a field of AI that has been quietly powering critical AWS services for years and is now becoming essential for production AI systems. We explore why generative AI alone is not enough for high-stakes applications, and how automated reasoning provides mathematical proof — not probabilistic guesses — that your AI agents are following the rules. Danilo traces the roots of automated reasoning back to the 'symbolist' branch of AI, explains how AWS has used it internally for years to verify S3 bucket policies, encryption algorithms, and network configurations, and shows how it now converges with neural networks in what researchers call neurosymbolic AI. On the practical side, we dig into Amazon Bedrock Guardrails with Automated Reasoning checks — the first and only generative AI safeguard that uses formal logic to verify response accuracy. Danilo walks through how developers can use policy verification for agentic systems and tool access control with Cedar, and how AgentCore Gateway fits into the picture for managing MCP-based tool interactions at scale. We also cover the open source landscape: Dafny for verification-aware programming, Lean as a theorem prover, Prolog for logic programming, and the growing ecosystem of MCP servers that bring these capabilities into everyday development workflows. Whether you are building AI agents for production or just curious about what comes after prompt engineering, this conversation will change how you think about AI reliability. With Danilo Poccia, Principal Developer Advocate, AWS Developer Relations Amazon Bedrock Guardrails — Automated Reasoning Checks Automated Reasoning Checks Rewriting Chatbot — Reference Implementation Amazon Bedrock Samples — Responsible AI on GitHub A Gentle Introduction to Automated Reasoning — Amazon Science What is Automated Reasoning? — AWS Cedar Policy Language — GitHub Amazon Bedrock AgentCore Gateway Dafny — Verification-Aware Programming Language Lean — Theorem Prover and Programming Language How the Lean Language Brings Math to Coding — Amazon Science How AWS Uses Formal Methods — Amazon Science Open Source MCP Servers for AWS Danilo Poccia on the AWS News Blog
#202
April 1 · 47 min
Agent-Native Serverless Development with Shridhar Pandey
In this episode, we sit down with Shridhar Pandey, Principal Product Manager on AWS Serverless Compute, to explore how the serverless team is pioneering agent-native development. Shridhar walks us through a remarkable March 2026 where the team shipped three major capabilities in just three weeks — a Kiro Power for Durable Functions, a Kiro Power for SAM, and a serverless agent plugin now available in Claude Code and Cursor. We trace the journey from 18 months of traditional developer experience improvements — local testing, remote debugging, LocalStack integration — to the realization that AI agents are fundamentally changing how developers build, deploy, and operate serverless applications. The serverless MCP server, now approaching half a million downloads, laid the foundation, and the new agent plugin builds on it with four specialized skills covering Lambda functions, operational best practices, infrastructure as code with SAM and CDK, and durable functions. Shridhar shares his thinking on agent personas — developer agents, operator agents, and platform owner agents — and how the team is applying an 'AX' (agent experience) lens to every feature they ship. We also take a candid detour into how AI has transformed his own work as a product leader: research that took weeks now takes hours, document cycles that spanned days now wrap up in a single sitting, and a fleet of agents handles daily digests and data analysis for the team. Open source runs through everything — the MCP server, the plugin, the public Lambda roadmap on GitHub — and Shridhar invites the community to shape what comes next. With Shridhar Pandey, Principal Product Manager, AWS Serverless Compute AWS Serverless MCP Server Agent Plugins for AWS — GitHub Introducing Agent Plugins for AWS — Blog Post AWS SAM Kiro Power Announcement AWS Lambda Public Roadmap — GitHub Serverless Land — Patterns and Resources Kiro Powers The Innovator's Dilemma — Clayton Christensen Competing Against Luck — Clayton Christensen
#201
March 25 · 1 hr 13 min
The Hard Lessons of Cloud Migration: inDrive's Path from Monolith to Microservices
Join us for a fascinating conversation with Alexander 'Sasha' Lisachenko (Software Architect) and Artem Gab (Senior Engineering Manager) from inDrive, one of the global leaders in mobility operating in 48 countries and processing over 8 million rides per day. Sasha and Artem take us through their four-year transformation journey from a monolithic bare-metal setup in a single data center to a fully cloud-native microservices architecture on AWS. They share the hard-earned lessons from their migration, including critical challenges with Redis cluster architecture, the discovery of single-threaded CPU bottlenecks, and how they solved hot key problems using Uber's H3 hexagon-based geospatial indexing. We dive deep into their migration from Redis to Valkey on ElastiCache, achieving 15-20% cost optimization and improved memory efficiency, and their innovative approach to auto-scaling ElastiCache clusters across multiple dimensions. Along the way, they reveal how TLS termination on master nodes created unexpected bottlenecks, how connection storms can cascade when Redis slows down, and why engine CPU utilization is the one metric you should never ignore. This is a story of resilience, technical problem-solving, and the reality of large-scale cloud transformations — complete with rollbacks, late-night incidents, and the eventual triumph of a fully elastic, geo-distributed platform serving riders and drivers across the globe. With Alexander Lisachenko, Software Architect, inDrive ; With Artem Gab, Senior Engineering Manager, Runtime Systems, inDrive Redis in Action — Josiah L. Carlson (Manning) AWS Well-Architected Framework — ElastiCache Lens Brendan Gregg's Blog — Performance Analysis & Observability Uber H3 — Hexagonal Hierarchical Spatial Index inDrive Website AWS ElastiCache Documentation Valkey Project AWS Well-Architected Framework

Showing 1–20 of 21 episodes