EventFlow: From Specification to Production with AI Agents

Building production-grade software through systematic human-AI collaboration at ETLS 2025

Four days. That's how long it took to go from skeptical enterprise engineer to building a production-ready app that would earn a main-stage shoutout from industry legends Gene Kim and Jeff Gallimore. But more importantly, it's how long it took to discover a systematic methodology that could transform how we build software at enterprise scale.

When I landed in Las Vegas on Monday, September 22nd, at 11:30 AM, I had a problem. Not a technical problem - those I could solve. This was a deeply human challenge that every working parent knows: How do you maximize professional growth while staying connected to the people you love most? As the father of an absolutely delightful 15-month-old boy, I was juggling conference sessions, networking meetings, and scheduled FaceTime calls using a messy spreadsheet that barely worked.

I also had extensive experience with chat-assisted programming from my previous role as a lead engineer and manager at Brivo, where I'd helped teams adopt AI-powered development tools while establishing safe practices around their use. But agentic AI was entirely different territory. Capital One was still in early AI adoption phases, and I'd been laser-focused on delivering immediate results with our Financial Core Modernization teams (we'd just crushed our goal of reducing software delivery lead time from 30 days to less than 1). My total agentic AI experience? A single 15-minute session asking OpenAI to create a business funding spreadsheet.

What I discovered over the next four days would fundamentally change how I think about software development, team productivity, and the future of enterprise technology.

Day 0: The Vibe Coding Revelation

The Enterprise Tech + AI Leadership Summit officially started on Tuesday, but Monday featured something special: a Vibe Coding Workshop led by Gene Kim and Steve Yegge. I'd followed both of their work for years, so when I managed to check in just 15 minutes before it began, I was already excited.

Gene and Steve introduced us to "Vibe Coding," their philosophy of crafting code by feel. The principles resonated immediately:

• Rapid iteration guided by intuitive feedback
• Clean, expressive naming and structure
• Aligning code style with team culture and project vibe

But theory quickly gave way to magic. Within the first 45 minutes, I'd gone from zero AI agent experience to building functional web games: brick breaker and tetris. Just by describing what I wanted. The technology didn't just work; it felt intuitive, almost conversational.

Then came the challenge that would change everything. Gene offered us a choice: group discussion or continued vibe coding. For those who chose to keep building, he suggested recreating a mobile app that could play both podcasts and videos.

Here's where having a brand new laptop became a strategic advantage rather than a limitation. While other attendees dove into coding, I didn't have Xcode installed or any mobile development environment set up. Instead of seeing this as a blocker, I used the workshop time to do what I do best as an enterprise engineer: create a systematic plan.

I spent the session developing a spec-driven approach based on Deming's Plan-Do-Check-Act (PDCA) cycle:

• Plan: Define clear specifications, tool selection rationale, and success criteria
• Do: Execute implementation through AI agents within well-defined guardrails
• Check: Validate results through comprehensive testing and human oversight
• Act: Iterate based on feedback loops and continuous improvement

My two primary research questions became:

1. How to create a spec-driven feedback process that could scale beyond individual coding sessions
2. Where are the optimal human-in-the-loop points in AI-assisted development?

Instead of following the workshop prompt, I had my architectural insight: why not solve my actual problem while systematically testing this methodology? A conference agenda tracker would provide real-world validation of production-grade AI-assisted development.

Day 1: Developing the Specification-Driven Approach

When I woke up on Day 2 of the conference (the first official day after the workshop), I had a clear objective: implement the systematic approach I'd planned while setting up my development environment.

The first critical decision was tool selection. After installing Xcode and the necessary dependencies, I chose Flutter as the development platform based on systematic criteria:

• Cross-platform from day one (iOS, Android, web) for maximum reach
• Hot reload enabling instant iteration feedback with AI agents
• Mature ecosystem with comprehensive packages and community support
• Excellent documentation that AI agents can reference effectively
• Material 3 design system providing consistent, professional UI patterns
• Strong CI/CD integration for automated testing and deployment

I started by embracing the vibe coding approach from the workshop - rapid iteration, intuitive feedback, and conversational development. This was perfect for exploring the problem space, understanding Flutter's capabilities, and building an initial MVP.

But within an hour, I'd discovered something crucial: while vibe coding excels at exploration and rapid prototyping, building production-grade software requires a more systematic approach. I needed to evolve from vibe coding to specification-driven development as the complexity and quality requirements increased.

This realization led me to independently create an agent_assets/ directory structure to organize specification materials, backlog items, and documentation that would guide AI agents throughout the development process.

Day 2: The Unexpected Recognition

The second day brought an honor I never expected: a main stage shoutout from Gene Kim and Jeff Gallimore for my "vibe coded conference agenda tracker app."

Standing in the audience, hearing these industry legends mention my project, was surreal. It wasn't just recognition of the app. It was validation of a new approach to software development that the entire ETLS community was witnessing in real-time.

That moment crystallized something important: we weren't just building software anymore. We were demonstrating a fundamental shift in how quickly ideas could become reality when human creativity partners effectively with AI agents.

Day 3: Building Production-Grade CI/CD Infrastructure

I woke up at 4 AM on Day 3, energized by the challenge of building a complete production pipeline. This wasn't just about tinkering - I was systematically implementing the infrastructure patterns I'd learned delivering enterprise software at Capital One.

The key insight was that AI-assisted development accelerates you directly into the parts of the SDLC that have always been the most challenging but most worthwhile: continuous delivery, automated testing, feedback loops, and quality gates.

More importantly, I wanted users to feel completely assured that EventFlow was secure when they downloaded it to their phones. Here's what I built:

Comprehensive GitHub Actions Pipeline

• Cross-platform build verification for iOS, Android, and web targets
• macOS runners for iOS build verification (essential for App Store deployment)
• Automated testing suite with unit, widget, and integration tests
• Code coverage reporting with detailed metrics
• Static analysis with Flutter's built-in linter
• Security scanning integration with DryRun Security

The Agent Feedback Loop Architecture

The breakthrough was creating automated feedback systems that AI agents could read and act upon, enabling a continuous improvement cycle where agents could automatically identify root causes, implement fixes, and verify through the same automated pipeline.

The Dinner That Changed My Perspective

Closing out the conference, I had an experience that perfectly captured the magic of the ETLS community. Jason Cox, executive director of Global Hosting & SRE at Disney, not only gave me incredible advice about my app and career but invited me to dinner with all the keynote speakers and industry leaders.

Walking into that dinner, I was terrified. Here I was, about to sit at a table with people whose ideas I'd seen published in books that changed my career. At first, I was afraid to speak up, convinced someone would realize I wasn't qualified to be there.

But the opposite happened. Within minutes, legends like Randy Shoup, Scott Prugh, Christine Hudson, Jeff Gallimore, Gene Kim, Leaf (Jessica) Roy, Topo Pal, and Jon Smart made me feel not just welcome, but like part of the circle.

This experience perfectly captured what makes the ETLS community special. It's not just about the technology or the methodologies. It's about creating spaces where ideas can flourish, where newcomers are welcomed, and where the future is being built through genuine collaboration and shared curiosity.

What This Means for Enterprise Leaders

The EventFlow experience offers several critical insights for technology leaders navigating the AI transformation:

1. AI Amplifies the Importance of SDLC Fundamentals

The most significant bottlenecks shift from "how do we implement this feature?" to "how do we ensure quality, maintain control, and prevent AI agents from introducing subtle regressions?"

2. Quality Gates Need Fundamental Redesign

When feature development accelerates 10x, quality assurance processes designed for traditional development cycles become inadequate.

3. The Skills Gap Is Changing, Not Disappearing

Domain expertise, systems thinking, and the ability to define clear acceptance criteria become differentiating skills.

4. Technical Leadership Becomes More Important

When anyone can generate working code, the ability to make sound architectural decisions, establish coding standards, and guide technical strategy becomes the primary value differentiator.

Looking Forward

EventFlow started as a simple conference agenda tracker and became something much more significant: a real-world demonstration of what's possible when human creativity partners effectively with AI assistance.

The magic isn't in the AI technology itself. It's in the amplification of human creativity and problem-solving capability. When developers can focus on defining problems clearly and designing elegant solutions rather than wrestling with implementation details, we unlock new levels of innovation.

The future of software development isn't human versus AI. It's human with AI, creating solutions that neither could achieve alone.

After building a production-ready conference agenda app in under 36 hours using Amp, I'm convinced: this technology is going to reshape thought work in ways we're only beginning to imagine.

The energy at ETLS was electric. The ideas were bold. And it reminded me why I got into tech in the first place: it's the closest thing to being a wizard.