ForgeCode’s Tushar Mathur wants software development to run like a factory, not a project

An AI-native software factory is a system in which AI agents manage much of the software lifecycle, from specifications and implementation to testing and deployment. It matters because writing code is becoming cheap and fast, while the work around code is creating new bottlenecks. The factory aims to scale delivery without adding engineers for every task.

In a traditional project, people manually coordinate stages and track individual tasks. ForgeCode’s approach lets agents triage requests, plan work, implement features, verify results, and respond to feedback. Inputs from executives, product managers, and production monitoring can feed the backlog directly. Agents can then keep working while engineers are offline.

Humans do not disappear from the process. They supervise performance, provide direction, and make decisions when judgment is needed. The proposed model also measures deployment frequency, bug density, and cost. Over time, feedback helps the factory improve and align development with business goals.

ForgeCode’s platform is designed to manage the software development lifecycle as one connected system. It begins with specifications and work entering the development backlog. The goal is to remove manual coordination between planning, implementation, verification, testing, and deployment. This matters because faster code generation alone does not guarantee faster delivery.

For example, feedback from a CXO, product manager, or production monitoring system can create or update backlog work. Agents then triage the request, plan an approach, write the implementation, and verify the result. They continuously test outcomes and can identify bugs or improve performance while engineering teams are offline.

Engineers remain responsible for oversight and decisions that need human judgment. The platform’s broader aim is an always-moving development process. It also tracks deployment frequency, bug density, and costs, using those results to refine its operation and improve future delivery.

According to Tushar Mathur, “practically all code is autogenerated today.” The article does not give a precise percentage, but it describes autogenerated code as widespread across software development. Teams can now produce thousands of lines quickly. This changes the economics of engineering, but it does not remove the need to assess and deliver that code safely.

When generation was slower, writing code was the main bottleneck. Now, each new batch still needs code review, testing, security checks, and deployment. Those activities may not accelerate at the same rate. As a result, a team can create more code without increasing the amount of software that reaches users.

The main bottleneck has therefore shifted from writing code to managing what happens afterward. Mathur’s software factory addresses this gap by assigning lifecycle work to AI agents. The intended result is faster organizational delivery, not merely faster individual coding.

ForgeCode’s agents can handle many repeatable parts of software delivery. The article names triaging, planning, implementation, and verification. Agents can also develop features, identify bugs, improve performance, and continuously test outcomes. This division lets software work continue without engineers managing every individual task.

For example, a production monitoring signal can feed the backlog. An agent can assess the request, plan changes, implement them, and verify whether the result meets an objective check. If a scale target is not met, the system can keep testing and optimising until the check passes. This creates a continuous feedback loop rather than a fixed chain of steps.

People remain essential when a choice cannot be settled by an objective test. Mathur said trade-offs require human judgment. Engineers and business leaders must provide direction, detailed feedback, and decisions about acceptable risk or failure. Humans supervise the factory rather than vanish from development.

An AI software factory scales by separating the amount of work from the number of people manually coordinating it. Agents can keep handling backlog items, implementation, verification, and optimisation continuously. This matters because the platform is designed to support both a small feature and a much larger transformation without changing its basic operating model.

The article gives a direct example: an organisation might use the factory for a small feature or for rewriting an entire application in a different programming language. In either case, agents work through specifications, planning, implementation, testing, and deployment. Feedback from monitoring systems can continue entering the backlog as work progresses.

The proposed advantage is high scalability, supported by autonomous operation and measurement. The factory tracks deployment frequency, bug density, and costs. Those measures help leaders assess performance and improve the process. Humans still provide direction and oversight, especially when large changes involve difficult trade-offs.

If code generation accelerates while review, testing, security checks, and deployment remain slow, software delivery develops a new bottleneck. Code may be produced quickly, but it cannot move safely through the rest of the lifecycle. The organisation gains individual productivity without gaining equivalent output for users.

The article warns that teams risk producing more poorly reviewed, buggy, or uncoordinated code. For example, thousands of generated lines may wait for review or fail tests faster than engineers can respond. Security checks and deployment can add further delays. The problem is not simply the quality of generated code; it is the ability to manage the volume after generation.

ForgeCode’s proposed answer is to use agents for the downstream work as well as implementation. Continuous testing, verification, bug fixing, and performance improvement can keep the flow moving. Humans still supervise and decide. The goal is to prevent faster generation from overwhelming delivery controls.

The software development lifecycle is the sequence of activities used to turn a software need into a working release. In this article, it includes specifications, planning, implementation, verification, testing, and deployment. It matters because software delivery depends on every stage, not just on producing source code quickly.

Code review helps teams examine what was written. Testing checks whether the software behaves as expected. Security checks look for problems that could make the software unsafe. Deployment moves the result into use. The article identifies these activities as bottlenecks because AI can generate thousands of lines before teams can complete the follow-up work.

If these stages cannot keep pace, code may become poorly reviewed, buggy, or uncoordinated. ForgeCode proposes agents that manage more of the lifecycle through continuous feedback loops. Engineers still supervise the process and handle decisions that require judgment, while objective checks can be delegated to the system.