Agentic AI Coding: What Still Remains Expensive Amid a 90% Drop in Costs

AI agents significantly reduce coding time. If a problem can be reduced to something solvable by simple code, an AI assistant can deliver the solution very quickly. However, reducing a complex problem to one solvable by simple code still requires senior skill, experience, and time. That is why building a complex multi-tenant, compliant B2B SaaS system that generates revenue for owners is still not easy, even with AI agents. Obviously, the cost of building software that works in a lab has become much lower. But is it really true that the cost of building software that runs reliably in production for years is also much lower with AI agents? It depends. Some believe you can expect only a 50% reduction in human engineering effort, which becomes a 10% savings on total expenditures. However, clients of Belitsoft know that with the right software engineering team from the right location, the total cost reduction may be much more than just 10% (which is also not bad, depending on the project size: 10% of one million is 100,000).

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.