Tushar Mathur from ForgeCode advocates for the software development process to function like a manufacturing factory rather than remaining a project. Traditionally, scaling development required an increase in engineers, time, and resources. However, artificial intelligence is changing this paradigm, making code writing faster and cheaper.
Nevertheless, accelerating code generation alone does not guarantee faster delivery of the finished product. The code still requires review, testing, and deployment, which creates new bottlenecks for engineering teams.
A question arises for heads of engineering departments: how to ensure the scaling of software delivery without a proportional growth in staff? ForgeCode solves this problem by creating what they call an AI-driven software factory. This platform uses AI agents to manage the entire software development lifecycle—from task definition and implementation to testing and deployment, with humans providing oversight.
At the TechSparks 2026 event, founder and CEO Tushar Mathur demonstrated the platform's operation and explained why reducing the cost of writing code makes review, testing, and deployment processes more critical for software delivery.
Despite increased individual productivity due to AI, these improvements do not always translate into faster software delivery at the organizational scale. Mathur noted: 'The first thing we are seeing is that almost all code today is generated automatically.'
Engineering teams can quickly create thousands of lines of code, but subsequent stages—code review, testing, security checks, and deployment—struggle to keep up with this volume. In Mathur's view, the bottleneck has shifted from the coding process itself to managing what happens after creation.
He explained: 'Previously, the main fundamental bottleneck was writing the code. But today, the cost of writing code is so low that all these other aspects have become the bottlenecks.'
As a result, teams risk releasing more code that has low quality assurance, contains errors, or is uncoordinated, because the systems needed to manage the increased workload cannot keep pace.
To bridge the gap between individual productivity and overall organizational results, Mathur presented ForgeCode's approach to building an AI-driven software factory. The core idea is to move away from a software development lifecycle that depends on manual coordination of every stage by humans.
Instead, AI agents take on tasks such as task sorting, planning, implementation, and verification. Humans intervene only when decisions, direction, or more detailed feedback are required.
Unlike traditional automation, which links a sequence of predefined steps, the software factory uses continuous feedback loops. Data from C-level executives (CXOs), product managers, and production monitoring systems can flow directly into the development backlog. Agents then work around the clock on feature development, bug identification, and performance improvement, even when engineering teams are inactive.
The goal is to maintain continuous software development momentum without requiring engineers to manage every single task.
Mathur outlined six principles he believes are necessary for creating an effective AI-driven software factory. These principles aim to make software development more autonomous while maintaining alignment with business priorities.
During the Q&A session, the audience asked Mathur how engineering teams should approach trade-offs and complex non-functional requirements, such as database architecture and scalability. He replied that requirements that can be objectively verified, such as scale targets, can be delegated to the software factory. The system constantly checks results and optimizes them upon verification failure. However, trade-offs require human judgment. Questions about acceptable levels of risk or failure that a company is willing to accept remain the domain of engineers and business leaders who intervene to guide the agent when necessary.
ForgeCode asserts that this is possible because the platform operates on a self-improving feedback loop. Every task, decision, and fix contributes to a knowledge base that informs future work. Engineers remain closely involved in the early stages, but as the system learns the team's engineering practices and business context, it can operate with greater autonomy.
The platform also determines which decisions are critical and require expert oversight, especially those concerning security, reliability, performance, and competing business priorities. In such cases, it pauses operations and requests human input before proceeding. This growing ability to distinguish routine execution from decisions requiring expert judgment is central to the product's functioning.
ForgeCode's AI-driven software factory is designed to convert gains in individual coding productivity into faster software delivery across the entire organization. By using agents to manage coordination, code reviews, testing, and other development tasks, the platform aims to reduce bottlenecks that can slow down engineering teams.
For Mathur, this shift means a change in the role of engineers. Instead of managing every development stage, they will focus on defining requirements, making decisions, analyzing results, and guiding the overall process. The goal is not just to generate more code or build larger teams, but to achieve more efficient software development through autonomous systems operating continuously under human control.
