My First Vibe Coding Journey: From Zero to Working App in 4 Hours (And What I Learned About Spec-Driven Development, SDD)

Two months ago, I had never built a real app in my life. Sure, I’d been doing business analysis and product management for 7-8 years, but actually writing code? That was for “real developers,” not for someone like me.

Then I stumbled across a Facebook post about Kiro releasing their public beta. I got lucky and snagged early access to their AI-powered development platform. Four hours later, I had a working tarot reading app running on my own domain, complete with Gemini API integration.

And honestly? I still can’t believe it actually worked.

The Moment Everything Changed

Let me back up a bit. I was scrolling through a Vietnamese developer Facebook group (you know the ones—where everyone asks the same React questions over and over) when someone posted about Kiro’s free beta. I’d heard whispers about “vibe coding” but thought it was just another Silicon Valley buzzword.

But something made me click that registration link. Maybe it was curiosity. Maybe it was the fact that I’d been sitting on app ideas for years but never had the technical skills to build them.

Three days later, I got the acceptance email. And that’s when my whole perspective on software development changed forever.

The Spec-Driven Development (SDD) Process (Or: How I Learned to Stop Worrying and Love Requirements)

Here’s what I didn’t expect: Kiro didn’t just let me type “build me an app” and magically spit out code. It forced me to think like a product manager first, developer second.

The process started with something I was actually familiar with—writing requirements. But this time, instead of handing them off to a development team, I was working directly with an AI agent that could actually build what I described.

The workflow looked like this:

1. High-level product vision – What does this app do for users?
2. Detailed requirements – What specific features and behaviors?
3. System design – How should the pieces fit together?
4. Task breakdown – Step-by-step implementation plan
5. Execution – AI builds while I provide context and feedback

And you know what? This felt natural to me. I’d been doing the first four steps for years. The only difference was that step 5 actually resulted in working code instead of developer estimates and sprint planning meetings.

My First App: A Tarot Reading Experience (With Some Questionable Design Choices)

For my first project, I decided to build something personal—a tarot reading app that combined traditional divination with Vietnamese spiritual elements. The concept was simple: users input their name, date of birth, and birth time, then get personalized tarot and I-Ching readings powered by Gemini AI.

Now, you might ask: “Why do users need to input their birth time?”

Honestly? Two months ago, I had no idea. I just made up that requirement because it felt mystical and important. Classic product manager move—adding features without really understanding why.

But here’s the thing: the AI didn’t judge my questionable product decisions. It just built what I asked for.

The Technical Stack (Or: How I Accidentally Chose the Right Tools)

I went with the simplest possible tech stack:

• Python (Flask) for the backend
• HTML/CSS/JavaScript for the frontend
• Gemini API for the AI-powered readings
• My home lab server for hosting

Why these choices? Because I literally didn’t know what else to use. Sometimes ignorance is bliss—I picked tools that were simple enough for a beginner but powerful enough to build something real.

The AI agent helped me understand each piece as we built:

• “Flask is like a lightweight web server that handles requests”
• “HTML structures your content, CSS makes it pretty, JavaScript makes it interactive”
• “APIs are like asking another computer to do work for you”

It was like having a patient tutor who could also write code.

PlantUML Diagram:

The Build Process: 4 Hours of Pure Magic (And Confusion)

Here’s how those 4 hours actually broke down:

Hour 1: Requirements and Planning

I spent the first hour writing out exactly what I wanted:

• User inputs personal information
• System generates personalized tarot reading
• Clean, mystical interface design
• Integration with AI for interpretations
• Basic security to prevent API abuse

The AI agent asked clarifying questions that made me think deeper:

• “What happens if the user doesn’t know their birth time?”
• “How many tarot cards should be drawn?”
• “What style of interpretation do you want?”

Hour 2: System Design and Setup

The AI helped me understand the architecture and set up the development environment. This is where I learned about:

• How web applications actually work
• Why we separate frontend and backend
• What APIs are and how to use them
• Basic security considerations

Hour 3: Core Development

This was the magical part. I described what I wanted, and code appeared. But it wasn’t just random code—it was structured, commented, and actually made sense because the AI had full context of the project.

Hour 4: Testing and Bug Fixes

Even with AI help, things didn’t work perfectly the first time. But debugging was different—instead of hunting through stack traces, I was having conversations:

• “The form isn’t submitting properly”
• “The API response isn’t displaying correctly”
• “The styling looks weird on mobile”

Each issue got fixed within minutes because the AI understood the entire codebase.

The Deployment Surprise: From Local to Live in Minutes

After the app was working locally, I wanted to show it to my friends from my VGU master’s program. That meant deploying it to a real server.

In the old world, this would have involved:

• Setting up a production server
• Configuring databases
• Managing SSL certificates
• Setting up CI/CD pipelines

With my home lab and Cloudflare tunnels, it took about 20 minutes:

1. Upload the code to my server
2. Set up a Cloudflare tunnel
3. Point my domain to the tunnel
4. Add some basic rate limiting

Suddenly, I had a real app running on my own domain. My friends were shocked—they knew me as the “business guy,” not someone who could build and deploy applications.

The Learning Rabbit Hole: From One App to Seven Projects

Here’s where things got dangerous. After that first success, I was hooked. Within a week, I had 5-7 different repositories on GitHub, each exploring different ideas:

• Converting the Flask app to React.js and Node.js
• Building a mobile version with React Native
• Experimenting with different AI APIs
• Creating microservices architectures
• Playing with different deployment strategies

My effort got completely scattered, but I was learning at an incredible pace. Each project taught me something new about modern web development, and the AI was there to explain concepts as I encountered them.

The Reality Check: It’s Not Magic, It’s Process

After a few weeks of building, I started to understand something important: vibe coding isn’t a magic button that turns ideas into apps. It’s a process that requires:

1. Clear thinking – You still need to understand what you’re building and why
2. Good requirements – Vague prompts lead to disappointing results
3. Context management – The AI needs to understand the full picture
4. Iterative refinement – First versions are rarely perfect
5. Basic technical understanding – You don’t need to write code, but you need to understand how systems work

The most common criticism I heard was: “Vibe coding is just for non-tech people to show off to developers.” And you know what? There’s some truth to that if you approach it wrong.

But when you combine domain expertise (like my product management background) with AI-assisted development, something powerful happens. You can go from business requirement to working prototype faster than ever before.

The Technical Skills I Actually Learned

By the end of two months, I had picked up more technical knowledge than in years of working with development teams:

Frameworks and Tools

• React.js and Node.js ecosystem
• React Native for mobile development
• Different deployment strategies
• API design and integration
• Basic DevOps with Docker and cloud services

Development Practices

• Version control with Git
• Code organization and structure
• Testing and debugging approaches
• Security considerations
• Performance optimization basics

The Meta-Skills

• How to research and evaluate technical solutions
• How to communicate effectively with AI agents
• How to break down complex problems
• How to iterate and refine based on feedback

But here’s the key: I didn’t learn these by memorizing syntax or debugging obscure errors. I learned them by building real projects and having the AI explain concepts as I encountered them.

PlantUML Diagram:

The Discord Community: Learning from Fellow Vibe Coders

One of the best parts of this journey was joining the Kiro Discord community. Suddenly I was connected with other people going through the same learning process—some with traditional coding backgrounds, others like me coming from business or design.

The conversations were fascinating:

• “How do you handle state management in React?”
• “What’s the best way to structure API endpoints?”
• “How do you prevent users from abusing your AI endpoints?”

I was learning from experienced developers while also helping newcomers who were just starting their vibe coding journey. It felt like being part of a new kind of development community.

The Business Analyst Perspective: Why This Changes Everything

After 7-8 years in product management and business analysis, I can tell you that vibe coding fundamentally changes the relationship between business and technology.

Traditional development has this huge translation layer:

• Business stakeholders describe what they want
• Product managers write requirements
• Developers interpret and estimate
• Something gets built that’s sort of what was requested

With vibe coding, that translation layer shrinks dramatically. As a PM, I can go directly from business requirement to working prototype. I can test ideas quickly, get user feedback, and iterate without waiting for sprint planning meetings.

This doesn’t replace developers—it makes them more valuable. Instead of spending time on routine implementation, they can focus on architecture, performance, security, and complex problem-solving.

The Mistakes I Made (So You Don’t Have To)

Let me save you some pain by sharing my biggest mistakes:

Mistake #1: Feature Creep Without Purpose

I kept adding features because I could, not because users needed them. The birth time requirement? Perfect example of this.

Mistake #2: Not Planning for Scale

My first app had zero consideration for multiple users, rate limiting, or security. It was basically a proof of concept that I accidentally put into production.

Mistake #3: Getting Distracted by Shiny Tools

I spent way too much time trying every new AI coding tool instead of mastering one approach and building something meaningful.

Mistake #4: Ignoring User Feedback

I was so excited about the technical achievement that I forgot to actually ask users if the app was useful.

Mistake #5: Not Documenting the Process

I wish I had written down more about what I learned along the way. This blog post is partly me trying to capture those insights before I forget them.

The Security Wake-Up Call

One thing that hit me hard was realizing how vulnerable my first app was. I had basically exposed my Gemini API key to the internet with minimal protection. Anyone could have spammed my endpoints and run up huge bills.

This taught me an important lesson: AI can help you build fast, but you still need to understand security fundamentals. I quickly learned about:

• API rate limiting
• Input validation
• Environment variables
• Basic authentication
• Monitoring and alerting

The AI helped me implement these protections, but I had to know to ask for them.

The Mobile Development Surprise

Last week, I decided to try building a mobile version using React Native. Six months ago, mobile development seemed like this completely separate skill that would take months to learn.

With vibe coding, I had a working mobile app in a few days. The AI helped me:

• Choose the right libraries and frameworks
• Understand mobile-specific design patterns
• Handle device-specific features
• Set up the development environment
• Deploy to test devices

I’m not saying I’m a mobile developer now, but I can build functional mobile apps that solve real problems. That’s pretty incredible.

The Community Response: From Skepticism to Curiosity

When I first shared my tarot app with friends and colleagues, the reactions were mixed:

The Skeptics: “This is just a demo. Real development is much more complex.”

The Curious: “How did you actually build this? Can you show me?”

The Converts: “I want to try this. Can you help me get started?”

Over time, I’ve seen more people move from skepticism to curiosity. Even traditional developers are starting to experiment with AI-assisted development, not to replace their skills but to amplify them.

The Vietnamese tech community is still catching up, but I’m seeing more interest in AI coding tools and vibe coding approaches.

What’s Next: The Evolution Continues

Two months in, I feel like I’m just getting started. The landscape is evolving so fast:

• Context engineering is becoming more sophisticated
• Spec-driven development is emerging as a best practice
• Test-driven AI development is the latest trend I’m exploring

Each month brings new tools, techniques, and possibilities. The key is staying curious and continuing to build real projects that solve actual problems.

PlantUML Diagram:

The Honest Truth: It’s Still Hard Work

Let me be clear about something: vibe coding doesn’t eliminate the need for thinking, planning, and hard work. It just changes what kind of work you do.

Instead of debugging syntax errors, you’re debugging requirements and context. Instead of memorizing APIs, you’re learning to communicate effectively with AI systems. Instead of fighting with deployment scripts, you’re thinking about user experience and product strategy.

The work is different, but it’s still work. And honestly? I find it much more engaging than traditional development.

Advice for Fellow Product People

If you’re a PM, BA, or business stakeholder thinking about trying vibe coding, here’s my advice:

Start Small

Don’t try to build the next Facebook. Pick a simple problem you actually have and build a solution for it.

Leverage Your Domain Knowledge

Your understanding of user needs and business requirements is your superpower. Use it.

Learn the Basics

You don’t need to become a developer, but understanding how web applications work will make you much more effective.

Join Communities

Find other people on the same journey. The learning happens faster when you’re not doing it alone.

Document Everything

Write about what you learn. It helps you process the information and helps others who come after you.

GIF Idea: Vietnamese PM confidently walking into a room full of developers, laptop under arm. Developers look surprised as PM starts demonstrating working prototypes. Caption: “Khi PM biết code, meeting ngắn hơn nhiều” (When PMs know how to code, meetings are much shorter)

The Future is Already Here

Looking back on these two months, I’m amazed at how much has changed. I went from someone who could only describe software to someone who can actually build it.

But more importantly, I’ve gained a new perspective on what’s possible when business knowledge meets AI-powered development tools. We’re not just building apps faster—we’re changing how we think about the relationship between ideas and implementation.

The future where anyone can build software isn’t coming. It’s here. And honestly? It’s pretty exciting.

Inspirational illustration showing Vietnamese developer’s journey from confused beginner to confident builder. Multiple screens showing progression of projects, from simple tarot app to complex mobile applications. Upward arrow trajectory with Vietnamese motivational text. Community of diverse developers in background.

Try It Yourself: Your First Vibe Coding Project

If this post has inspired you to try vibe coding, here’s a simple challenge:

1. Pick a small problem you actually have
2. Write clear requirements (spend time on this!)
3. Choose simple tools (don’t overcomplicate)
4. Start building with AI assistance
5. Share your results with the community

Remember: the goal isn’t to build the perfect app. It’s to learn the process and prove to yourself that you can turn ideas into working software.

And if you get stuck? The community is here to help. We’re all figuring this out together.

---

Mong được nghe về journey của bạn! If you try vibe coding after reading this, I’d love to hear about your experience. What did you build? What surprised you? What was harder than expected?

Drop me a comment or email—let’s learn from each other’s journeys.

Let’s keep building the future, one app at a time!

---

Built with AI assistance (and a lot of trial and error) | September 2025

P.S. – If you want to try my tarot app, you can find it at [domain]. But fair warning: I still don’t know why I made birth time required. Some mysteries are better left unsolved.

Below are some UI and styleguide of my app, all ai-assisted job.