Build and ship an entire app using Amazon Q
How the AWS Lambda Hackathon let me stress test an idea that ended up transforming how I work with Q CLI to develop software. This post is based on a presentation at AWS Community Day 2025, New Zealand, Aotearoa.
The Hypothesis That Changed Everything
What if you could build 100% of a digital product's code using only Amazon Q CLI? This wasn't just theoretical curiosity—it was the driving hypothesis behind my entry into the AWS Lambda Hackathon in June 2025. The result was CodeRipple, a complete documentation automation platform built entirely through AI-assisted development.
Hackathons like AWS Lambda are among the best environments to test new ideas.
But this story isn't just about a hackathon project. It's about discovering a way of working that fundamentally transforms how we approach software development in the age of AI.
The Documentation Tax
Before diving into how CodeRipple works, let's acknowledge a silent challenge plaguing every software project: documentation decay. Consider the GCC project—one of the most important compiler projects in computing history. While code changes happen daily, the README file hasn't been updated in 13 years.
This pattern repeats across countless projects. We write code, ship features, fix bugs, but documentation remains frozen in time. CodeRipple was born from a simple premise: what if documentation could update itself automatically, staying in sync with your codebase without human intervention?
Introducing CodeRipple: Documentation That Never Gets Stale
CodeRipple is an event-driven application that automatically generates and updates documentation whenever you commit code. Here's how it works:
The Flow:
- You commit code to your GitHub repository
- A webhook triggers CodeRipple's API endpoint
- The "Receptionist" Lambda checks out your code and stores it in S3 (the "Drawer")
- The "Analyst" Lambda uses Strands Agents and Claude Foundation Model on Bedrock to analyze the source code
- AI-generated documentation is created, including descriptions, usage guides, and ASCII architecture diagrams
- The "Deliverer" Lambda publishes the documentation to a static website.
Documentation generated with CodeRipple
The result? A continuously updated catalog of project documentation that reflects your actual codebase, not what it looked like six months ago.
To learn more about CodeRipple visit CodeRipple's git repository .
CodeRipple: an event drive app that generates documentation automatically
The New Abstraction Layer: Natural Language as Code
To understand the significance of what's happening here, we need to step back and consider software development's evolution. Martin Fowler recently described Generative AI as a new abstraction layer enabling interaction with computers through natural language.
We've progressed from punch cards to assembly language to high-level programming languages. Each abstraction layer made programming more accessible and productive. Now, with Large Language Models, we can write instructions in natural language—but this comes with unique challenges.
- The Non-Deterministic Challenge: Ask ChatGPT "what time is it?" multiple times, and you'll get different responses. Unlike traditional code, AI responses aren't perfectly predictable.
- The Curse of Knowledge: Because we're communicating in natural language, the meaning of our words carries implicit assumptions. What seems obvious to us might be completely unclear to the AI, leading to hallucinations or unexpected outputs.
- The Spiral of Errors: When you encounter an error and ask AI to fix it, you might get another error. Attempt to fix that, and you might spiral into an increasingly problematic state, far from your original goal.
Introducing Micromanage-Driven Development (MMDD)
To address these challenges, I developed what I call Micromanage-Driven Development (MMDD). The name is intentionally provocative—while micromanagement is counterproductive with humans, it's exactly what AI needs to deliver reliable results.
MMDD rests on three core principles:
- Every Decision Goes Through Me
I maintain constant conversation with the AI, making all architectural and implementation decisions explicit. The AI executes, but I guide every step. - Documentation Holds the World Together
Every decision, context, and plan gets written into files. This creates a knowledge base that can be referenced throughout the project, ensuring consistency and enabling recovery from mistakes. - Small Steps, Big Results
I make one small change at a time. Big changes lead to hallucinations and disasters. By constraining scope, I maintain control and can easily backtrack when needed.
The MMDD Workflow in Action
Here's how MMDD works in practice for a project like CodeRipple:
Step 1: Context Building
I start by having a conversation with the AI about event-driven architecture, asking questions until I'm confident we share the same understanding.
Step 2: Planning
Using the MMDD template (available at mmdd.dev ), I work with the AI to break the project into small "units"—discrete, implementable chunks that can be completed and tested independently.
Step 3: Implementation
For each unit, I create a detailed specification file, iterate on it until perfect, then simply tell the AI: "implement what this file says."
Step 4: Version Control Integration
Each unit corresponds to a single commit. My git history becomes a clear narrative of the project's evolution, with each commit tied to a specific unit description.
Each unit corresponds to a single commit. My git history becomes a clear narrative of the project's evolution, with each commit tied to a specific unit description.
Escaping the Spiral of Errors
When things go wrong (and they will), MMDD provides a clear recovery path. If I notice we're spiraling into increasingly complex problems, I:
- Ask the AI to assess what went wrong and document the lessons learned
- Revert to the last stable commit
- Create a new unit that incorporates both the original goal and the lessons learned
- Implement a better solution with more context
This approach transformed my error rate from frequent spirals to manageable hiccups.
The Transformation: Speed, Scope, and Skills
The results of using MMDD with AI have been remarkable:
- Speed Gains: Projects that would take a week now take a day. The overall development time decreases dramatically, even accounting for increased planning and testing time.
- Skill Expansion: I've become more of a generalist, able to work across different technology stacks without deep specialization in each. Like the transition from assembly to high-level languages, I'm operating at a higher abstraction level.
- Experimentation Freedom: The reduced cost of coding enables trying multiple approaches to the same problem. I can implement different solutions and choose the best one, rather than being locked into the first approach that works.
The Trade-offs: What You Gain and Lose
Time Redistribution:
- More time planning and designing (↑)
- More time testing and debugging (↑)
- Less time implementing (↓)
- Overall project time (↓↓)
Skill Evolution:
- Increased: Architecture thinking, prompt engineering, testing methodology
- Decreased: Deep technical implementation knowledge in specific frameworks
New Responsibilities:
- Code review becomes critical—you're now the quality gatekeeper
- Context management requires discipline
- Tool orchestration becomes a new skill
Adopting Q CLI and MMDD not only changes the time to deliver, but also the skills and use of the time.
The Verification Imperative
Working with AI-generated code makes testing non-negotiable. You become the code reviewer for a very productive but occasionally unpredictable developer. This means:
- Comprehensive testing strategies are essential
- Code review skills become more important than ever
- Understanding what the code does (even if you didn't write every line) is crucial
Practical Takeaways for Your Next Project
If you're ready to experiment with AI-driven development:
- Start Small: Choose a well-defined, low-risk project for your first experiment
- Document Everything: Create files for context, decisions, and plans—don't rely on chat history
- Break It Down: Divide your project into the smallest possible implementable units
- Test Relentlessly: Assume every AI-generated piece of code needs verification
- Embrace the Iteration: Plan to refine and improve rather than getting it perfect on the first try
Looking Ahead: The Future of Development
CodeRipple represents more than just a successful hackathon project—it's a glimpse into how software development is evolving. We're not replacing developers; we're augmenting human creativity and problem-solving with AI execution capabilities.
The developers who thrive in this new paradigm will be those who learn to effectively collaborate with AI, understanding both its capabilities and limitations. They'll be architects, reviewers, and orchestrators rather than primarily implementers.
Resources and Next Steps
The complete codebase for CodeRipple is available in GitHub . You can also explore the MMDD framework at https://mmdd.dev .
If you're attending AWS events or working on similar AI-assisted development projects, I'd love to connect and hear about your experiences. The AI development community is still young, and sharing our learnings helps everyone move faster.
Enjoyed reading this content? Let the author know!
Your likes, comments, shares, and saves help creators reach more builders.
Loading recommendations
Loading article