Belitsoft > Vibe Coding Software Development > Vibe-Coding Limits No One Can Avoid

Vibe-Coding Limits No One Can Avoid: Cleanup Specialists On Rise

Vibe coding is when AI quickly puts together the first version of a program. You get something working in a few hours. It is an easy way to test an idea and show the result right away. Many startup founders use AI "vibe-coding" platforms (Lovable, Replit, etc.) to build early versions of their apps. You type a plain-language description of what you want, and the tool produces the code (and sometimes a runnable app). This lets non-technical people with no programming experience create a working prototype quickly and at low cost. About 25% of new startups now use AI for 95% of their code. AI writes more than 30% of Google's new code.

Contents

The Promise: Speed and Cost Savings

Jobs that used to take weeks can now be finished in a few days - about two to five times faster than with traditional approaches, in my experience. AI coding tools let startups build and launch a basic product very quickly - sometimes even from a single prompt. This helps them test ideas and reach users sooner.

Founders can build a prototype without hiring a team because AI coding tools take care of the routine code. This can significantly reduce further development costs. A project that once required 1,000 development hours can now be completed in 200. For a startup, that is a major saving.

From the outside, you look very productive - one day's work now leads to a week's worth of code.

The Hidden Problems

With vibe-coding you can quickly assemble a prototype, but such code usually doesn't work properly. Founders quickly run into errors. LLMs write code that looks fine, but it often has problems that beginners don't notice.

Architecture and Scalability Issues

Founders want code fast and cheap. They use AI to build something that works right now and skip what they see as not important. There is no testing to make sure it is reliable, and no plan for how different parts of the code should fit together. This is only suitable for a demo. Without a good plan for how your code is organized, the app might work but will not scale well. Nobody knows what needs to change when things get bigger. When more customers start using your app or you want to add new features, you may have to rebuild most of it.

Security Vulnerabilities

When you ask an AI tool to write code, you may not think to request checks on user input, password hashing, or access checks, so the AI may ignore it. Tests show that, for example, asking an AI to build a login page with no extra details on security produces code that allows SQL injection. Code built this way often breaks company rules and industry standards. Experienced developers can spot these problems right away.

Performance and Reliability Issues

When AI writes code, it often works slowly - pages load for a long time, database queries take too long, the application is "heavy". If you don't configure and optimize such code, the application will start to "crash" or slow down when many people log in simultaneously.

Small home-grown projects often lack thorough tests. A founder may assume that code from an AI will work, but rare cases, and error handling will be missing. Unit tests, docs, and helpful error text show up only when someone creates them. Without them, the program can break with little provocation.

Teams that code this way in-house often end up with shaky programs lacking solid structure or security checks. They then need experienced engineers to review, rewrite, and prepare the software for day-to-day use. The prototype may run, but it does not meet the standards of a safe, and efficient app, so founders bring in experts.

The Solution: AI Code Cleanup Specialists

When writing the first version, everything is done quickly just to show how the idea works. Then they usually call in experienced programmers or specialized teams to prepare the product for launch. A quick draft and a real product are completely different things.

Now there are companies that specialize in this. Vibe coding cleanup specialists are in high demand to fix poorly-written code with issues generated by AI. They close security holes, write tests, set up automated builds, connect logs and monitoring.

Companies increasingly turn to such specialists to rescue projects where AI code is raw, without proper architecture and security. Those who made demos now call in seniors to make the code stable and secure. Investors and product managers often call such teams before launch to avoid surprises.

Before, everyone was happy that AI could write code in a couple of minutes. Now everyone understands: without experienced programmers, the product won't work for real users.

How Cleanup Specialists Work

In the beginning, startups often write code themselves - just to get something working. But such code is usually unstable, with errors and without proper structure. Then they call in experienced developers to fix bugs, build proper architecture, create protection from hacking, write tests and documentation. They know how to make a stable and secure product from such a prototype. Products stop falling apart and are ready for launch.

Founders come to Belitsoft with first versions of their software products coded by AI agents. Our vibe coding cleanup specialistsmake the products ready for customers: ensure proper architecture, fix bugs, patch security holes, and perform testing. You get a reliable application faster and cheaper than with traditional development.

The Cleanup Process

Experienced programmers look at all the code and search for where hackers might break in. They look for bugs too. Then they decide what's better to rewrite from scratch. There's usually plenty of problematic code. Next they write tests so nothing breaks and check that all parts of the program work normally with each other. In the end, they make it so that customers can use it without problems.

The best AI cleanup companies have a special process for working with AI. Senior engineers plan out how the app should work before any AI writes code. This way the AI-generated code fits the plan better. They build one piece at a time and test each piece as they go instead of building everything at once.  Sometimes they use different AI tools for different jobs. Senior developers put all the pieces together, run tests on the whole app, and fix any problems before anyone sees the code.

AI plus Senior Engineers

These companies have senior programmers and neural networks. Artificial intelligence writes the first version of the code in a few hours. Then senior developers review that code and make it reliable.

By pairing experienced engineers with AI "co-pilot" tools and well-honed processes, these companies can do more with fewer billable hours – savings that get passed to the client.

Instead of an engineer spending a day writing rote code (like writing tests, converting one data format to another, etc.), an AI model can generate most of that code in minutes. The senior engineer's role then shifts to reviewing and refining the AI-generated code. Far fewer human hours are needed for a given scope of work.

AI has freed senior engineers to resolve higher-level issues ten times faster than before. By letting the AI handle the grunt work, a single senior developer can produce the output that might have taken several developers in the past.

These firms assign senior engineers to oversee each step of the AI-assisted development process. AI-generated code serves only as an initial draft. Every line is then tested, reviewed and refined by an expert before it becomes part of the final product. This human oversight catches and corrects bugs, design flaws and security vulnerabilities in the AI code. As a result, clients receive reliable, well-built software more quickly and at lower cost.

The New Economics: Professional Vibe-Coding Software Development

A key reason entrepreneurs seek out these AI-savvy development companies is also the cost. They want the expertise of senior developers, but at a price closer to what they might pay less-experienced coders. The good news for them is that the top cleanup firms have figured out how to dramatically boost senior developer productivity using AI, which in turn lowers the cost of their services.

AI makes coding faster, so projects cost less. You pay for fewer hours of work and get your product out sooner. Projects that used to take six months now take two or three. The quality stays just as good. A project that once cost $200,000 and took six months? Now it's done in two to three months for much less money.

This requires fewer senior developers and less time. The clients get a working product quickly and at a lower cost.

Startups used to need a large team of programmers. Months of work cost a lot of money. AI writes code fast, but the code usually has bugs. Company employees can't fix these problems themselves. So they hire outside experts to clean it up. After that, you need real programmers. They find the bugs and fix them, patch security holes so hackers cannot break in, and make the code stable. Now there are entire teams who take what the neural network has written and turn it into a working product.

Never miss a post! Share it!

Written by
Business Development Director at Belitsoft
Expert in IT staff augmentation (5 dedicated development teams have been created, 500 team members have been hired).
5.0
1 review

Rate this article

Leave a comment
Your email address will not be published.

Recommended posts

Belitsoft Blog for Entrepreneurs
Google Makes Gemma 4 Up to 3x Faster Locally
Google Makes Gemma 4 Up to 3x Faster Locally
Gemma 4 is a popular tool among software engineers for tasks ranging from code generation and debugging to building complex agentic systems. According to Google, the Gemma 4 models were downloaded more than 60 million times since April 2, 2026. Recently, Google has added Multi-Token Prediction to its Gemma 4 family of open models to make text generation faster, achieving up to 3 times the speed without reducing quality.  Previously, generating text involved waiting for the AI to produce each token sequentially. With multi-token prediction, a lightweight drafter model proposes several tokens at once, which the main model verifies in parallel. This leads to faster response times. Since the drafters are open source under Apache 2.0, companies can run them locally. A Different Approach Than Gemini Gemma 4 and Gemini are built for different audiences.  Gemini operates in Google's cloud infrastructure with access to large pools of server-class TPUs. When users ask Gemini questions, the system allocates resources to run the calculations across multiple TPUs.  With Gemma 4, Google has refocused on the needs of developers who want AI that run on their own hardware. Gemma 4 (in its smaller variants) works for consumer grade GPUs SMBs have on their desk: dedicated gaming graphics cards or purpose-built AI accelerators. MultiToken Prediction speeds things up for locally hosted AI. Google also released Gemma 4 under the Apache 2.0 license.  Previously the company used more restrictive licenses that limited how developers could use the models. Now it is easier for businesses to build their own systems: fact-checkers, document summarizers, chatbots, code generators. This opens the door for a new wave of custom applications that business is built on-premise or in private clouds. The Bottleneck MTP Targets The main bottleneck for local large language models was moving weights throughout memory during generation of each word. Since every word requires running the model again to predict the next token, most time was spent waiting on data transfer.  When the model runs at home on a gaming PC or a server with limited video memory, it is often waiting for weights to get fetched from VRAM. You end up with high costs: either you wait long periods for AI to generate text or you need expensive workstation hardware with video cards that have thousands of dollars worth of VRAM to get any real work done. Google's MultiToken Prediction extends the inference speed of Gemma 4. Previously slow models can now handle real-time applications with multi-phrase conversations or text generation. How the Drafters Work The new drafting system has two text generation models: a main model (the target model) and a smaller model (the drafter). Quick token generation: When you ask it to write something, the drafter will quickly come up with a few tokens. Shared memory cache: Meanwhile the main model stores its previous attention computations in another 'bank' of memory called the key value cache. The drafter shares this cache, so it can generate draft text very quickly, without rebuilding from the ground up.  Intelligent mimicking: The drafter is less correct than the main model, so it guesses intelligently based on its training to mimic the main model. Simultaneous testing: The main model compares the drafter guesses against its own predictions and approves or not. It tests all candidates simultaneously. Parallel verification: These guesses are verified in parallel by the larger target model. Keeping the best guesses: When a draft token matches what the target would have generated, the system keeps the text. If every guess in a batch is right, all of them get accepted at once.  Dropping and proposing again: Otherwise it drops that token and everything after it, then the drafter proposes again from that point. The system performs better on speed while preserving output quality. Hardware Performance Gains On Google's Pixel phones, a 2.8 times speed increase on E2B models with the new drafting system. The same Pixel phones perform 3.1 times faster in the E4B configuration with the latest draft system. The new drafting approach is also available on Apple's M4 Silicon chips, where the latest 31B Gemma models run 2.5 times faster with the new speedup. Availability and Integration Open source licensed (Apache 2.0) new drafting Multi-Token Prediction (MTP) Gemma implementations are now available.  This means anyone can use them and change them for free. These reference implementations are already integrated with popular local inference frameworks: MLX, vLLM, SGLang and Ollama.  Today, developers can take the latest release of Gemma and plug drafting in without rewriting existing code or infrastructure. If you just want to evaluate the model, then log in at Google's AI Studio at aistudio.google.com and select Gemma 4 from the list of available models. If you want to run Gemma 4 on your laptop without any server setup, run it locally using Ollama. Gemma 4 can be fine-tuned to specialize for your domain. The recommended way is to use QLoRA with the TRL library. Businesses are already using Gemma 4  Businesses are already using Gemma 4  This is the first time a major AI lab has put frontier-capable AI in the hands of businesses without the need for cloud subscriptions or for data to leave the premises, which is changing AI affordability for SMEs. Running the model locally keeps the client data under the company’s control - an important requirement for GDPR and other regulations.  Gemma 4' function calls and JSON output allow firms to build AI agents that extract data from invoices, route support tickets or generate code without prompt engineering.  Different model variants suit different workloads:  E4B for low‑latency customer service and chat bots,  26B MoE for contract review and financial report analysis,  31B Dense for code generation and complex decision support,  E2B for factory‑floor monitoring and retail assistants.  For those finance leaders who cannot send general ledgers to public cloud APIs, Gemma 4's local deployment and native JSON functions offer automating invoice processing, revenue recognition and accounts payable while keeping payroll and vendor data air‑gapped.  Companies like WaveFlow use Gemma 4 to perform OCR on invoices, match them with local purchase orders and automate accounts payable entirely on local hardware.
Amazon Holds Mandatory Meeting After Vibe-Code Triggered Major Outages
Amazon Holds Mandatory Meeting After Vibe-Code Triggered Major Outages
The email from Dave Treadwell, Senior VP of ecommerce services, told employees: "Folks, as you likely know, the availability of the site and related infrastructure has not been good recently." A 13-hour AWS outage in December 2025 happened because the Kiro AI coding tool was allowed to decide that the best course of action was to "delete and recreate the environment." Multiple Amazon employees confirmed to reporters that engineers had let AI agents resolve issues without intervention. Following the December 2025 outages, Amazon implemented safeguards such as mandatory peer review for production access and staff training. As we can see, it had little effect. Last week in early March, both Amazon's website and shopping app went down. For six hours, customers could neither check out and complete transactions, access account information, nor view product prices. Before that, there was a severe 15-hour AWS outage in October 2025 that forced multiple customers' apps and websites offline, including OpenAI's ChatGPT. The Lack of Guardrails On March 2, customers across Amazon marketplaces saw incorrect delivery times when they added items to their carts. It led to nearly 120,000 lost orders, according to Business Insider. Amazon's AI tool Q was one of the primary contributors that triggered the event. An internal document warned that because GenAI generates code so quickly, it is accidentally exposing vulnerabilities and proving that the company's current safety guardrails are completely inadequate. This lack of guardrails was evident again on March 5. Another outage caused a 99% drop in orders across Amazon's North American marketplaces, resulting in 6.3 million lost orders. One key factor was a production change that was deployed without using a formal documentation and approval process called Modeled Change Management. There was no automated pre-deployment validation, so a single authorized operator could execute a high-blast-radius config change. Now, Amazon is rolling out a 90-day, temporary safety guideline on top of their existing policies. The new policy targets approximately 335 "Tier-1" (money-making) systems or services that impact consumers. Amazon engineers must get two people to review their work before making any coding changes. Tier-1 system owners, as well as Director- and VP-level leaders, must audit all production code change activities. "We will invest in more durable solutions including both deterministic [rules-based programming] and agentic [using AI to review the code] safeguards". Dave Treadwell Amazon Blames Human Error & Coincidence Executives are mandating the use of AI tools to write code (setting targets for 80 percent usage) to increase speed and cut costs. The AI tools are known to sometimes make catastrophic errors, such as deleting the environment. When the AI makes a mistake, executives (such as Amazon) officially blame "human error" or "misconfigured access controls" because the engineer was supposed to perfectly oversee, use a second person's approval before making changes and catch the AI's mistakes. "This brief event was the result of user (AWS employee) error, specifically misconfigured access controls, not AI". An Amazon spokesperson writes in a statement sent to The Register "It was a coincidence that AI tools were involved, and the same issue could occur with any developer tool or manual action. In both instances, this was user error, not AI error". Amazon writes in a statement to the Financial Times. An Amazon spokesperson told Business Insider that only 1 incident reviewed on Tuesday was AI-related, and none of them involved AI-written code. Internet users joke: Companies want all the productivity benefits of autonomous AI without taking any of the responsibility when that autonomy causes a disaster. Instead, they blame the human employee whom they forced to use the AI. Amazon is spending $200 billion on data centers, cloud infrastructure, and AI development. To afford this, Amazon is laying off tens of thousands of workers, including 16,000 in January 2026 alone. Because there are fewer engineers left to do the same amount of work, Amazon's leadership is forcing the remaining employees to use AI coding tools to speed up their output. The remaining engineers are pushed to code faster using AI (vibe-coding). "An I-shaped specialist, someone with knowledge in only one area, is becoming outdated. To solve hard problems, developers must look past their main skill". Dr. Werner Vogels, CTO of Amazon But AI code constantly requires thorough human review. Because Amazon fired so many people, there are not enough engineers with the time or capacity to double-check the AI's work. As the Financial Times reported, Amazon engineers complained that their teams had to deal with a higher number of "Sev2s" (major incidents requiring rapid response) specifically because of these recent job cuts. Amazon tried to replace human engineers with AI to save money, but the AI is not good enough to work unsupervised. Amazon has disputed the claim that headcount cuts were responsible for an increase in recent outages, according to the Financial Times. The Danger of Vibe-Coding Vibe-coding, in which you tell AI what you need and sit back, is on the rise. Anthropic released Claude Code in February 2025 and passed $1 billion in annualized recurring revenue by November. They also released Claude Cowork, a version of Claude Code built for everyday knowledge work instead of just programming.  Both Microsoft and Google state that over a quarter of their code is now written with AI. Engineers at Anthropic and OpenAI say that nearly 100% of their code is AI-written. The Amazon incident has opened up a conversation about whether vibe coding could lead to badly designed software. Third-party code reviewing software platforms report that, out of hundreds of pull requests (engineers speak for bug fixes or changes in code), AI code had 1.7 times more issues than human code. "We can't just pull a lever on your IDE and hope that something good comes out. That's not software engineering but gambling. Remember, the work is yours, not the tool's. AI can generate code faster than you can understand it. That gap allows software to move toward production before anyone has truly validated what it actually does". Dr. Werner Vogels (CTO of Amazon) at AWS re:Invent 2025 "LLMs sometimes make assumptions you do not realize they are making. If you do not tell it explicitly that something needs to work for multi-threading, for example, it may produce the minimum version that works, but when it is scaled or put into production, it could crash.It is very hard to resist vibe coding nowadays. When your peers are using it and coding faster, it is hard to resist. If you cannot keep up with the speed, it becomes difficult to collaborate". Anni Chen (Amazon tech lead) "There is a capability reliability gap in AI-assisted coding. Systems can look impressive at the moment, but reliability only shows up over time, after varied real-world use". Lilly Ryan (cybersecurity consultant and software historian) There is a lot of software that we can automate, and that does not matter so much, and we do not need the best quality assurance for this. Then there is software where we want to be careful, and we want to keep the human in the loop." Christian Kästner (associate professor of software engineering at Carnegie Mellon University) AI Code Cleanup Company Belitsoft offers a solution to the vibe-coding risks (lack of human oversight, security flaws, and scalability limits): agentic AI software development with senior engineer supervision. Our Senior, Staff/Lead, and Principal Engineers, not AI, take full responsibility. Bringing AI coding tools into professional software development means that every AI-generated line still goes through human engineer review, automated tests, and security scans. Our senior engineers determine exactly how the code should look and behave, and check whether any AI suggestions comply with those standards. After the AI adds or modifies code, our team runs tests and reviews to catch any new bugs or unexpected side effects immediately. Our most experienced engineers review every piece of AI-generated code, look for hidden mistakes, and adjust the output so it integrates seamlessly with your existing system.
How Exactly Professional Software Developers Use AI Coding Agents
How Exactly Professional Software Developers Use AI Coding Agents
They Control Architectural Decisions and Code Changes All professional developers working with AI agents keep control of the process - period. Nobody just lets the agent run wild. That said, the tasks they give agents vary widely: building new features (which requires planning design and architecture) versus fixing bugs (where the design already exists - you just find what broke and patch it). How developers work with agents when building a new feature Most figure out the design plan themselves first, then hand that plan off to the agent. This is especially true when: You're working for a client with specific requirements The project has proprietary info you can't fully share with the agent It's just faster to do it yourself than explain everything and then fix what the agent screws up Some developers take a different approach. They ask the agent to draft a plan first, then revise it themselves. This makes sense when you're not super familiar with the domain you're working in and want the agent's ideas as a jumping-off point. When developers aren't familiar with the domain, they may ask the agent to sketch out a plan for building the feature. Then they vet it using their general engineering know-how. What are they checking for? The plan needs to break down the coding work into small, sequential steps. So they can test integration after each step to make sure the new code plays nice with the existing codebase, and, if something breaks, they know exactly where to look. Professional developers read AI code carefully, even when the amount of code is large. They also watch what else the agent tries to do. For example, they may reject unnecessary dependencies the agent wants to install. And if something breaks, many developers debug and dig through the code manually to figure it out themselves instead of asking the agent to fix it. Sometimes it's faster than re-explaining the issue to the agent. By the way, if a developer reviews the code and makes changes, they need to tell the agent what they changed so it doesn't lose context. Otherwise the agent won't account for those changes down the line. Some developers, by the way, use the agent not for writing code, but only for explaining unfamiliar architecture in existing applications and for creating diagrams to visualize the structure. This means that if a developer is handed an application for updates that was previously developed by other engineers and needs to quickly get up to speed on how it is built, this is an optimal use case. They use Effective Prompting Strategies to Control Coding Agents The more detail you put into a prompt, the more control you keep and the less cleanup you need later. Professional developers always keep the prompt focused on one thing: a small, specific modification.  They use prompts with maximum information, including file, function, and variable names, as well as full texts of error messages.  When they modify existing code, they constantly try to remove ambiguity.  For example, they may mention what data types they expect to see, what specific libraries they want to use, what domain objects they expect to alter (app-specific entities). They also describe what the UI should do when someone takes an action, such as clicking the Submit button.  Their prompts clearly state what the LLM should look at through file references, what they want the agent to do, and how the output should look. They can toss in screenshots or code examples to show what they want.  After mentioning all these details in the prompt, they may ask the agent to "do just step 1 now from TASKS.md" at the end. That stops the agent from racing ahead.  Modern LLM models behind coding agents can switch to extended thinking mode. However, developers may still additionally ask for step-by-step thinking in their prompts to make the agent reason out loud, rather than work in fast mode. This lets engineers control the reasoning process. They can see the agent’s thought process before any code gets written. Coding agents work well with knowledge bases, both internal and external, that are accessible through MCP servers. For example, Context7 MCP Server pulls up to date, version specific documentation about the libraries you use and code examples straight from the source and places them directly into your prompt, so you do not have to search for and copy-paste docs yourself. Professional developers don't limit themselves to just the coding agent. They open, for example, ChatGPT separately first to brainstorm, get explanations, and refine their prompt. Only after that do they go to the coding agent and drop in the polished prompt. Professional developers use a coding agent configuration file to avoid repeating the same instructions in every coding session, and for new projects. This file contains rules the agent must consistently follow.  These aren't rules you write once and forget - the file needs to be updated periodically.  Most often this custom settings file is refined to remove ambiguous interpretations for the agent and correct the agent's behavior based on past mistakes caused by its default system prompt.  It may include:  Project requirements (for example, "always use TypeScript", "use only this library and don't use that one")  Coding rules ("always write clear variable names", "always add comments", "make code readable", "write tests for every function") Is there one ready-made prompt that professional developers can share with each other or with non-professional coders so they can use it? No, because prompting is an individual thing.  What matters is understanding the prompting strategy, not copying someone's prompts.  Through self-teaching, trial and error, and feedback, each developer individually breathes life into this prompting strategy with specific content adapted to their own needs.  Those who experiment with agents more often and more consistently see higher effectiveness in their AI-assisted coding work. They become more productive than those who don't actively work with coding agents, even though they are becoming the new normal. One question remains: should you work in one long chat, continuing the same conversation (since that's supposed to make it easier for the agent to hold context with all the details),  or open new windows for each task?  Long chats make it convenient to work interactively, but tasks may drag on longer since the agent has more load to handle. Plus it gets more expensive - every request processes the entire long context, burning through API tokens faster.  With new windows, the problem is you lose the conversation history for the task.  How to deal with this in each specific case - each engineer decides individually.
Agentic AI Coding: What Still Remains Expensive Amid a 90% Drop in Costs
Agentic AI Coding: What Still Remains Expensive Amid a 90% Drop in Costs
Benefits of Agentic Coding Engineering Cost Reduction Agentic coding has changed the software development market by cutting the labor cost of implementation for simple and internal tools. The cost of writing has dropped by up to 90% compared with similar work a decade ago.  Agentic coding excels at CRUD applications, simple web forms, standard workflows, small internal tools, simple test suites, and basic API glue code. For these types of projects, development costs have dropped approximately 90%. AI tools let companies delay hiring managers and larger engineering teams, because a small senior team can do more. Tools like Cursor plus Claude allow a single experienced engineer to generate output that used to require a small team. With these tools plus smaller teams, a handful of people can now achieve roughly an order of magnitude more than before. Engineering Time Savings For a typical internal tool where data modeling is already complete, work that previously required a small team can now be finished in a few hours with an agentic coding command line interface. AI coding agents like Claude Code can generate a full unit and integration test suite for a fairly complex internal tool in a few hours. The AI-generated test suite, which contained more than 300 tests, would have taken several software engineers several days to write by hand. A project that previously took roughly a month from start to release can now be completed within about a week when using agentic coding tools. New Market Opportunities For niche platforms, AI makes it economically viable to build a product where the total market size is no more than 10 million USD  in annual revenue and hiring a full team would not have been worthwhile. Faster Product Idea Exploration Agentic coding tools are extremely good at turning business logic specifications into well-written application programming interfaces and services. AI agents allow faster exploration of product ideas, which shortens the loop between product and engineering.  Pairing a business domain expert with a motivated software engineer and these tools produces an extremely powerful combination. Instead of a larger squad that pairs a business specialist with a group of software engineers, we will see much tighter two-person pairings. Such pairings allow extremely rapid iteration on software products. If the chosen direction is poor, the team can discard the current software and quickly start again, using what they have learned. In this new mode, the hard work is the conceptual thinking rather than the typing. Faster B2B SaaS Customization There is a lot of customization per client in B2B SaaS, so the fast conversion of unclear requirements into working prototypes that reveal misunderstandings is the biggest gain.  AI agents help most when software requirements are fuzzy, polish and long-term support are less critical right now, and you only need to iterate quickly by creating simple prototypes. Excel Spreadsheet to Web App Conversion Every organization has hundreds, and possibly thousands, of Excel sheets that track important business processes. Those Excel-based processes would be much better expressed as applications. In some cases, a professional development agency can turn these spreadsheets into an application for around 5000 dollars by combining a competent software engineer with AI tools. Cutting Recurring SaaS Costs with Self-Hosted Internal Solutions, Built Cost-Effectively with AI Agents As AI lowers the cost of custom development, SaaS tools that mostly wrap simple workflows are no longer viable as monthly subscription products. High SaaS subscription prices make it easier for companies to justify replacing them with AI-coded internal solutions. Some multi-billion dollar corporations are already replacing SaaS tools with custom internal solutions built with AI assistance. They:  replicate Salesforce-like features and embed them directly into internal systems to reduce costs. replace tools like Fivetran with internal ETL solutions based on open-source platforms and custom code, saving 40,000 dollars per month, reducing maintenance costs, and making customization inexpensive. rebuild key features of expensive back office SaaS in several weeks. For many internal workloads or custom mobile apps, it now makes sense to build rather than buy. Low-code platforms combined with AI agents enable companies to build business applications quickly, replacing subscription-based alternatives. Optimal Use Cases for Agentic Coding AI is especially powerful in small companies or teams that already have an engineering culture and testing practices.  Production of Small Applications Many developers now produce far more small internal or personal applications, even if those applications never become public products. Even if AI may produce boring, ugly code, it is still good enough for personal tools such as IDE plugins that saves developer time. Component Development Large language models are very good at writing small components from the bottom up and stitching them together.  A software engineer can feed a REST API specification to an AI coding tool and receive a module that largely works. They can also write documentation and explanations for protocols or complex code paths. Composing Small Parts With guidance, AI is very good at composing small parts, such as several API calls plus error processing, into a coherent routine.  Senior developers are comfortable with letting AI generate entire small components such as simple dialogs or small modules. Predictable Tasks, Known Patterns and Libraries AI tools work best when they can compose known patterns and libraries rather than invent new designs.  AI coding tools work excellent when the underlying task is predictable, such as generating wrappers or predictable user interface patterns. They are strong at identifying libraries that solve a problem when given freedom to choose the approach.  The Main Use Case: Understanding Legacy Code The main value of AI agents is not code volume, but having a second brain that thinks faster than a human developer. Senior developers use AI agents to understand large legacy codebases, not necessarily to write big changes autonomously.  Legacy projects are dangerous for agentic coding, because AI agents may generate large diffs that are hard to review, and lack of tests makes correctness very hard to assert. However, even if they are not good at generating new code in that environment, AI tools are excellent at parsing existing legacy code and using it to explore scenarios and hypotheticals.  AI can extract complex business logic even from obscure implementations such as templates and plugins. AI is also good at explaining low-level code, including assembly for retro platforms. What Makes Code Legacy When models are fed well-structured code even from legacy systems, they can help deliver changes faster without a large team. AI agents can easily read a specific function, understand what it does, and propose changes with high accuracy because there are boundaries in the well-structured code. However, most legacy projects are those that are not maintained and have little or no test coverage, and where engineers fear changing anything. Legacy is a business decision: a system becomes legacy when the business declares it obsolete and stops investing in it.  Poor engineering and mismanagement can create legacy code even on a brand new project, so age is not the key factor.  Most vibe-coded apps become legacy almost immediately, because no one wants to invest in cleaning them up. 10x Productivity Gains A 10x personal productivity increase may occur when working on a large legacy codebase if your code agent can: scan and understand big old codebases, answer questions about them, propose targeted changes, and assist with testing and debugging. AI is excellent at understanding existing code, summarising it, and answering questions, and this is the main productivity gain for work on legacy systems. AI is a crew of excavators compared to a single shovel when exploring large garbage heap codebases. Developers have spent a lot of time trying to understand codebases that are several years old. Agents make understanding these older codebases easier: explain what the code is doing, and locate bugs in that code.  New Automation Opportunities Many use cases senior developers previously would not have bothered to script or automate are now easy, and they have cranked out small scripts and small web services in several hours using AI. AI-Assisted Code vs. Contractor Code Developers would rather inherit a repository written with the help of an agent and a good engineer in the loop than one written by a cheap contractor of questionable quality from India who left several years earlier. The kind of repository left by such a questionable contractor typically has no tests and code is often a mess of classes and methods. What Remains Expensive in Custom Software Development Even with AI Agent Coding AI hype around code is comparable to the hype around self-driving cars: solvable in theory, but much harder than many assumed. In fact, coding time is often only a small fraction of the total time spent on a complex enterprise project. Hidden Costs The main costs are not in the initial building but in future maintenance, feature additions, operations, and organizational coordination, which AI reduces far less. Debugging and supporting software in production is still difficult and has not been automated by AI. Production software also has many hidden costs that include: security, upgrades and patches, hosting and uptime at scale, customer interactions, regulatory and compliance aspects, product management and design, and data migration and integration. The cost of having software today also includes the cost of dealing with cloud platform complexity, such as Kubernetes, distributed databases, queues, and multiple user interfaces. Distribution Still Costs More Than Building  AI agents can reduce building cost, but large companies still have advantages in brand, distribution, and customer trust.  Marketplaces and discovery are controlled by algorithms that favour big players and established brands. Many excellent small products will remain invisible until their features are copied by large companies.  You May Still Require a Team Decision makers in larger organisations are unlikely to trust a one-person shop for core systems, regardless of how cheaply that person can code. Coding time is often only a small fraction of the total time spent on a complex enterprise project where you may still require a team of human engineers. Yes, smaller than even a year ago, but still a team. Before building the app from the ground up, a team would set up continuous integration and continuous delivery, define and implement data access patterns and the core services. After that, the team would usually build a backend, dashboards and graphs for users. Near the end, the team would ideally add automated unit tests, automated integration tests and automated end to end tests to make the product fairly solid. The release of such a product, depending on the complexity, may happen even about a month after the work started. This description above only covers direct labour. Every additional person on the project adds coordination overhead that includes daily or regular standups, ticket management, code reviews, handoffs between frontend and backend contributors and waiting on other team members to unblock your work. Senior Engineering Effort is Still Required to Solve Complex Production Issues There is currently enormous value in having a human supervise the agent and check its work. AI makes it very easy to create huge volumes of code, but this can be dangerous because code for critical systems is considered a liability, and less code is usually better. When AI writes code, it is tempting to accept it quickly, but this can damage long-term quality and maintainability. With a senior engineer in the loop, AI agents can create very high-quality software very quickly. AI is best used as a partner, not as an autonomous agent. Senior engineers still need to design, review, and direct the work. Using AI for code generation requires the same effort in design, coding, and review, except the code under review is not their own. Many engineers use AI primarily for exploring codebases and libraries, generating first drafts of code or tests, refactoring proposals, explaining errors, and drafting documentation. They may ask AI to implement something and use the AI output only as motivation. Experienced software engineers never just copy AI-generated code as is, and always review and adjust it. They may ask the model to write some code, then ask it to list the top ten problems, and then ask it to fix the most important ones. AI agents are very good at checking code and then critiquing or fixing it, so engineers actively use this workflow. To get good results from AI, you need to learn how to ask good prompts, plan the work, and supervise what the model does. Experienced software engineers often start with a planning step before any code is written. They ask the agent to propose a high level plan so that the person and the model are aligned. A simple CLAUDE.md or instruction file can teach Claude Code how a specific project works and help it stop repeating the same mistakes over time.  Agents are claimed to be strong at writing large volumes of unit or integration tests quickly. However, there may be challenges with the quality of these tests. They can create a false sense of security. While a human writes a test based on requirements, the AI may write a test based only on the code it sees. If the original code is wrong, the test will also use the wrong logic to verify it - the test passes, but the bug remains. That's why AI agents work best when you already have good automated tests, because those tests keep the model in check and make its output more trustworthy. AI can replicate the behavior of people who put together StackOverflow snippets without fully understanding them. With AI, average software engineers lose the educational value of spending hours reading documentation.   The educational loss is a reason why AI is more useful for senior software engineers than for junior engineers.  Will AI Replace Software Engineers? Current models may be pretty bad at programming anything non-trivial and  "fix" issues by removing functionality. AI coding assistants may hallucinate functions or APIs that do not exist, use deprecated interfaces, reintroduce bugs during refactors, and remove tests silently. They may "fix" failing tests by changing the test instead of the code. However, many human programmers also do not manage complexity well, and for senior engineers there is no fundamental difference between improving large language models and training junior developers. Moreover, AI agents and models are still improving at a rapid pace. Existing benchmarks do not really capture how fast these agents and models are improving. Newer models will soon make the current ones look completely obsolete. Model providers are now actively filtering code training data for quality, so the new generation will use higher quality code than older models.  Even without AI, developers were always at risk of field disruption from new technologies. There will still be strong demand for engineers who can supervise AI, manage complexity, and align software systems with business goals. Knowing the business and industry specifics gives senior programmers an advantage over others in the era of AI-assisted coding. When you add business domain understanding on top of technical and agent skills (which architectural decisions fit a project, which framework to use, and which libraries perform best), it feels as if the 10X engineer has arrived. Such engineers move toward full stack and product engineering or roles with more business responsibility, propose solutions rather than just implement specifications, and engage with customers, sales, and marketing. Modern developers use AI to learn faster about business processes, regulations, and industry history (verifying information). AI is a partner that amplifies us. We plus AI are much more valuable than we or AI alone.
Belitsoft Reports Rise in Vibe Coding Cleanup Requests
Belitsoft Reports Rise in Vibe Coding Cleanup Requests
Benefits of Vibe Coding For example, engineers can build a production-ready library in several days using an AI assistant, a task estimated to have taken weeks or months otherwise. This is a 2–5× speedup in development time. CEOs report that using AI coding tools save them the equivalent of  thousands of developer hours of effort. Even Google’s CEO confirms that over 30% of new code at Google is now AI-generated. This leads to lower development costs. Industry studies found that companies integrating AI into their software process achieved about 30% savings on software production costs on average. With senior engineers supervising the workflow, the productivity gains do not compromise code quality or security. Experienced developers can use AI to handle rote coding tasks while ensuring the output meets high standards. This means far fewer billable hours are needed to deliver a given scope of work, so the total cost of ownership for clients plummets even as quality is maintained (and often improved).  Enterprise surveys show rising client satisfaction as projects are delivered faster and with solid reliability.  Rather than replacing senior developers, AI amplifies their output: a skilled engineer working with LLM pair programmers can produce much more at the same time.  One FAANG engineer noted that about 50% of his daily code is now AI-generated, freeing him to provide the broader brush strokes and review the code, and allowing him to resolve certain issues 10× faster than before.  By offloading tedious boilerplate (like unit tests and data-handling functions) to AI, developers focus on higher-level design and bug prevention.  The result for clients is more value for less money – projects that have required 1000+ developer-hours in the past can be delivered with only a few hundred hours of human work, thanks to AI assistance.  As a consequence, some tech giants have even begun reducing total engineer headcount or reassigning junior roles, given that many repetitive coding tasks have been automated. (Notably, new hires with less than 1 year experience fell, as entry-level work is increasingly handled by AI.)  Nonetheless, companies that empower their senior developers with these AI tools are seeing enthusiastic teams delivering more value faster.  When experienced engineers remain at the helm, they can retain full accountability for the end product – ensuring the software is high-quality and secure – while letting the AI handle the grunt work.  This senior-driven approach has led to visibly happier developers and satisfied clients, as projects finish in half to a third of the time and within a fraction of traditional budgets, all with robust results. Methodology & Internal Process for the Right Vibe Coding Realizing the above benefits requires more than just throwing an AI at some code.  Successful vibe coding has a secret sauce: a methodology that front-loads the project with solid engineering practices before any AI writes code.  The team invests extra effort in a solid technical specification and architecture design up front, which then makes the downstream AI prompts extremely effective.  Coding without solid planning and engineering practices can be a real vibe-killer – if you rely on an LLM without a clear design, the results can be chaotic.  Architecture & Requirements First Senior engineers and business analysts collaboratively produce a detailed technical spec, clear requirements, and an architectural blueprint for the system. This blueprint is often explained in plain language (for stakeholder buy-in) and covers everything from data models to how the app will be deployed in different environments, as well as how third-party APIs will be safely integrated.  By having this blueprint, the team ensures the AI works toward a cohesive vision rather than ad-hoc code. Some AI-assisted development tools enforce this separation of phases: they have a "Plan Mode" for discussing architecture and design with the AI, and only then an "Act Mode" to generate code once a plan is approved. This human-in-the-loop planning prevents the AI from coding hallucination. Modular, Iterative Prompting Instead of one gigantic prompt asking the LLM to build an entire application (which often fails due to context limits and complexity), the work is broken into modules or features.  For each component, developers provide specific prompts (backed by the spec) describing the one module’s functionality in detail. The LLM then generates that code.  This iterative approach – treating the LLM like a programmer who implements one task at a time – yields far better results than a single "mega-prompt".  It also allows continuous refinement: the developer can test each AI-produced module, catch errors, and adjust prompts for the next module accordingly. AI Code Generation & Senior Review Once the prompt is given, the LLM writes the code. Every single line of AI-written code is then inspected, tested, and corrected by a senior engineer before it gets merged.  This review step is critical: the AI can produce working code quickly, but only a seasoned human can verify nuances, ensure the code fits the overall design, and enforce standards.  Seniors often catch subtle issues or suboptimal approaches that the LLM, lacking true understanding, might miss. LLMs can introduce new kinds of bugs – code that looks polished but fails in edge cases – which an experienced reviewer needs to sniff out. By having seniors in the loop to debug and polish, the final codebase remains clean and maintainable. Even a routine feature like a user login, which might have taken a developer 16–40 hours traditionally, can be specced out and generated by the AI in minutes – but it’s the senior engineer’s careful validation and tweaks that guarantee it meets all security and quality requirements before a Git push. Continuous Testing and Integration The workflow integrates testing at each step.  Test cases (which can themselves be drafted by AI) are run on AI-generated code to ensure it meets the spec. Any failing tests or runtime errors are fed back to the LLM in a prompt (much like an error message to a dev) so it can suggest a fix.  This loop repeats until the module passes all tests. Modern AI coding tools support such cycles.  This approach results in code that is well-documented and aligned with requirements, with the AI effectively doing a form of test-driven development under human guidance. This methodology – design first, then small prompt cycles, with constant human oversight – make the coding phase up to 10× faster than normal in the experience of some teams. By spending more time in design and prompt preparation, the actual coding becomes almost automatic.  Senior developers experimenting with these techniques accomplish in 4 days what would normally take two weeks, by letting AI generate code and only later stepping in to assist with tricky bugs and integration. Multiple AI agents in parallel (several AI instances working on different feature branches, with one coordinating merges) can pump out an astonishing 10,000 lines of code per day across projects. Careful planning (writing thorough specs, tests, and even style guidelines for the AI to follow) is a key to keeping that output high-quality – recreating an architect’s oversight in an automated loop. Security and architecture are never left to the AI by itself Senior engineers incorporate dedicated security checks and wrappers around things like third-party API calls, rather than assuming an AI will do so by default.  Naive use of LLMs (just asking for a feature implementation without mentioning security) often yields code that misses common security best practices.  In one evaluation, all popular LLMs tested produced code with serious vulnerabilities (like mishandling input or hardcoding secrets) when given an unspecified prompt. Only when the prompts included explicit security requirements or when additional rule-based guardrails were added did the AI outputs become secure.  The human team must bake in security and sound architecture from the start. An experienced architect mandates an extra validation layer around an external API integration – even if the AI didn’t spontaneously suggest one – to protect the overall system.  When companies like Belitsoft audit AI-generated code from external projects, they often find that a lack of upfront architecture/design review leads to major gaps that require costly rework. Outsourced devs did not spend one second beyond the spec sheet – no extra thinking about edge cases or "common sense" improvements – resulting in a product that technically met requirements but wasn’t a cohesive, maintainable system. That entire codebase had to be partially rewritten and fortified after the fact.  By contrast, a well-run vibe coding process avoids these pitfalls by designing in quality and security from the beginning (through explicit prompts, policies, and senior reviews).  Market Demand for Vibe Coding The rise of vibe coding reflects a broader surge in demand for AI-assisted development.  AI-powered code generation has become one of the hottest areas for investment and innovation in tech. Venture funding and valuations for startups in this space have skyrocketed.  Reuters reports that code-gen startups are commanding sky-high valuations as companies race to adopt AI in software development. These tools allow users to translate plain English commands into code, sometimes called vibe coding in the press. Such tools promise that even non-programmers can create working software by simply describing what they need, while experienced developers can dramatically accelerate routine work. On the demand side, companies of all sizes are experimenting with LLM-driven development. Many companies had at least begun adopting generative AI technology in their business, and software development is a prime use case.  Many startups have fully embraced vibe coding – 25% of startups may have 95% of their code generated by LLMs. These young companies lean heavily on AI to crank out an MVP quickly.  However, this rush often leads to technical debt: observers note that some founders using AI produce low-quality code, as cheap and dirty as they can, with no long-term planning. As a result, there’s a growing niche for firms with senior AI expertise to step in and "rescue" half-finished AI-coded projects.  Belitsoft and others report being approached by teams that attempted vibe coding internally but ended up with shaky systems – missing robust architecture or security safeguards – and now need seasoned engineers to audit, refactor, and productionize the work.  This scenario is becoming common as the hype meets reality: companies realize that skipping the architecture phase or lacking seasoned oversight can lead to fragile software that doesn’t scale or comply with compliance needs. In terms of broader market trends, LLM code quality has been steadily improving, which further fuels adoption. Each new model brings better understanding of coding contexts and fewer errors. Upgrading from an older AI model may double coding speed-up (from a 1.5× boost to well over 2×) because the newer model could handle prompts more accurately. Some LLMs are top performers in generating secure code when given proper guidance.  Belitsoft continuously evaluates these models and adopts the best-performing ones for each task – whether it’s using code-specific models for certain languages or switching to a larger context model for handling big codebases. The effect is a virtuous cycle: as the tools get better, more organizations are willing to pilot them on real projects, which in turn drives more innovation and investment in the space. The enterprise sector, however, has been slower to fully embrace vibe coding compared to startups.  Large enterprises often have legacy codebases, strict compliance requirements, and established development processes – all of which can act as "crutches" slowing down AI adoption.  There is also a talent gap: many corporate developers and managers are not yet adept at crafting high-quality prompts or integrating AI agents into their workflows. Prompt engineering and AI oversight are becoming new skills that enterprises must cultivate.  That said, even conservative organizations have started dipping their toes into AI-generated code, particularly for new, self-contained modules or for modernizing legacy systems.  A notable example is Morgan Stanley, which built an internal tool to help rewrite its old COBOL code – effectively using an LLM to interpret and regenerate decades-old code faster than a human could. The result showed promise, confirming that LLMs can accelerate even traditionally slow enterprise development tasks like legacy refactoring. Similarly, Microsoft has deeply integrated AI into its dev pipeline (reporting 20–30% of new code being AI-generated) and even flattened parts of its workforce in response, indicating they expect existing teams to deliver more with AI assistance. Observers predict that in the near future, even large enterprises will routinely let vibe coding handle greenfield projects or new components, while human experts focus on integration and high-level design.  This is already hinted at by internal developers: one FAANG engineer noted that while AI isn’t yet good at higher-level design choices or bigger picture stuff, it excels at pumping out well-encapsulated functions and boilerplate, so day-to-day software engineering is going to look very different once adoption becomes mainstream.  We’re seeing the beginning of this shift. Industry surveys of CIOs show a sharp increase in budget for AI developer tools and training in 2025, and early enterprise pilots are expanding. Still, full enterprise uptake will likely be gradual – many organizations are proceeding cautiously, running AI coding in sandbox environments or on non-critical projects until issues like data privacy, regulatory compliance, and staff training are addressed.  Risk Management with Vibe Coding LLMs are powerful tools but can be useless – or even dangerous – in unskilled hands. Effective vibe coding is very much a senior-level discipline.  It requires an experienced engineer to keep full responsibility for the software, guide the model thoughtfully, catch AI errors, and enforce coding standards. Without that human expertise, an AI can churn out code that is syntactically correct but architecturally unsound or riddled with subtle bugs.  As an analogy, think of an LLM as a highly efficient junior developer: it can produce a lot of code quickly, but it has zero real understanding or accountability.  The lead engineer treats a large language model as it would a junior developer. The engineer gives concise instructions and runs every draft through review. The model delivers scaffolding in minutes, so the engineer’s own development time drops. The less experienced developers take a different approach. They paste the model’s suggestions straight into the codebase and move on. They do not pause to consider architecture or security trade-offs. From a distance, their productivity looks impressive — one day of work now produces as much code as a full week had before. An LLM can write convincing code that is still wrong, and developers without enough experience often miss the difference. When the lead engineer opens their pull requests, the engineer sees defects which take time to explain. Output volume has increased, but so has the lead engineer’s review load. Progress now depends on the engineer’s ability to detect and explain subtle problems the LLM has introduced. Security is another area where experience is critical.  LLMs do not inherently understand secure coding practices - they’ll often omit important steps (like input validation, authentication checks, or proper error handling) unless explicitly told.  A junior might not even realize those omissions. Researchers found that naive AI prompts (asking for a feature without security detail) caused every tested LLM to produce code vulnerable to multiple common weaknesses. This means if an unskilled developer just says "Build me a login form" and copies the AI’s output, they might deploy code that is susceptible to SQL injection or other attacks.  A senior engineer, on the other hand, will either prompt the AI with specific security requirements or manually add the necessary checks around the AI’s code. They understand the gotchas and ensure nothing critical is overlooked. Many senior-led AI projects incorporate a manual review for security: in high-risk areas (payments, authentication, third-party APIs), the code might even be hand-written or heavily refactored by the senior to guarantee safety, rather than relying on the AI’s first draft. The contrast in outcomes has led to a saying in these circles: LLM coding isn’t bad – bad developers using LLMs are. In other words, the rumor that vibe coding = garbage code arises mainly from cases where organizations let loose AI tools without proper training or oversight.  The real issue is insufficient expertise guiding the AI, not the AI itself. When steered by a skilled hand, vibe coding can produce clean, robust code, but in unskilled hands, it can amplify poor practices (mass-producing flawed code at an overwhelming pace).  As one early adopter put it after using multiple AI agents on a complex project: this tool would absolutely ruin a codebase if you weren’t a very experienced dev and tech lead. Without a solid grasp of software architecture and best practices, a developer could quickly inject chaos by trusting the AI too much. Another commenter predicted we’ll be swimming in an ocean of bad software written by inexperienced devs leaning on AI, while good experienced devs will be able to make better software with the same tools.  This underscores the point: human role differentiation is key. Juniors must still learn the fundamentals and should use AI carefully (to learn or speed up small tasks, but not design entire systems). Seniors, meanwhile, take on more of a governance and orchestration role – they treat the AI like a helpful junior engineer who needs supervision. They remain accountable for the final product, guiding the AI with high-quality prompts (encoding their expertise into the instructions) and rigorously reviewing output. With this division, the LLM becomes a force multiplier for the senior developer, not a replacement for them. In terms of risk management, forward-looking teams are establishing policies to keep AI coding in check. This includes code review protocols (any AI-generated code must be tagged and gets an extra manual review), security scanning of AI contributions, and rules for what types of tasks are appropriate for AI.  Some companies integrate tools that automatically inspect AI-written code for known vulnerability patterns.  The consensus is that LLMs should be used with trust, but verify. They can draft 90% of a solution, but a human must verify that last 10% (and often that final polish is critical, as an uncaught AI mistake could be catastrophic).  When managed properly, LLMs are an incredibly potent aid, when mismanaged, they can accelerate the creation of bugs or security holes. Thus, effective vibe coding teams invest in training developers on how to use AI responsibly, pair newcomers with seniors as mentors, and maintain a culture where using an AI doesn’t mean skipping diligence. The engineer – not the AI – remains the ultimate owner of the code quality. Outcomes of Vibe Coding Despite the challenges, the on-the-ground outcomes of senior-driven vibe coding have been largely positive – even exciting – for many developers.  Those who have incorporated AI into their workflow report significant productivity boosts on the tedious parts of coding, and a better overall developer experience. Quantitatively, the reported gains vary, but they are often substantial.  Overall productivity improvements of 20–50% are common once developers get used to AI assistance. In specific scenarios (particularly repetitive, boilerplate-heavy tasks), the speed-up can be much more dramatic – on the order of 5× to 10× faster. One engineer noted that writing unit tests or parsing routines, which might have taken him half a day, became trivial with AI: things that would have taken me 10× time otherwise were solved quickly by the model. Another developer found that using the latest LLMs with an optimized workflow doubled his output (a solid 2× boost), and he occasionally saw even higher throughput on easy, well-represented tasks where the AI excelled.  Beyond the numbers, the sentiment among many developers using vibe coding is enthusiastic. They often describe the experience as transformative or liberating. Tedious boilerplate work feels like less of a burden, allowing them to focus on creative and complex aspects of software.  As one Reddit user put it, it really removes a lot of drudgery – tasks like slogging through unit tests or boilerplate code are no longer where developers derive their value. Instead, they can spend more time on architecture, refining requirements, or tackling tricky problems, with the AI handling the rote stuff.  Developers have called these AI coding tools pretty cool and express excitement about having them in their toolbox.  The initial fear some had (of AI replacing programmers entirely) is giving way to a more nuanced view: augmentation rather than replacement. Many now see AI assistance as a must-have tool. "I’m excited about AI as a great tool in our toolbox," one senior engineer wrote, adding that he’s tired of doom-and-gloom scenarios and instead sees concrete advantages. Another developer commented that these tools "help me get ideas out of my head and into something practical very quickly, as long as you can filter out some of the nonsense it returns". The AI might not be perfect, but it kickstarts progress rapidly, and with a bit of human steering, it leads to faster results. When vibe coding is done under proper conditions (solid specs, senior review, etc.), the resulting code quality has proven to be excellent. There is growing evidence that AI-generated code, when guided well, can be as good as or even better than hand-written code for many use cases. For example, the AI output often strictly follows style guides and patterns it was trained on, meaning consistency can be very high. In cases where minor fixes or refinements were needed, the team found it was a reasonable trade-off – the AI saved them a mountain of initial work, and the small percentage of sloppy output could be quickly deslopped by hand. This aligns with the broader sentiment that when guided by seniors and anchored to a solid architecture, vibe coding yields excellent results — even if minor fixes are still required.  It’s also worth noting the morale boost these tools provide. Developers often find it awesome to see an AI quickly generate boilerplate. It’s like having a supercharged pair-programmer who never gets tired. This makes the development process more enjoyable.  In interviews and online discussions, many express that once they got used to AI assistance, they wouldn’t want to go back. Despite initial skepticism, a lot of devs now say AI coding assistance is already absolutely necessary in their workflow.  At the same time, experienced voices caution against over-reliance or premature hype. They point out that the fundamentals of software engineering – understanding the problem, devising an elegant design, and maintaining code over time – still matter as much as ever. In other words, writing code was never really the hardest part - understanding and evolving it is.  LLMs have drastically reduced the effort of writing new code (the marginal cost of adding software is approaching zero), but they haven’t removed the need to think deeply about that code. Recognizing this, the most successful teams use vibe coding as a force multiplier for human creativity and diligence, not a replacement for them.
Lovable grows to $1.8 B valuation despite security issues
Lovable grows to $1.8 B valuation despite security issues
Its sole product, released in late 2024, is a web platform that converts plain language prompts into production-ready software. Lovable markets the service as a "vibe coding" environment and an "AI Software Engineer" that allows anyone, whether a coder or not, to assemble a complete application or website by describing the desired outcome in natural language. The slogan, "the last piece of software," reflects management’s belief that the tool will eliminate most routine programming work. How Lovable Works A user writes a short prompt, such as a request for a customer feedback portal or a multiplayer quiz game. Lovable then orchestrates several large language models to create the front-end interface, the back-end logic, a database, and the deployment pipeline.  The system stitches together code from Anthropic’s Claude, OpenAI’s GPT series, and Google’s Gemini family, but it relies primarily on Claude Sonnet after internal tests showed that this model is the most reliable. The firm built its own benchmark to measure how often a model "hits a wall" during the build process. Claude scored highest, so it serves as the default engine, while the others act as fallbacks.  The generated project includes two-way GitHub synchronization, Supabase back-end integration, a visual editor, and inline educational snippets that explain what each file does. The stated goal is a twenty-fold productivity gain for professional developers and a zero-to-one path for non-technical founders. Main Use Cases First, founders and product managers use the platform for rapid ideation and proof-of-concept work. Second, small businesses build commercial-grade web products, avoiding the cost of hiring a full development team. Third, larger organizations create internal tools — dashboards, workflow trackers, lightweight CRMs — without adding to backlogs in their main engineering groups. Unusually Strong Early Revenue Within three months of launch, Lovable reported annualized recurring revenue of $17 million and thirty thousand paying customers. Six months in, a public case study by Anthropic quoted $40 million in annual recurring revenue, and by the seventh month, the number had risen to $75 million.  Management also reports that more than one million people use the platform each month. Lovable is "Europe’s fastest-growing company ever" and the data lends some weight to this claim. The market intelligence outlet Sifted ranked Lovable first on its 2025 B2B SaaS Rising 100 list, an annual survey limited to companies valued below one billion dollars. Ambitious Financing Plan Lovable is in the final stages of a round that would raise more than $150 million and imply a valuation of approximately $1.8 billion. Accel is leading the transaction, with prior backers 20VC and Creandum taking pro rata positions.  The firm last tapped the market six months ago, in February 2025, when Creandum led a $15 million pre-Series A round. People involved in the new deal say the target size and headline valuation were increased during negotiations because investor demand was stronger than expected.  Both Lovable and Accel have declined public comment, but the consensus among advisers is that the round will close as scheduled on the stated terms. If completed, the deal would place Lovable among a growing group of multibillion-dollar European AI companies that includes Mistral, Synthesia, DeepL, and Helsing.  Security Concerns The company claims that, on average, the end-to-end build process runs twenty times faster than a traditional development cycle. The speed advantage, however, brings security concerns. A Replit employee published research showing that 170 of 1,645 analyzed Lovable projects exposed personal data, including names, email addresses, financial information, and secret API keys. The root cause was almost always the same: misconfigured Supabase access controls. Because Lovable encourages direct database connections, an error in the rules can leave tables open to the public internet. The vulnerability was entered into the U.S. National Vulnerabilities Database after Lovable’s 45-day remediation window lapsed.  On the social media site X, the company conceded that it is "not yet where we want to be" on security and promised to improve. It also released a built-in scanner that checks whether Supabase access controls are enabled, though critics note that the tool does not verify whether the rules themselves are correct. Security specialists argue that letting novice users attach live databases to public applications revives risks long considered solved in professional engineering.  Insecure vibe coded apps are the single biggest challenge. Former Facebook security chief Alex Stamos says the odds of a beginner configuring permissions correctly are "extremely low." Replit chief executive Amjad Masad adds that any platform making deployment trivial must also make accidental exposure difficult. Analysts draw parallels to the 1990s web era, when dynamic sites multiplied faster than secure coding practices could keep up. The difference now is that attackers can automate reconnaissance with the same AI tools developers use to write code. Lovable’s leadership says community feedback is integral to its roadmap. An active Discord server acts as a bug report channel, feature request board, and informal support forum. Adoption appears strongest among solo entrepreneurs, small founding teams, and product or design professionals looking to build tangible demos without waiting for scarce engineering resources. The company’s documentation emphasizes that human review remains essential for sensitive deployments, and forthcoming releases will add automated penetration tests, linting for security issues, and one-click migration from the built-in database to managed cloud services with stricter defaults. Broader Trend European AI agent start-ups collectively raised €481 million during the first six weeks of 2025, already more than a quarter of the total for all of 2024.  Competition is emerging on both sides of the Atlantic. In the United States, direct competitor Anysphere tripled its valuation to $9 billion after a $900 million Series B in May 2025. The broader coding assistant field now includes Microsoft, OpenAI, Anthropic, Poolside, Bolt, and Replit, while design software providers Figma and Canva are adding generative AI modules of their own. Investors often cite "vibe coding" as one of the most straightforward ways to monetize large language model technology because it maps directly onto established software team budgets. Lovable distinguishes itself by aiming squarely at users with little or no coding background. Where Cursor and other incumbents target professional engineers, Lovable promises true no-code operation. The system reads a text brief, proposes an initial architectural outline, asks follow-up questions if necessary, and then emits a running application with authentication, database tables, and deployment scripts already configured.  2025 as a Pivotal Year Industry observers view 2025 as a pivotal year for AI-driven software creation. Only about one percent of the global population can write code, yet software needs continue to expand. By pushing large language model capabilities into a no-code package, Lovable aims to widen the pool of "builders" and cut iteration time for professionals.  Chief executive Anton Osika proposes that engineers will shift from handcrafting features to integrating pre-built blocks and translating user needs into system specifications. He sees further model advances reducing the manual work still required today, though he also argues that human oversight will remain necessary to assure quality, reliability, and policy compliance. Looking Ahead Lovable plans to channel the new capital into model research, security hardening, and a push into enterprise accounts. Management believes that combining faster build times with reliable guardrails will appeal to corporate teams that must deliver internal tools under tight budgets. Part of the funding will go toward expanding the platform’s library of pre-configured components and industry templates — health records viewers, logistics dashboards, subscription e-commerce stacks — so users can start from semi-finished blueprints rather than blank pages. The firm also intends to deepen its relationship with Anthropic, arguing that specialized fine-tuning could raise reliability further and open the door to domain-specific variants for finance, healthcare, and education. Investors frame Lovable as a bet on the application layer of generative AI rather than on foundational models themselves. While Europe has fewer hyperscale compute clusters than the United States or China, its start-up scene has proved capable of building vertical products on top of global model APIs. Lovable’s challenge is to maintain its early lead in usability and speed while closing the gap in security maturity. If it succeeds, the company may demonstrate that world-class AI software firms can scale rapidly outside Silicon Valley. If it falters, competitors with deeper pockets or stronger security postures will absorb the same demand. Either way, the rapid rise of vibe coding tools suggests that natural language programming is moving from experiment to mainstream practice, and Lovable has placed itself at the center of that transition. The next twelve months will test every dimension of the business. Users will tolerate friction in a young product, but they expect steady evidence that the platform can support production workloads without exposing sensitive data. If Lovable can balance velocity with safety, it will not only shorten build cycles, it could change who gets to participate in software creation and how the industry values the skill of writing code.
Enterprise Vibe Coding vs SaaS
Enterprise Vibe Coding vs SaaS
Internal Vibe Coding: Will Enterprises Buy Fewer SaaS Applications? Artificial intelligence coding platforms (Lovable, Bolt, Replit, Cursor, etc.) are rapidly transforming enterprise software strategy. By converting simple, natural language prompts directly into working code, these tools reduce the difference between adopting a SaaS subscription and coding your own solution to nothing. As the time, cost, and complexity of DIY development drop, the value proposition of traditional subscription-based SaaS comes into question. Companies that master AI development can control their software, reduce spending, and accelerate innovation.   Low Barriers In many cases, it is already faster to build a custom tool with AI than to learn a vendor’s complex user interface. Non-programming AI builders - often business or operations specialists - can now create working software after only weeks of training. This growing talent pool, combined with the productivity boost from AI for every developer, makes projects that once seemed uneconomical suddenly possible.  The first areas to move from buying to building are lightweight but highly customized.  These include HR and training portals, Q&A and knowledge bases, revenue operations dashboards, CPQ calculators, AI-driven healthcare tools (like AI medical coding software), and custom marketing tools.  Security team can replace a SaaS-based survey with an internally built alternative using Bolt. A revenue operations staff member can code a pricing calculator that would have once required commercial software. A recruiter can use the Lovable platform to create an interview training course. Managers can write even their own AI-based personal CRM, sidestepping the Salesforce interface completely. Incumbent vendors feel the pressure. While the core Salesforce customer record database may stay popular, the profitable add-ons built on top of it are now vulnerable. Salesforce’s response - its new Agentforce suite - shows early promise. Many smaller and mid-tier SaaS providers do not have similar options. Challenges Enterprise-level reliability, security, and ongoing maintenance do not go away just because code is machine-generated. When an AI-written application fails, it is not always clear who owns the fix.  To reduce that risk, AI-building platform providers provide standard stacks that include authentication, staging, security controls, and data access patterns. This lets companies move prototypes into production without hiring large teams of senior engineers. Bright New Future? Firms that use AI tools early will gain speed, flexibility, and cost advantages. Those that rely only on SaaS could end up paying more for less.  On the other hand, software vendors must build unique AI features or face the risk of being replaced.   Overall SaaS spending still rises. Companies keep buying cloud software, just a different mix. Heavyweight systems stay SaaS - ERP, finance, payroll, global CRM databases remain too complex or regulated to rebuild quickly - those contracts keep renewing. However, some CEOs already predict a shake-out in which only the largest or most AI-advanced SaaS vendors survive, while the rest are folded into broader hubs.   Some SaaS Was Never Hard to Build Before AI-assisted vibe coding tools appeared, most business-to-business software development was slow rather than technically difficult.  Many engineering teams spent weeks or months recreating features every SaaS product needs, such as user-permission matrices, audit logs, and email notification systems, even though thousands of developers had solved these problems before. Eighty percent of an engineer’s time went into this repetitive work, while the truly difficult challenges - understanding customers, designing the right workflow, and scaling the architecture - competed for the remaining bandwidth. Generative AI coding platforms such as Cursor, Windsurf, Loveable, and Replit change that equation. By recycling proven open-source patterns and boilerplate, they reduce build times for standard features by at least half and often by as much as five times.  A user-permission service that once took three weeks now appears in three days. An audit log drops from two weeks to half a day. Email scaffolding is ready in hours.  These tools do not yet create a fully hardened, enterprise-grade product overnight, but they eliminate the “artificial slowness” that used to dominate business-to-business development. Since well over ninety percent of SaaS functionality is routine, the impact is broad. Product teams can test several workflow designs in the time it once took to build one, refining decisions with real feedback. Engineering is no longer the bottleneck. Requests that used to trigger three-month roadmap debates now become three-week sprints, and internal panels or admin consoles are ready by Friday.  For founders and engineering leaders, the question is no longer whether AI will replace developers - it will not. The question is whether their teams will use AI to remove busywork and focus their talent on the problems that matter, such as deeply understanding users, creating scalable systems, and delivering experiences that competitors find hard to copy. Teams that adopt this new approach will reach product-market fit faster and set prices based on differentiated value. Those who do not will still be discussing three-month roadmaps while their rivals are already shipping. Vibe coding tools mark a fundamental shift, not because they solve the hardest technical problems, but because they remove the slow, repetitive ones that never gave any advantage. Companies that move now will build better products, faster. Those that delay risk watching the market move past them. More and More Enterprise Software Will Be Assembled with Vibe Coding Techniques "Vibe coding", the term computer scientist Andrej Karpathy introduced in February 2025 for using large language model tools to generate production code, is quickly rising on the CIO agenda.  Gartner estimates that by 2028, about 40 percent of all new enterprise software will be assembled with vibe coding techniques.  Yet most large organizations remain cautious. The current generation of vibe coding platforms excels at small, temporary projects. For example, a user interface prototype during a hackathon or a celebratory web page in minutes. Such experiments succeed in sandboxes, proofs of concept, and disposable utilities.  In these cases, the code does not need to be highly robust, scalable, or built to last. Those qualities are exactly what enterprises need for customer-facing or critical systems, and analysts agree the tools are not there yet. Security controls, audit trails, and large-scale deployment patterns are still being developed. CIOs say they welcome AI-driven productivity, especially during multiyear cloud and ERP migrations, but insist they will not compromise on enterprise-grade reliability. A March 2025 HackerRank survey found that more than two-thirds of engineers feel extra pressure to deliver faster since AI assistants became part of the tool chain. Gartner expects about 80 percent of developers to reskill by 2027 as generative AI changes their roles, shifting work from writing boilerplate code to reviewing, securing, and integrating AI-generated output. Analysts urge CIOs to keep vibe coding projects in controlled, well-governed environments, set clear security, compliance, and testing standards, and keep close communication with engineering teams to decide where this approach fits best.  Large language models are improving quickly, and Omdia predicts noticeable quality improvements within six to twelve months, so the readiness gap may close sooner than expected. Until then, organizations that pair strong governance with targeted pilots can gain early productivity benefits without taking on unknown risk.  Scaling Vibe Coding in Enterprise IT Enterprises are experimenting with vibe coding - the practice of using large language model tools to generate working software with minimal hand coding - because it promises rapid prototyping and shorter release cycles. Thanks to readily available LLM APIs, GitHub Copilot, and similar assistants, projects that once required a full-stack team can now be kicked off by analysts or subject matter experts.  The difficulty emerges when organizations try to scale those prototypes for everyday, nontechnical users. Choices that feel harmless in a sandbox can turn into long-term liabilities. Extending a Python Flask demo to a full web product, for instance, collides with the reality that most modern front-end tooling, hosting frameworks, and pretrained AI agents gravitate toward React and TypeScript stacks. Are you ready for this? Two distinct modes of vibe coding Senior architects use AI as a force multiplier: they prompt multiple agents, explore design forks, and evaluate trade-offs quickly. Casual enthusiasts, by contrast, may generate code on demand and ship it unchecked.  Both practices produce very different outcomes and risk profiles. Without oversight, the second mode can scatter inconsistent applications and unforeseen technical debt across the enterprise. Architecture and economics Hosted models such as OpenAI’s deliver sub-three-second responses that local open-source models struggle to match without substantial GPU investment. Firebase accelerates back-end build-out by more than 60 percent compared with Kubernetes, but its usage-based billing can become volatile once user numbers rise. Each platform or data-store decision ripples through cost forecasts, latency budgets, and support models, demanding active monitoring and a clear exit strategy. For CTOs, vibe coding shifts the bottleneck from writing code to deciding what should be built, how it should be hosted, and whether the result is operationally sustainable. Deep technical judgment becomes more valuable, because the keyboard is no longer the scarce resource - architectural clarity is.  Scaling safely requires rigorous product management: centralized governance committees, reference architectures for would-be vibe coders, scoped feature requests, scheduled technical-debt reviews, and explicit security and compliance checkpoints. Cultural enablers matter too - structured upskilling in prompt engineering, psychological safety for experimentation, and guardrails that prevent burnout amid rapid iteration. Handled well, vibe coding lets enterprises capture innovation speed without the chaos of uncontrolled cloud sprawl. Handled poorly, it simply turbocharges mistakes.

Our Clients' Feedback

Any software development, programming, or design needs we have had, Belitsoft company has always been able to handle this for us

We have been working for over 10 years and they have become our long-term technology partner. Any software development, programming, or design needs we have had, Belitsoft company has always been able to handle this for us.

We are very happy with Belitsoft

Belitsoft has been the driving force behind several of our software development projects within the last few years. This company demonstrates high professionalism in their work approach. They have continuously proved to be ready to go the extra mile. We are very happy with Belitsoft, and in a position to strongly recommend them for software development and support as a most reliable and fully transparent partner focused on long term business relationships.

We can recommend Belitsoft and are looking forward to start a follow-up project

It was a great pleasure working with Belitsoft. Software Development Company. New requirements and adjustments were implemented fast and precisely. We can recommend Belitsoft and are looking forward to start a follow-up project.

Let's Talk Business
Do you have a software development project to implement? We have people to work on it. We will be glad to answer all your questions as well as estimate any project of yours. Use the form below to describe the project and we will get in touch with you within 1 business day.
Contact form
We will process your personal data as described in the privacy notice
This site is protected by reCAPTCHA and the Google Privacy Policy and Terms of Service apply
Contact us

USA +1 (917) 410-57-57
700 N Fairfax St Ste 614, Alexandria, VA, 22314 - 2040, United States

UK +44 (20) 3318-18-53
26/28 Hammersmith Grove, London W6 7HA

Poland +48 222 922 436
Warsaw, Poland, st. Elektoralna 13/103

Email us

[email protected]