Agile Meets AI—How to Code Fast Without Breaking Things | Llewellyn Falco

AI Assisted Coding: Agile Meets AI—How to Code Fast Without Breaking Things, With Llewellyn Falco

In this BONUS episode we explore the practice of coding with AI—not just the buzzwords, but the real-world experience. Our guest, Llewellyn Falco, has been learning by doing, exploring the space of AI-assisted coding from the experimental and intuitive—what some call vibecoding—to the more structured world of professional, world-class software engineering. This is a conversation for practitioners who want to understand what's actually happening on the ground when we code with AI.

Understanding Vibecoding

"You can now program without looking at code. When you're in that space, vibecoding is the word we're using to say, we are programming in a way that does not relate to programming last year."

The software development landscape shifted dramatically in early 2025. Vibecoding represents a fundamental change in how we create software—programming without constantly looking at the code itself. This approach removes many traditional limitations around technology, language, and device constraints, allowing developers to move seamlessly between different contexts. However, this power comes with responsibility, as developers can now move so fast that traditional safety practices become even more critical.

From Concept to Working App in 15 Minutes

"We wrote just a markdown page of ‘here's what we want this to look like’. And then we fed that to Claude Code. And 15 minutes later we had a working app on the phone."

At the Agile 2025 conference in Denver, Llewellyn participated in a hackathon focused on helping psychologists prevent child abuse. Working with customer Amanda, a psychologist, and data scientist Rachel, the team identified a critical problem: clinicians weren't using the most effective parenting intervention technique because recording 60 micro-interactions in 5 minutes was too difficult and time-consuming.

The team's approach embodied lean startup principles turned up to eleven. After understanding the customer's needs through exposition and conversation, they created a simple markdown specification and used Claude Code to generate a working mobile app in just 15 minutes. When Amanda tested it, she was moved to tears—after 20 years of trying to make progress on this problem, she finally had hope. Over three days, the team released 61 iterations, constantly getting feedback and refining the solution.

Iterative Development Still Matters When Coding With AI

"We need to see things working to know what to deliver next. That's never going to change. Unless you're building something that's already there."

The team's success wasn't about writing a complete requirements document upfront. Instead, they delivered a minimal viable product quickly, tested it with real users, and iterated based on feedback. This agile approach proved essential even—or especially—when working with AI.

One breakthrough came when Amanda used the number keypad instead of looking at her phone screen. With her full attention on the training video she'd watched hundreds of times, she noticed an interaction she had missed before. At that moment, the team knew they had created real value, regardless of what additional features they might build.

Good Engineering Practices Without Looking at Code

"We asked it to do good engineering practices, even though we didn't really understand what it was doing. We just sort of say, okay, yeah, that seems sensible."

A critical moment came when the code had grown large and complex. Rather than diving into the code themselves, Llewellyn and his partner Lotta asked the AI to refactor the code to make a panel easy to switch before actually making the change. They verified functionality worked through manual testing but never looked at how the refactoring was implemented. This demonstrates that developers can maintain good practices like refactoring and clean architecture even when working at a higher level of abstraction.

Key practices for AI-assisted development include:

• Don't accept AI's default settings—they're based on popularity, not best practices

• Prime the AI with the practices you want it to use through configuration files

• Tell AI to be honest and help you avoid mistakes, not just be agreeable

• Ask for explanations of architecture and evaluate whether approaches make sense

• Keep important decisions documented in markdown files that can be referenced later

“The documentation is now executable. I can turn it into code”

"The documentation is now executable. I can turn it into code. If I had to choose between losing my documentation or losing my code, I would keep the docs. I think I could regenerate the code pretty easily."

In this new paradigm, documentation takes on new importance—it becomes the specification from which code can be regenerated. The team created and continuously updated markdown files for project context, architecture, and individual features. This practice allowed them to reset AI context when needed while maintaining continuity of their work.

The workflow was bidirectional: sometimes they'd write documentation first and have AI generate code; other times they'd build features iteratively and have AI update the documentation. This approach using tools like Super Whisper for voice-to-text made creating and maintaining documentation effortless.

Remove Deterministic Tasks from AI

"AI is sloppy. It's inconsistent. Everything that can be deterministic—take it out. AI can write that code. But don't make AI do repetitive tasks."

A crucial principle emerged: anything that needs to be consistently and repeatedly correct should be automated with traditional code, not left to AI. The team wrote shell scripts for tasks like auto-incrementing version numbers and created git hooks to ensure these scripts ran automatically. They also automated file creation with dates at the top, removing the need for AI to track temporal information.

This principle works both ways—deterministic logic should be removed from underneath AI (via scripts and hooks) and from above AI (via orchestration scripts that call AI in loops with verification steps in between).

Anti-Patterns to Avoid

"The biggest anti-pattern is you're not committing frequently. I really want the ability to drop my context and revert my changes at a moment's notice."

The primary anti-pattern when coding with AI is failing to commit frequently to version control. The ability to quickly drop context, revert changes, and start fresh becomes essential when working at this pace. Getting important decisions into documentation files and code into version control enables rapid experimentation without fear of losing work.

Other challenges include knowing when to focus on the right risks. The team had to navigate competing priorities—customers wanted certain UX features, but the team identified data collection and storage as the critical unknown risk that needed solving first. This required diplomatic firmness in prioritizing work based on technical risk assessment rather than just user requests.

Essential Tools for AI-Assisted Development

"If you are using AI by going to a website, that is not what we are talking about here."

To work effectively with AI, developers need agentic tools that can interact with files and run programs, not just chat interfaces. Recommended tools include:

• Claude Code (CLI for file interaction)

• Windsurf (VS Code-like interface)

• Cursor (code editor with AI integration)

• RooCode (alternative option)

• Super Whisper (voice-to-text transcription for Mac)

Most developers working at this level have disabled safety guards, allowing AI to run programs without asking permission each time. While this carries risks, committing frequently to version control provides the safety net needed for rapid experimentation.

The Power of Voice Interaction

"Most of the time coding now looks like I'm talking. It's almost like Star Trek—you're talking to the computer and then code shows up."

Using voice transcription tools like Super Whisper transformed the development experience. Speaking instead of typing not only increased speed but also changed the nature of communication with AI. When speaking, developers naturally provide more context and explanation than when typing, leading to better results from AI systems.

This proved especially valuable in a crowded conference room where Super Whisper could filter out background noise and accurately transcribe the speakers' voices. The tool enabled natural, conversational interaction with development tools.

Balancing Speed with Safety

Over three days, the team released 61 times without comprehensive automated testing, focusing instead on validating user value through manual testing with the actual customer. However, after the hackathon, Llewellyn added automated te