From Idea to Reality: Developing a Web App in a Weekend Without Coding

I haven’t written serious code in many, many years—and every time I tried to get back into it, it was painful. 😀 So much has changed that catching up felt completely ... overwhelming. That was true until recently.

Cursor (and other companies like Windsurf) has added a new feature to their IDE called Agent Mode. It doesn’t just autocomplete lines of code—it can build entire applications based on plain-language instructions.

Naturally, I had to find out if this was something that could actually change the way people build software. And honestly? It completely blew my mind.

From an idea to a running application

For a long time, I had this idea for a health app—something that would track all kinds of data and give me personalized recommendations and suggestions. But realistically, I knew I’d never be able to build it myself in this lifetime 😀.

So I decided to give it a shot using Cursor’s Agent Mode, just to see how far it could take me.

The first thing was to set it up (you can find more on how to do it here). Once I was ready, I gave Cursor a high-level instruction like this:

• “Build a web application in Python using Django as the web framework, SQLite as the database, and use a standardized UI framework. The application navigation looks like <overview of the navigation>. At the moment, all pages are empty. We will add functionality later.”

And that was it. Cursor’s AI agent handled everything—it installed the necessary libraries, dependencies, created a functional Django project, built a decent-looking UI, and gave me a solid starting point.

From there, I went into an iterative loop with the agent. I gave it instructions like:

• “Add a new page here. This is how I expect it to work.”
• “On this page, if I do X, I expect Y to happen.”
• “I clicked this, but it didn’t do what I thought it would. Fix the bug.”

Every step felt like a natural conversation, not technical micromanagement. I tried to keep my language “analytical,” aiming to be as clear and unambiguous as possible, but I didn’t need to describe edge cases or validation logic in detail. The AI agent filled in the blanks with surprisingly smart assumptions. Forms worked. Validation was in place. Navigation was smooth. Error handling was handled. What used to be hours (or days) of setup and debugging was now just a back-and-forth chat.

Sometimes it missed the mark slightly, but tweaking things was quick and intuitive. And sometimes, I even got unexpected features as a side-effect of a request—bonus functionality I hadn’t asked for but really liked!

The Weekend Project

I worked on the app over a weekend, and in just two days, I had a fully functional health-tracking application that I now use every day! The UI is decent, it fits my personal needs perfectly, and if I want to change anything, I can usually do it in 15-30 minutes.

I’m not going to make bold claims about the quality of the code, but the app is stable. No data issues or database errors. Even after over a month of daily use. 

I’ve kept adding new features, and I genuinely enjoy the fact that I can do it all myself 🙂. Now, after all those updates, the application has grown to over 20,000 lines of code—so it’s definitely not a small project anymore. Sure, it takes the AI a bit longer to implement changes now, but it still gets things right. And in the end, that’s what really matters.

Lessons learned

First of all, I came across a post from Tomas Cupr (here) and completely agree with all his points (project rules, context, testing, etc.), so I won’t repeat them. Instead, I’ll share a few additional thoughts based on my own experience working with Agent Mode (Keep in mind that I tried to avoid directly checking or editing the code):

• Outline navigation and app structure early - If you already have a clear idea of what you want to build, outline the navigation and overall app structure from the start. Making structural changes later, especially to the UI, can be tricky and time-consuming. But if your page design is solid from the beginning, it’s easy to say things like: “Create a new page X and use the UI style from page Y.”
• Use AI to understand and then modify features - Before requesting changes, ask the Agent to give you an overview of how a feature or flow works. Once you have that summary, you can often just say something like: “Modify step 3 to include functionality X.” This approach can be especially useful when a simpler/direct instruction doesn’t produce the desired result.
• Make iterative changes - At first, I asked the Agent to build a large chunk of features all at once. It didn’t completely fail—it did build something—but it wasn’t what I had in mind. Fixing it turned out to be more work than it was worth, so I scrapped it and started over. Big, complex requests are not practical because AI fills in too many gaps and makes too many assumptions, and the end result is not what you want.
• Back up frequently - Even for small changes, back up your work. Run tests, and be ready to revert when things break. This saved me more than once.
• Help AI understand the broader impact - When making a change, let AI know what else might be affected. In my case, I had three areas displaying similar information. If I didn’t explicitly tell the AI to update all of them, it would usually change just one, leaving bugs I had to fix later.
• It struggles with UI - There were a few cases where it was tough to get the AI to make the UI changes I wanted. I had to try multiple times, rephrasing the instructions in different ways to get the results I needed. In fact, most of my bug-fixing time went into resolving UI issues, while only a small portion was spent fixing business logic.
• Direct code changes - There were two moments when I had to inspect the code and step in myself to make changes. One was a UI issue. The AI tried over 20 times and still couldn’t get it right. The other was a complex math calculation that the AI couldn’t implement correctly.
• Plan for code reuse early - If you know a feature will be reused elsewhere, mention it up front. Something like: “Build X, but note that this will be reused in other areas later”. That works much better than coming back later and saying: “Do it the same way as in feature Y”. By that point, the AI might try to refactor the code, which can lead to all sorts of issues.
• Understanding the logic helps - Having some coding knowledge definitely helped me give better instructions and anticipate potential issues (especially around code reusability). You don’t need to be deep in the code, but understanding the logic behind what you're building makes it much easier to guide the AI effectively.
• Large refactorings are … challenging - At one point, I asked the AI to refactor a file that had grown to over 2,000 lines—and it completely broke the app. The files got corrupted, and I had to roll everything back. At that stage, it was too late to refactor safely and easily. I’m sure it’s still doable, but it would probably take half a day and a lot of trial and error. Avoid letting things get too big before you clean them up.

Final Thoughts

What else can I say? This was one of the most exciting experiences I’ve had in years. I skipped the grunt work, focused on logic and user experience, and actually got the job done.

And it’s not just about personal side projects. I can already see the impact on product managers building prototypes, startup founders trying to launch their first version of the product, or teams finally creating all the internal tools they’ve wanted for years.