Traditionally, scaling software development meant adding engineers, time, and resources. AI is changing that equation by making code cheaper and faster to write. But generating code faster does not necessarily mean delivering software faster. Code still needs to be reviewed, tested, and deployed, creating new bottlenecks for engineering teams.
For engineering leaders, this raises a question: how can software delivery scale without a corresponding increase in headcount?
ForgeCode is addressing this challenge by building what it calls an AI-native software factory. The platform uses AI agents to manage the software development lifecycle, from specifications and implementation to testing and deployment, with humans providing oversight.
At TechSparks 2026, Founder and CEO Tushar Mathur demonstrated how the platform works and explained why the falling cost of writing code is making review, testing, and deployment more important to software delivery.
The shift in bottlenecks
While AI has increased individual productivity, those gains have not necessarily translated into faster software delivery across organizations.
“The first thing that we are seeing is practically all code is autogenerated today,” Mathur said.
Engineering teams can now generate thousands of lines of code quickly, but the processes that follow: code reviews, testing, security checks, and deployment are struggling to keep up.
According to Mathur, the bottleneck has shifted from writing code to managing what happens after it is written.
“Earlier, writing code was the main fundamental bottleneck. But today, the cost of writing code is so low that all these other aspects have become the bottlenecks,” he explained.
As a result, teams risk producing more poorly reviewed, buggy or uncoordinated code because the systems needed to manage the increased output have not kept pace.
The rise of the AI-native software factory
To address this gap between individual productivity and organizational output, Mathur introduced ForgeCode’s approach to an AI-native software factory.
The idea is to move away from a software development lifecycle that depends on people manually coordinating each stage.
Instead, AI agents handle tasks such as triaging, planning, implementation, and verification. Humans step in when decisions, direction, or more detailed feedback are required.
Unlike conventional automation, which links a series of predefined steps, the software factory uses continuous feedback loops.
Inputs from CXOs, product managers, and production monitoring systems can feed directly into the development backlog. Agents then work around the clock to develop features, identify bugs, and improve performance, including when engineering teams are offline.
The aim is to keep software development moving without requiring engineers to manage every individual task.
Six tenets of a modern software factory
Mathur outlined six principles that he believes are essential to building an effective AI-native software factory.
- Autonomous operation: The system should work continuously, with humans supervising performance rather than coordinating individual tasks.
- High scalability: Organizations should be able to scale engineering work quickly, whether they are developing a small feature or rewriting an entire application in a different programming language.
- Cost-effectiveness: The factory delivers multifold returns compared with manual development, measured through two key factors: the cost of building software and the speed at which it can be shipped.
- Measurability: The system should track deployment frequency, bug density, and costs, using this information to assess and improve its performance.
- Self-improvement: The factory should use data and feedback to refine its processes over time and avoid repeating earlier mistakes.
- Business-driven development: Features should be prioritized according to business objectives, such as customer retention or compliance, rather than solely by technical backlog requirements.
Together, these principles are intended to make software development more autonomous while keeping it aligned with business priorities.
Handling trade-offs and non-functional requirements
During the audience Q&A, Mathur was asked how engineering teams should approach trade-offs and complex non-functional requirements such as scalability and database architecture.
He said requirements that can be objectively verified, such as scale targets, can be delegated to the software factory. The system continuously tests outcomes and optimises whenever a check fails. Trade-offs, however, require human judgment. Questions such as how much risk or failure a business is willing to tolerate remain decisions for engineers and business leaders, who step in to guide the agent when needed.
ForgeCode said this is possible because the platform operates on a self-improving feedback loop. Every task, decision, and correction contributes to a knowledge base that informs future work. Engineers remain closely involved in the early stages, but as the system learns a team's engineering practices and business context, it can operate with greater autonomy.
The platform also learns which decisions are critical and require expert oversight, particularly those involving security, reliability, performance, and competing business priorities. In such cases, it pauses and seeks human input before proceeding.
This growing ability to distinguish between routine execution and decisions that require expert judgment is central to how the product works.
Steering the factory floor
ForgeCode's AI-native software factory is designed to turn gains in individual coding productivity into faster software delivery across an organization.
By using agents to manage coordination, code reviews, testing, and other development tasks, the platform aims to reduce the bottlenecks that can slow engineering teams.
For Mathur, the shift is about changing the role of engineers. Rather than managing every stage of development, they would focus on defining requirements, making decisions, reviewing outcomes, and guiding the overall process.
The goal is not simply to generate more code or build larger teams, but to develop software more efficiently through autonomous systems that operate continuously, with human oversight.
Source: YourStory
