Not a portfolio. Not a blog. A conversation
A few days ago, I came across the AWS Builder Challenge—and I couldn’t resist. I love these sprints: the adrenaline of a deadline, the chance to challenge assumptions, and the opportunity to try and learn something new.
For this challenge, I set myself two rules:
- Build 100% of the code with AI, using Amazon Q CLI and my Micromanaged Driven Development (MMDD) workflow.
- Do something different, because another static portfolio page just wouldn’t cut it.
After reading a tweet about companies that went mobile-first, I started wondering: what would it look like to build an AI-first website? It’s not an original idea, but it’s definitely a challenging one—especially when you’re trying to integrate static content with conversational experiences.
Good artists copy; great artists steal.
A week isn’t much time — even when you have Amazon Q writing the code for you. Building a polished GenAI chat interface is no small feat.
That’s where assistant-ui came to the rescue. According to its tagline, “assistant-ui helps you create beautiful, enterprise-grade AI chat interfaces in minutes. Whether you're building a ChatGPT clone, a customer support chatbot, an AI assistant, or a complex multi-agent application, assistant-ui provides the frontend primitive components and state management layers to focus on what makes your application unique.”
With assistant-ui handling the UI and state complexity, I could focus on integrating the conversational flow and shaping the experience, instead of spending days coding interface details from scratch.
The plan was to build the interface with React and Tailwind, so I was very happy to see that assistant-ui was fully compatible with both. That meant I could keep my preferred stack, focus on the conversational experience, and still end up with a clean, responsive UI that felt like it belonged in a modern GenAI product.
Building Every Line with AI: The MMDD Way
MMDD stands for Micromanaged Driven Development —a methodology of prompts I created to help manage context when working with GenAI tools like Amazon Q CLI.
I first developed MMDD during the AWS Lambda Hackathon, where I team with Amazon Q CLI to build CodeRipple , an event-driven serverless app powered by Strand Agents that generates and updates documentation automatically. That entire project—just like this one—was written 100% by AI.
MMDD is built on three principles:
- Every decision goes through me - AI suggests, I ask, I iterate with AI and then I decide
- Document everything - documents are the glue that holds the world together
- One small change at a time - Big changes lead to big disasters
Every MMDD project starts with a single prompt:
“Using00_mmdd.md, generate01_main.mdfor the project that does …”
It’s a structured, iterative way to guide the AI—keeping the process predictable while letting the AI handle all of the heavy lifting.
Once you've the plan, you iterate between units. Each unit defines and implements a small change to the code base.
The Compound Misdirection Challenge
With high speed comes the demand for precision. Using GenAI to write software lets you produce code incredibly fast—but if you’re not careful, you can end up in a very curious destination before you even notice.
assistant-ui is an opinionated UI library. React and Tailwind… well, they’re opinionated too. So, you’d expect the integration to be smooth. But at the start of the project, it wasn’t.
Following MMDD, I organized tasks into Units . Every time I started a new task, I iterated with Amazon Q to define the unit: we discussed requirements, explored decisions, and only after everything was clear, started implementing. The problem is, if that conversation is incomplete or wrong, the machine will decide for you—and as a micromanager, that’s the last thing I want.
That’s exactly what happened during the UI integration. I needed a very specific behavior, but Q started to fight against assistant-ui. A fix would break something that had worked before, and if you don’t step in, you end up in an endless spiral of compounded errors and issues.
Fortunately, there are solutions for this:
- Version control is king. When I realized Q was fighting a war between assistant-ui and React/Tailwind, I rolled back to earlier units to reset the context.
- Context sharing with Q. I explained the issue to Q so we could prevent the same mistakes in the next iteration.
- Leverage the source. I cloned the entire assistant-ui repository and asked Q to generate a summarized “how-to” guide, which I kept in the context for the rest of the project.
I had a similar situation when I deployed to AWS Amplify and ran into monorepo setup issues. In that case, I turned to StackOverflow, found the right solution, and fed it back to Q. Only difference? I did that after trying fifteen other alternatives first. Sometimes, you can’t hand a human job to a bot.
When There Are No Issues, It’s Like Driving a Ferrari
A couple of months ago, Martin Fowler compared GenAI with High Level languages : if high-level languages abstracted us from machine code, LLMs introduce a new, non-deterministic layer of abstraction—changing not just how we write software, but what it means to “program.”
GenAI introduces a new level of abstraction that enables you to write high-quality code incredibly fast. When you stay disciplined—taking small steps and following MMDD or Spec-Driven Development—the workflow becomes not just fast, but effortless. It’s like driving a Ferrari on an open road.
One example? The contact form.
Because this is a conversational website, there’s no static “Contact Us” page. Instead, if you open the conversation section and type:
“Send an email to Roberto”
…the old school bot will guide you through the questions, collect your information, and trigger the email flow.
Behind the scenes, that conversation ties into a Lambda function, which eventually requires an EventBridge configuration and some supporting resources—everything Ana Cunha described in her excellent blog post titled Contact Form 📧 - Making Your Website Interactive .
But here’s where the GenAI workflow shines:
- You read the blog post to understand the architecture and confirm it matches your needs.
- Then, you hand that context to Amazon Q and simply ask it to follow the tutorial to generate AWS CLI scripts for deploying your Lambda and related resources as Infrastructure as Code.
Of course, you’re not limited to AWS CLI scripts. If your stack uses CloudFormation or Terraform, the same approach works beautifully—AI generates the baseline scripts, and you just refine and deploy.
My Wow Moment: AWS Amplify
I was genuinely amazed at how fast and easy AWS Amplify was to use. It was my first time trying it, so I asked Amazon Q to create a quick comparison matrix against tools I already knew—like GitHub Actions—to get a sense of what to expect.
When I saw the matrix, my first thought was: “This is promising.”
Task | AWS Amplify | GitHub Actions |
|---|---|---|
Initial Setup | One-click connect to your repo, auto-detects framework and build settings. | Requires writing workflow YAML, setting permissions, and configuring runners. |
Build & Deploy | Automatic build and deploy pipeline out of the box. | Separate build and deploy jobs, often with custom scripts. |
Environment Variables | Managed in the console; auto-injected at build time. | Requires secrets setup and manual mapping in YAML. |
Branch Previews | Automatically builds preview environments for pull requests. | Needs custom jobs and cleanup logic to manage preview environments. |
Custom Domains & SSL | Integrated setup, free SSL certificate via ACM. | Manual DNS and certificate management, plus custom scripts. |
And then I actually did the deployment... and wow. The word here is smoooooth—something you don’t often see in deployment flows.
- The project setup: Smooth.
- The build: Smooth.
- The branch connection: Smooth.
- The domain registration: Smooth.
I’m officially in love with Amplify. It’s earned a permanent spot in my workflows for future projects.
Lessons Learned
Every project teaches you something new—this one taught me a lot. Here are the biggest takeaways from building a 100% AI-generated, chatbot-driven website in just a week:
- Structure beats speed GenAI can write code faster than you can type, but speed without structure is chaos. MMDD kept me disciplined: defining, refining, and then implementing every unit step-by-step. That structure kept me from spiraling into unmanageable complexity.
- Version control is your lifeline When things went sideways (and they did), git saved the day. Frequent commits and clear messages made it painless to roll back, reset, and guide Q back on track. In an AI-first workflow, version control isn’t optional—it’s essential.
- Human oversight matters AI can generate incredible solutions, but it doesn’t understand context like you do. Reviewing, refining, and sometimes overriding Q’s output was the difference between a buggy mess and a working product. Think of AI as a very fast, very eager junior developer—it still needs guidance.
- AWS services are simpler than you think I’d never used Amplify before, and Lambda was something I’d only toyed with. This project changed that. Amplify made hosting, CI/CD, and domain management so easy that I can’t imagine future workflows without it. And Lambda? Perfect for lightweight, serverless logic without the hassle of managing servers.
A special shout-out to Ben Fowler and Ana Cunha for their excellent step-by-step guide that walks you through setting up a website from scratch. Reading that guide first gave me the confidence to let Amazon Q generate the automation scripts instead of manually clicking through the console.
Demo: Talk to the Bot
It’s an “old school bot” for now, but it already mimics the conversational experience. Instead of filling out a boring contact form, you can simply start typing and the bot will guide you through the flow.
Fun things to try
- Type: “Send an email to Roberto” The bot will guide you through the questions and “send” the message.
- Ask questions about AI-first websites It will share a brief explanation of what the concept means and why this project follows that approach.
- Chat about football — especially Messi The bot loves to talk about Messi and has a few fun scripted responses to keep the conversation lively.
-
Try It and Share Your Feedback
Take a look at the site, explore the content, and have a chat with the old-school demo bot.
I’d love to hear your thoughts:
- What parts of the experience did you enjoy?
- What felt smooth or surprisingly natural?
- What would you change or improve?
This project is just the first step toward a truly AI-first website. Your feedback will help shape the next version — one powered by Amazon Nova Micro for real, low-latency conversations.
Enjoyed reading this content? Let the author know!
Your likes, comments, shares, and saves help creators reach more builders.
Loading recommendations
Loading article