Video summary

AWS re:Invent 2025 - Building software like never before with Agentic AI (DVT220)

Main summary

Key takeaways

Technology

Summary of technological concepts, product features, and analysis

Session purpose and themes (Agentic AI for software development)

  • The talk frames Agentic AI as a shift from:
    • code prediction / autocomplete → chat-based assistance → agents that understand context, converse, and autonomously take actions
  • Emphasizes that AI dev tooling is changing rapidly.
  • Notes that many teams already use multiple tools, but production readiness and control remain major concerns.

AWS Kiro: “Agentic development environment” for production-grade structured AI coding

AWS introduces Kiro (launched Nov 17; GA “couple of weeks ago,” preview in July) as an environment designed to apply mature engineering practices to AI coding—aiming at production-level applications using structured/spec-driven workflows.

Key motivations / pain points (from customer feedback)

  • Autonomy limits in “vibe coding”
    • Great for small tasks/prototyping, but production work still requires substantial follow-up (bug fixes, code edits, rewrites).
  • Limited control & visibility
    • Some tools lack monitoring/end-to-end transparency and the ability to intervene during agent actions.
  • Quality & verification challenges
    • Agents can produce code/tests/docs, but teams need intuitive ways to confirm outputs match developer intent and project standards.

Core product features described

Two interfaces
  • Kiro IDE (fully agentic development experience)
  • Kiro CLI (agentic terminal workflow)
Spec-driven development (vs. generating large code dumps early)

Kiro emphasizes a guided workflow that generates:

  • Requirements
    • user stories + acceptance criteria
  • Design artifacts
    • components/interfaces, API routes, error handling, testing strategy, etc.
  • Task list / MVP approach
    • task backlog tied back to the spec

Additional capabilities:

  • Requirements traceability
    • mapping requirements → tasks
  • Human-in-the-loop edits and iterative refinement before coding
Demo example: Flask event management app
  • Prompt: add a “category” feature and enable event filtering.
  • Kiro generates:
    • requirements (user stories + acceptance criteria)
    • design markdown (components/interfaces/routes/error handling/testing strategy)
    • a task list, then code
  • Showcased:
    • approvals for agent commands
    • automated testing
    • database/table changes
    • iterative task completion
Agent hooks (automating repetitive dev workflows)

Kiro includes agent hooks to trigger actions on events such as:

  • file save
  • Python file updates

Examples mentioned:

  • regenerate test cases
  • update documentation
  • update changelog (timestamp + summary)
  • propagate changes across multiple languages/labels (example described)
Advanced context management with “steering files”

To reduce mismatches with org standards/best practices, Kiro supports steering files, such as:

  • project coding standards
  • testing guidance (libraries, strategies)
  • security guidelines
  • deployment process rules

Steering files can integrate with spec-driven development—for example, “persona” files used when generating requirements.

Brownfield steering demo

Kiro can generate/support steering docs like:

  • product markdown (core features, UX, business logic)
  • tech markdown (technology + DB schema)
  • structure doc (file/module structure)

It can also add:

  • coding standards (including recommendations produced by Kiro)

The approach emphasizes opinionated templates to accelerate brownfield onboarding.

Announcements mentioned
  • Kiro powers
    • partner integrations (example: Figma)
  • Frontier agent
    • a virtual extra teammate for Kiro

Rackspace customer story: enterprise rollout and outcomes using Kiro

A customer (Rackspace) describes evaluating and adopting Kiro as part of a standardized “one Rackspace” development community.

Evaluation approach

  • They saw other AI coding tools as strong in parts but lacking cohesive coverage across needs.
  • Kiro was selected due to its strengths and evolving capabilities, becoming the preferred tool.

Reported results / metrics

  • Early claim: 81% overall efficiency gains (updated to 85%).
  • Scale:
    • 700 developers (later stated 800 developers total)
    • 51+ projects logged
    • Estimated time savings: 8+ FTE years across 4–5 months
  • Business framing:
    • shifted from perpetual maintenance to continuous delivery & innovation
    • improved security and compliance

Example use cases

  1. Legacy Python application modernization/upgrade
    • Added missing unit tests and documentation
    • Identified dead/redundant code
    • Reduced code size (“shaved thousands of lines”)
    • Improved maintainability/security/reliability
    • Reported: first app moved to production after using Kiro
  2. MCP server + Splunk integration for post-deploy error remediation
    • Integrated Kiro’s MCP server with Splunk to:
      • deduplicate logs
      • identify errors after go-live
    • Because context stayed tied to the codebase in Kiro, the team could quickly:
      • write missing unit tests
      • fix defects
      • redeploy
    • Reported: 3 defects fixed within 15 minutes with no deployment complaints (for a critical internal system)

Rollout methodology

  • “Start small and controlled”
    • initial spark/ignition cohort (8 teams; multiple languages including Python, Java, .NET)
    • playbook included modernization steps like adding tests and creating spec files
  • Emphasized communication cadence: “talk early, talk often”
  • Expanded users: 100 → 175 → eventually to 800
  • Created a Community Center of Excellence
    • recurring sessions every other Friday with speakers sharing innovations and practices
  • Goal:
    • reduce IT bottlenecks and empower business units and cross-functional teams with a shared use-case library

Building custom agents inside applications (AWS enabling production agents at scale)

The second half shifts to agent design embedded in business applications.

Why build agents into apps (analysis)

  • Agents make natural language a UI, enabling users to request actions directly.
  • Improve customer experience via personalization and memory/reasoning.
  • Provide context-aware intelligence, reducing the need for massive bespoke code paths and long-term maintenance of customer-specific workflows.
  • Competitive framing: assume competitors are adopting agent-based automation.

Gartner predictions cited

  • Generative AI in a third of enterprise applications by 2028 (up from ~1% in 2024)
  • At least 15% of work decisions made autonomously via generative AI by 2028

AWS “Agent Core” approach: optionality + production primitives

The talk emphasizes AWS’s goal: let developers choose tools/models while still achieving production-grade deployment.

Optionality (developer tooling + model choice)

  • No one wants to lock into a single framework/model for 10 years.
  • AWS positions itself to support multiple frameworks and models.

Components referenced

  • Strands Agent SDK (open-source)
    • Build agents from a prompt + tools list
    • test locally
    • deploy to cloud
  • Amazon Bedrock
    • “single API” access to 100+ models
  • Amazon Bedrock Agent Core (modular services for production)
    • Runtime
      • serverless deployment
      • session isolation
      • long-running low-latency agent work
    • Memory
      • short-term and long-term memory capabilities
    • Identity/Access
      • controls what AWS resources/tools the agent can access
    • Gateway / Browser tool
      • connect agents to MCP/openAPI/Smithy protocols
      • interact with web pages via computer-use browser runtime
    • New primitives mentioned:
      • Evaluations primitive
        • benchmark agent performance against metrics/business goals
      • Policy primitive
        • described as another control primitive for production behavior

Demo: customer support agent workflow

Scenario: customer requests a game exchange immediately.

  • “Old experience”: delayed email
  • “New experience”: agent processes in real time

High-level steps shown:

  • In Kiro:
    • create steering documents
    • use spec mode to define agent requirements
  • Integrate with Strands + Agent Core MCP tools
  • Generate:
    • requirements → design → task list → source code
  • Deploy via an Agent Core configure command to Agent Core runtime
  • Run a test prompt (“hello”) to validate the agent is live

Observability emphasis

  • Uses OpenTelemetry for observability.
  • Demonstrated a “decision mapping tree” view to explain why the agent made decisions and support iteration when outputs don’t match team expectations.

Main speakers / sources

  • Svetlana Kolomeysky (AWS) — moderator; leads outbound go-to-market for Agentic AI development experience services
  • Al Di Stefano (AWS) — senior go-to-market specialist; Agentic AI developer experience team
  • Brian Lickley — Chief Technology Officer, Rackspace IT
  • AWS / Gartner — referenced for market predictions (Gartner cited in the second segment)

Original video