Vibe Coding: How to Build a Real Website With AI From Scratch
Building a website used to mean spending hours writing code, searching through documentation, figuring out why something wasn’t working, and trying to understand unfamiliar technologies. Today, AI has changed that process dramatically.
You can describe what you want in plain English, have AI generate the code, run it locally, look at what happened, and then continue the conversation until the website starts behaving the way you want.
This approach is commonly known as vibe coding.
But vibe coding isn’t simply telling an AI, “Build me a website” and waiting for a finished product. Building something that actually works in production is much more involved.
We experienced this firsthand while building the Dorado9 website. What started as a website project gradually involved React, APIs, FastAPI, MongoDB, WordPress, authentication, an admin panel, hosting, deployment, debugging, and plenty of moments where something simply refused to work.
That experience provides a useful look at what AI-assisted website development actually looks like in the real world.
What Is Vibe Coding?
Vibe coding is an AI-assisted approach to software development where you describe what you want to build or change using natural language and use AI to help write or modify the code.
Instead of needing to know exactly how to implement every component before you start, you can communicate the outcome you want and allow AI to help with the implementation.
For example, instead of manually figuring out how to build an animated portfolio section in React, you might tell AI that you want large typography, project cards, smooth hover animations, a dark editorial aesthetic, and a responsive mobile layout.
AI can then generate the initial implementation.
But that’s only the beginning.
You run the website and look at the result. Maybe the cards are too small. Maybe the spacing doesn’t feel right. Perhaps the animation is too fast on mobile.
You tell AI what you see, it modifies the code, and you test again.
This creates a continuous development loop:
Describe → Generate → Run → Inspect → Modify → Test → Repeat
That loop is really the heart of vibe coding.
Start With the Website, Not the Code
One of the easiest mistakes to make when working with AI is starting with a vague instruction such as “Build me a business website.”
AI can certainly generate something from that prompt, but the result is unlikely to match what you actually have in mind.
Before writing code, you need to think about the website as a product.
What pages does it need? Which sections will contain information that changes regularly? Which parts should be static? Will there be a blog? Will someone need to manage content without touching the code? Does the website need authentication? Will there be a database?
For a business website such as Dorado9, the structure eventually included areas such as the homepage, services, portfolio, courses, blog, contact functionality, and an administrative interface.
Once you know what you’re building, AI becomes much more useful because you’re giving it a clear problem to solve rather than asking it to invent the entire product.
Choosing the Technology Stack
One of the interesting things about building with AI is that you don’t necessarily have to restrict yourself to a single technology.
For the Dorado9 website, the frontend was built using React. The backend uses FastAPI, with MongoDB Atlas handling database storage. The frontend is hosted on Hostinger, while the backend initially runs separately.
WordPress is also used for managing blog content.
That gives the project a structure somewhat like this:
User
│
▼
React Website
│
┌────────────┴────────────┐
│ │
▼ ▼
FastAPI WordPress
│ │
▼ ▼
MongoDB Atlas Blog Content
You don’t need to use this exact stack for your own project. The important lesson is that AI can help you work across different parts of a modern web application, provided you understand how those parts are supposed to communicate with each other.
Building the Frontend With AI
The frontend is often where vibe coding feels the most intuitive.
You can describe a visual idea, generate a component, run it in the browser, and immediately see whether the result matches your expectations.
For example, you might ask AI to create a course section with large typography, interactive cards, subtle animations, and a responsive layout.
Once the component appears in the browser, you can make decisions based on what you actually see.
You might realise that the desktop version looks great but the mobile version feels cramped. Instead of trying to figure out the CSS yourself, you can explain the problem to AI and ask it to adjust the responsive behaviour.
This makes development feel much more conversational.
You’re not necessarily thinking in terms of individual lines of code. You’re thinking in terms of what the product should do and how it should feel.
AI-Generated Code Still Needs to Be Tested
This is where the reality of vibe coding becomes important.
AI can generate a lot of code very quickly, but generated code isn’t automatically correct simply because it looks professional.
At different stages of development, you can run into errors such as:
Module not found ReferenceError: api is not defined 401 Unauthorized 403 Forbidden 404 Not Found 500 Internal Server Error
The solution isn’t to keep asking AI to regenerate the entire project.
Instead, you need to understand what the error is telling you.
For example, if the browser says “ReferenceError: api is not defined”, the problem is likely somewhere in the JavaScript code where a variable or imported function called api is being used without being available in that scope.
If an API returns a 401 Unauthorized response, the problem is much more likely to involve authentication or credentials.
This is why learning the basics of development still matters when you’re using AI.
Building the Backend
As soon as a website needs dynamic functionality, the frontend usually needs to communicate with a backend.
For Dorado9, FastAPI handles the backend side of the application. It provides API endpoints that the React frontend can communicate with when it needs dynamic data or needs to perform an operation.
MongoDB Atlas is used to store the relevant application data.
The basic flow looks like this:
React │ ▼ API Request │ ▼ FastAPI │ ▼ MongoDB │ ▼ API Response │ ▼ React
AI can help create API routes, database models, authentication logic, validation, and the frontend code required to communicate with those endpoints.
But once again, you need to test every connection. A typo in an endpoint, an incorrect environment variable, a CORS configuration problem, or an authentication issue can prevent an otherwise perfectly good frontend from communicating with the backend.
Why We Used WordPress for the Blog
Not everything needs to be custom-built.
For the Dorado9 blog, WordPress provides a convenient content management system while React handles the visual presentation of the website.
Instead of displaying the traditional WordPress frontend, the React website can request blog posts through the WordPress REST API.
The basic architecture looks like this:
WordPress
│
▼
WordPress REST API
│
▼
PHP Proxy
│
▼
React Blog
This approach provides the flexibility of a custom React frontend while keeping content management relatively straightforward.
It also demonstrates an important principle of AI-assisted development: don’t build something from scratch simply because you can.
If an existing technology already solves part of the problem well, use it.
Building an Admin Panel
Once your website contains dynamic content, you’ll eventually need a convenient way to manage that content.
That’s where an admin panel becomes useful.
The Dorado9 admin interface allows content to be managed through the website rather than requiring database records to be edited manually.
The admin area contains sections for blogs, courses, and portfolio projects. Depending on the type of content, the interface communicates with either the backend or the appropriate content source.
This is one of the points where a project stops feeling like a collection of web pages and starts behaving like a proper web application.
Debugging Becomes Part of the Workflow
One of the biggest lessons from building with AI is that debugging isn’t something that happens only when everything has gone wrong.
It becomes part of the normal workflow.
When something doesn’t work, the browser gives you evidence.
The Console can show JavaScript errors. The Network tab can show exactly what request was made, where it went, what status code came back, and what the server returned.
For example, seeing a request such as:
GET /wp-api.php?endpoint=posts 500 Internal Server Error
gives you much more information than simply saying, “My blogs aren’t loading.”
The same applies to frontend errors. If React reports that a module cannot be found, you can give that exact error to AI and allow it to investigate the relevant import or file path.
The more precise the information you provide, the more useful the AI’s response tends to be.
Understanding HTTP Errors Helps a Lot
You don’t need to become a backend engineer to work effectively with AI, but understanding basic HTTP status codes makes troubleshooting much easier.
400 Bad Request generally means that the request itself isn’t valid.
401 Unauthorized usually points toward missing or incorrect authentication.
403 Forbidden means the server understood the request but is refusing access.
404 Not Found means the requested resource couldn’t be found.
500 Internal Server Error means something went wrong on the server side.
Once you understand these basic distinctions, your conversations with AI become much more precise.
Instead of saying, “The save button isn’t working,” you can say, “The save request returns a 401 response from the API.”
That’s a much better starting point for debugging.
Deployment Is Where Things Get Real
A website working on your computer doesn’t necessarily mean it’s ready for the internet.
This was another important part of the Dorado9 development process.
Locally, the React application might be running at:
localhost:3000
But production introduces real domains, HTTPS, hosting servers, environment variables, API endpoints, CORS policies, DNS, caching, and authentication.
A configuration that works perfectly on your computer can fail as soon as you deploy it.
That’s not necessarily a sign that the project is broken. It’s simply another stage of development that needs to be tested.
Localhost Is Not Production
This is one of the simplest lessons, but also one of the easiest to forget.
Before considering a website finished, you need to test the actual production environment.
Open the live website. Navigate through the pages. Submit forms. Test the admin panel. Check the blog. Test mobile layouts. Look at the Network tab when something behaves unexpectedly.
Don’t assume that because something worked locally it will automatically work after deployment.
What Vibe Coding Actually Changes
The biggest misconception about vibe coding is that it eliminates the need to understand development.
It doesn’t.
What it changes is where you spend your time.
Instead of manually typing every piece of boilerplate code, you can spend more time thinking about the product, testing ideas, identifying problems, making architectural decisions, and improving the user experience.
You become less focused on writing every individual line and more focused on directing the system.
That doesn’t mean you can completely ignore the code.
In fact, the more complex the project becomes, the more useful basic technical knowledge becomes. You need to recognise when an error is related to a frontend component, an API, authentication, a database, hosting, or something else entirely.
Can Someone With Limited Coding Experience Build a Website With AI?
Yes, but there is an important condition.
You need to be willing to learn enough to understand what you’re building.
You don’t have to memorise the entire React documentation. You don’t need to know every FastAPI function. You don’t need to become a database administrator.
But concepts such as APIs, databases, authentication, HTTP requests, environment variables, hosting, DNS, and browser debugging are worth understanding.
Once those concepts start making sense, AI becomes much more useful.
You can ask better questions because you understand the system you’re working with.
Vibe Coding Is a Skill, Not a Shortcut
The real advantage of AI isn’t that it lets you skip development.
It’s that it reduces the distance between having an idea and implementing it.
You can start with something as simple as:
“I want a website for my business.”
That idea can gradually become a complete system containing a frontend, backend, database, CMS, authentication, admin panel, APIs, deployment infrastructure, and production content.
AI can assist at almost every stage of that process.
But you’re still the person deciding what the website should be, what problems need solving, what should be changed, and whether the final result is actually good.
Want to Go Deeper?
Want to take your understanding of vibe coding further? We’ve put together a comprehensive, step-by-step guide covering the practical process of building a website with AI, including the tools, workflow, development process, and lessons learned along the way.
Read the complete Vibe Coding Guide →
Final Takeaway
Building a website with AI isn’t about asking an AI to magically produce a finished website.
It’s about creating a development loop where you describe, AI implements, you test, and you iterate.
The more clearly you can communicate what you want, understand the basic architecture, and diagnose what went wrong, the more capable you become at building real software with AI.
That’s probably the most useful way to think about vibe coding.
AI writes a lot of the code. You build the product.

