Vibecoding - just a trend, or a serious method?

What is Vibecoding?

“Vibecoding” was coined by well-known computer scientist Andrej Karpathy on Twitter early this year, and it has caught on as a slang term for instructing AI Agents (large language models) in natural language prompts (chatting with the program) to generate, rewrite, or debug a code base instead of writing it. 

In his post, he mentioned that he doesn’t need to think about the code itself — he only focuses on the application and instructs the AI to create it. If there’s any problem, he doesn’t worry about it and lets the AI fix it. AI can generate large amounts of code quickly — more than he could read in a reasonable time — so he doesn’t even bother checking everything. The LLMs are now so good that he can mostly trust them, and it usually works.

Is this really true or an exaggeration? Are LLMs really becoming powerful enough to be like ‘Jarvis’ from Iron Man — where you simply tell them what to create, and they figure out the best way to do it? Could every developer become an Iron Man? I’m sure plenty would love the chance.

I’m sorry to say it, but the reality isn’t quite there yet. Thanks to over 70 years of research in deep learning and neural networks, chatbots like ChatGPT can now understand and generate text, code, and content based on natural language instructions. They’re great for summarising information, answering questions, explaining topics, and providing guidance and suggestions. However, they cannot guarantee flawless information or perfect execution of tasks. They can make independent decisions based on context, but they cannot fully replace humans in all domains yet.

What is the reality in coding now?

When OpenAI launched ChatGPT to the general public in November 2022, people were amazed by what it could do. During the first five days, it gained over 1 million users. It was powered by the GPT-3.5 language model, which was the first GPT model from OpenAI large enough to handle meaningful code generation and completions. Here is a short evolution in the capabilities of GPT models. 

Evolution from GPT-3.5 to GPT-5: 

• GPT-3.5 (2022): 
  
  • good for junior-level tasks (basic functions, code explanations, code translations)

• GPT-4 (2023):
  
  • handled bigger projects, better logic (less mistakes in algorithms), better tests and documentation

• GPT-5 (2025):
  
  • mid-level developer quality, reasoning capability 

The Bottleneck is that it's still not perfect, and developers need to control the code, especially in areas as security, architecture or performance. It can also overcomplicate (over-engineer) the code. 

OpenAI is, of course, not the only company working on the development of LLMs. In next years, several other players launched their first commercial versions: 

• Anthropic (Claude), which became a serious competitor to GPT-4; 
• Google, with its multimodal Gemini model connected to Google Search; 
• Meta (LLaMA 2)
• Perplexity AI
• DeepSeek (DeepSeek)
• Mistral AI (Mistral Large)
• xAI (Grok) and others. 

Each of these companies is relentlessly refining its models to outperform the competition. While every model has its own strengths and weaknesses, each tends to excel in different areas.

Individual LLM models are continuously tested across many areas (performance, safety, ethics, truthfulness, …), one of which is programming performance. Models are evaluated against different programming challenges and assessed based on how well they perform. 

According to the latest benchmarks, Anthropic’s Claude currently seems to be the leader in coding performance (source: swebench.com). Its strengths lie in fixing bugs, handling large multi-file projects, and refactoring. GPT is close behind, with stronger capabilities in working across multiple languages (Python, Java, JavaScript, Go, Rust). This makes GPT particularly well-suited for tasks involving UI, web components, and smaller scripts.

“In 5+ years, LLM models can be so advanced that the required development skills will be minimal or even nonexistent. AI could be able to suggest solutions as effectively as a great programmer.”

— Pavel Janko, CTO at Moravio

Alongside the models, a variety of tools have been developed to make coding faster and easier. These include:

• GitHub Copilot
• Cursor
• Windsurf
• Replit
• Claude Code
• Codex
• Bolt
• Lovable
• V0
• …

They vary in:

• Model choice
• Usability / IDE integration 
• Pricing
• Supported programming languages
• Context length 
• Autonomy
• Collaboration 
• Safety / guardrails
• Performance

Most of them can also be used by non-developers as Vibecoding platforms without any coding knowledge, but only up to a certain level. They can be used for learning programming, creating simple scripts for Excel automation, or data manipulation, explaining code, or working with low-code/no-code tools. (e.g., Replit, Loveble, Bolt, V0).

For Complex projects, debugging, integrating AI-generated code, and interpreting AI suggestions,s development knowledge is still required. 

Where does Vibecoding fit in serious software development? 

Vibe coding, in definition, is a creative, experimental, playful way of coding. It has its place in:

• Rapid prototyping - experimenting with ideas, creating proof of concept, or replacing traditional wireframes. 
• Creative coding - generating art, music scripts, visualisation, and other expressive projects.
• Hobby/ fun projects - coding for enjoyment or exploration

Vibecoding allows you to write code at amazing speed without worrying about efficiency, safety, or best practices.

Vibecoding at Moravio?

AI-generated code saves a lot of time in a designing phase. Prototyping new features, new products (creating proof of concept) is now possible in a matter of a few days instead of weeks (depending on size and complexity). Also, it is much more accessible to people with limited or no programming skills. AI allows you to think through the product details much better, present them more clearly to the client, and agree on the final product.

The trend in software development is now to return to spec-driven development, meaning specifying exactly how the product or software will work before coding the actual product. (Source) This is not a new approach — it has been used for several years on different scales. The bottleneck has always been that it was usually in the form of a large written document, shared and agreed upon with the client, often tied to a contract. The document could contain designs, wireframes, API schemas, and more. 

Issues of spec-driven development before AI:

• really hard to specify every detail about the software, 
• It took a lot of time,
• and it was still possible that different people would interpret it differently,
• difficult to keep the entire document up to date when making changes.

Luckily, all of this is now much easier and more feasible with AI and Vibecoding.

Developers or product managers can now specify the application in words (so the document is still created), and AI will generate, for example, a React app. It looks like a functioning application with “hardcoded data” (no API connected). It looks close to the real product; changes can be reflected quite easily, but it is not yet a production-ready application. It can also be used for smaller pieces, such as a single feature.

The prototype can be shared across the whole organization, allowing people to test the business logic behind the product. It is much more understandable than static graphics or a clickable wireframe. Once the specification is finalized, it can be easily transferred into development tasks and provides AI with much more context for building the real application. 

For this approach, we are currently using v0, but for larger projects we need tools like Cursor that can handle bigger project sizes and contexts. 

In the development phase, our programmers mostly use Cursor. It is easy to work with and allows access to the project context. It also enables changing models per feature, depending on which model is best suited for the task.

Models powering Cursor can be used to create pages, detail pages, modal windows, and typical features commonly used in web applications. It can also assist with creating automated tests, styling, displaying data, and similar tasks. It can generate basic and straightforward code efficiently.

The key is to use detailed, targeted prompts, apply common sense, and carefully review the generated code before using it.

In a time before AI, senior developers had to design the entire app architecture, figure out how the app should work, define all the components, and often had little time left to write actual code. Especially when managing a team of developers, they also had to coordinate the team’s work.

Now AI can help generate code at a mid-level programmer quality. What AI still cannot do is fully grasp the entire app context, efficiently determine how to connect all the features so that the app works effectively, and ensure that the code remains maintainable.

This is changing the size of the team we need to work on specific projects. Usually, we now have only a senior developer working with AI. It is possible to work in teams on bigger projects, but it has to make sense. They need to be working on different parts; otherwise, it would be even less efficient. There are also Libraries and other tools (cursor rules) that are emerging very quickly, helping to maintain application context and consistent code. We could say that Co-development is becoming less effective than before on smaller projects. 

"Developers now need a new core skill: the ability to effectively prompt a large language model (LLM). This includes describing the specification in detail, taking the time to explain to the model exactly what needs to be built, and providing a few examples of code so that the AI can generate consistent and reliable output.”

— Pavel Janko, CTO at Moravio

We use Vibecoding only in the design phase, where the main focus is on the product, user flow, and business logic. When developing the actual application, we take quite the opposite approach to Vibecding-style software development— a carefully thought-through process where we know exactly what we are building and how it should be built, using AI only to generate code according to our specifications.

There are also other areas where our developers use AI to be more efficient. It is great for helping to summarise and understand very complex topics (e.g., “Explain how encryption and cryptography work”) that would otherwise take developers many days to study Scriptas. It enables one to learn new topics much quicker than it would take a person alone searching the internet. 

AI is changing the way of working, not justfor designers, developers but also testers. AI models can be used to generate tests in tools like Cursor, or there are new tools that can even replace testers by using acceptance criteria.  

Right now, our testers are using AI to write better and more tests using Visual Studio Code, Copilot, Claude.ai, and, of course, ChatGPT.

Risks We See Ahead

• A flood of low-quality apps that seem to be working but lack proper structure, security and are hard to maintain.
• Over-engineering - AI can generate more code than is actually needed
• False simplicity: “Anyone can code” illusion hides complexity (can lead to deleting production data e.g., Hot_Bologna_Sandwich, comment on Reddit , Aug 19, 2025) 
• Security gaps: AI doesn’t prioritize architecture or compliance.
• Dependency risk: Teams that blindly rely on AI will eventually hit its limits — limits they won’t be able to overcome on their own.
• Dependency on the tools and models: if the creators change pricing or impose restrictions, it it will directly affect development companies. 
• It can save time but also waste time if developer does not understand the AI limits and tries to build complicated application with it. (e.g., Kai Lentit, Youtube, Apr 8, 2025 Senior developere tries to Vibecode) or does not have enough programming skill.

What is next for Vibecoding?

• In 5+ years, AI may handle most coding tasks.
• Developers’ role will shift to prompting, system design, and critical review.
• Senior developers will be even more valuable than before
• Companies that blend AI speed with human expertise will thrive.

Our Take at Moravio

• Vibecoding can be powerful, but only in the right hands
• At Moravio, we embrace it for prototyping and exploration, but for production we pair AI with senior developers to ensure security, scalability, and maintainability.
• We are not afraid to experiment with the AI and explore new tools
• The true value of our people and their skills lies in what AI can’t replace:
  
  • understanding user needs and creating a user-friendly, smooth interface, 
  • choosing the right architecture and structure, 
  • writing high-quality, understandable code, 
  • covering the application with automated tests, that make sense, 
  • ensuring security.

At Moravio, we harness the power of AI to accelerate innovation, without compromising on quality, security, or user experience.