LifeinTECH

In 2021, I wrote an article regarding the release of “GitHub Cpilot”, an AI pair programming capability powered by OpenAI Codex.

This was my first glimpse of a world where code could be generated based on user intent, either by describing the desired outcome or referencing previous code. It sparked a lively debate across the software engineering community, regarding the value and ethics of such a capability, especially one that could (in theory) replace/reduce the reliance on specialist skills.

Personally, I was optimistic, as AI-generated code felt like a natural progression for software engineering, accelerating the development process, whilst also providing new ways to verify and test code, without human intervention.

This journey has led us to the concept and term “vide coding”, which was first introduced in February 2025 by Andrej Karpathy, co-founder of OpenAI and former AI leader at Tesla. Vibe coding refers to a coding approach that relies on large language models, allowing programmers to generate working code by providing natural language descriptions.

Inevitably, this has led to the emergence of specialist “AI coding” platforms, which I would loosely split into two categories. Those platforms that are designed to support software engineers with a technical background, and those that target software hobbyists who have an idea but limited technical experience.

A few examples are listed below. To be clear, these platforms can be used to complement each other, for example, Lovable + Cursor, with a source code management system such as GitHub, providing the common ground.

Software Engineers (AI Coding Assistant)

• Cursor
• Windsurf
• Claude Code

Software Hobbists (Vibe Coding)

• V0 by Vercel
• Lovable
• Bolt
• Figma Make

I have been investigating a few of the “Software Hobbist” platforms, most notably Lovable, V0, and Figma Make. In some respects, these platforms are the most interesting, as they attempt to produce full-stack applications, targeting individuals with little or no software engineering experience. If successful, these platforms have the potential to broaden the scope of what we consider to be software engineers.

At work, we have been testing V0 by Vercel and Figma Make, as they most closely align with our architecture standards and technology stack. However, at home, I have been testing Lovable.

Lovable is considered the most “user-friendly” vibe coding platform for non-technologists. Therefore, I was intrigued to understand how simple Lovable has been able to make the process and how far it could be pushed.

As a test project, I decided to create a simple application to track my gym activity, covering weights, cardio, etc. In many respects, this is a simple Create, Read, Update, and Delete (CRUD) web application. However, it would likely take a single developer several working days to develop manually (assuming no reference code).

I started with the following prompt, outlining six requirements. I did not pay much attention to the structure or “completeness” of the requirements, as I wanted to see how Loveable would interpret ambiguity.

I am looking to create a web application to track my gym workouts. The key requirements are listed below:

1. The web application must be mobile responsive.
2. The web application must have an interface to add new exercises, which could be weights, cardio, etc.
3. The web application must be able to track sets and reps.
4. The web application must be able to track the weight of the weights used for relevant exercises.
5. The web application must track the date/time of the workout.
6. The web application must include a simple timer on the homepage, allowing for certain exercises or workouts to be tracked by time. The user should be able to set the length of the time, with a buzzer (sound) at the end.

The initial result (one-shot prompting) was impressive, as after a few minutes of “thinking”, I was presented with a mobile-responsive homepage that includes a workout timer (as defined in my requirements).

Lovable successfully generated all sub-menus, which provide the ability to create workouts, add exercises, sets, etc. The major functional requirements were incorporated, with a simple user journey that made navigating the application intuitive.

The code produced was also easy to navigate and read. I later took the opportunity to update the code directly within the Lovable editor, which worked as designed, with the changes being reflected/maintained throughout the development process.

With the basic application already working, I then iterated to add some missing features. For example, features to edit/delete workouts and capture the one rep maximum for each relevant exercise. This was all achieved by simply prompting the requirement, which I did incrementally.

When testing the application, I noticed a few minor visual errors (user interface alignment issues) and a couple of functional bugs. To resolve, I simply prompted Lovable to review and resolve the issues. This worked surprisingly well, with only one example that required me to specifically state how I wanted the issue to be resolved (still described in natural language via a prompt).

Regarding backing services, I connected Lovable to GitHub for source code management and Superbase, which is a Postgres development platform that has become popular with Vibe Coding platforms. The setup was simple, with Lovable handling most of the integration steps. Once configured, Lovable could leverage the database as a backing service and would automatically commit updates to GitHub.

Overall, the entire process took me approximately one hour, including the time to set up and configure Lovable, GitHub, Superbase, etc. At the end of the hour, I had a fully working application, which I was able to publish via the Lovable hosting option. I could have also used a third-party host, such as Netlify, pushed via GitHub.

I have been testing with the Lovable “Pro” plan, which was £185.25 for the year, which includes 100 credits per month. A credit tracks usage within the platform, with a variable cost being assigned based on the action complexity.

My gym tracking application consumed approximately 22.5 credits.

Lovable also includes a basic security review capability, which aims to highlight potential risks. I am pleased they include this feature. However, I would recommend leveraging a third-party tool, integrated with GitHub, for a more thorough analysis.

Overall, I have been impressed with Lovable. The user interface is intuitive, and the results are impressive, at least for a simple CRUD web application.

With that said, my experience and ongoing analysis have highlighted a few advantages and disadvantages of vibe coding.

Advantages

1. Prototyping: Vibe coding is great for rapid experimentation and protypting, producing a working asset within hours (vs. days). It is also possible to iterate in real-time, taking direct input from non-technical users. I could see this being very useful when completing discovery with the target user base.

2. Personal Projects: If you are looking to create a simple CRUD web applications for personal use, vibe coding offers a compelling proposition. The speed and simplicity lower the barrier to entry for non-technical users, making application development feasible for a wider audience.

3. Boilerplate Code: Vibe coding can produce respectable boilerplate code, providing a foundation to build from. This could be valuable when starting a new project, helping to accelerate through the initial development phase, allowing the software engineer to focus on the more complex logic. In addition, for software engineers with specific expertise (e.g., backend development), the use of vibe coding could replace the need for additional human resources (e.g., frontend development), allowing software engineers to produce “full-stack” deliverables.

4. Education: If you have previous software engineering experience, vibe coding could be used as a method to learn a new programming language and/or framework. Being able to rapidly generate working code that can be used as a reference could save hours of research, whilst also allowing the software engineer to get “hands on keyboard” more quickly, which accelerates learning and improves engagement (motivation).

Disadvantages

1. Security: At this time, I would not trust any vibe coding platform to generate secure/hardended code, specificlly for key funcionaility such as authentication and authorisation. Security-specific functionality should be custom-developed or imported from a trusted source, including peer review before publishing and after all changes.

2. Backing Services: Middleware and/or backing service configuration, including the Superbase integration, prioritises functionaility over security. This can leave the application and data vulnerable. Therefore, I would recommend that all backing services be reviewed before publishing and after all changes.

3. Complex Logic: Vibe coding is capable of generating simple web applications, that support basic CRUD operations. However, more complex logic and/or building from a “brownfield” application (existing codebase) will likely generate inefficiencies and/or errors that could become increasingly difficult to troubleshoot.

4. Efficiency: To embrace vibe coding effectively, you must accept that the code generated may not adhere to your personal style. This is ok, as it is similar to how different software engineers have certain preferences. However, as a general rule, the best code is the simplest. Vibe coding may not always generate the simplest or most efficient code. With personal projects, this may not cause a concern, but if the application is designed to scale, the performance and support overhead of unoptimised code could become a significant burden.

5. Hidden Risks: With vide coding, there is a tendency to “fire and forget”, assuming the generated code is “right”, as long as it is functional. This approach could quickly lead to hidden risks, which will likely grow over time.

Overall, I am pleasantly surprised by the effectiveness of vibe coding. Considering the immaturity of this space, it is impressive that a non-technical user could go from nothing to a published web application in a few hours with little/no previous experience.

I am confident this is only the beginning. I expect vibe coding to continue to mature rapidly, enabling greater scope and complexity. I also expect the disadvantages to be reduced over time, with more advanced features and automated verification checks to mitigate common issues/risks.

There is also an interesting opportunity to blend vibe coding with advanced AI coding assistants, like Cursor and Claude Code, etc. In this scenario, I could see engineers using low-barrier platforms such as Lovable as part of the initial discovery, importing the output into an IDE, and using an AI coding assistant to deliver production-ready code.

Finally, a common question is whether vibe coding will replace the need for software engineers. In my opinion, the answer is simple: no, it will not.

The value of a software engineer expands beyond the code itself, which is really just an asset produced as part of the process (similar to how an architect may produce a blueprint as an asset).

The real value is the hundreds of decisions that contribute to the final code, designed to solve a specific problem. This requires curiosity, critical thinking, and strong situational awareness (to understand dependencies, etc.)

In addition, experts will still be required to review and understand code, especially in large enterprise systems, many of which may operate critical infrastructure, services, etc. Therefore, code review skills, which require foundational expertise, will likely become increasingly important.

With this in mind, like many revolutions before, I expect the use of AI within software engineering to evolve how individuals and teams work, replacing certain aspects of the process, but not the underlying skillset.

I will be watching this space closely to see how it evolves!