— named one of yc demo day's standout startups —

— named one of yc demo day's standout startups —

All posts

The software factory will be a commodity. The plan won't.

Software factories will become commonplace. We believe the next step is a product factory that improves its plans with competitor signals and internal usage data.

Ben Ong

October 8, 2026

ai-agents

product-development

Diagram titled From software factory to product factory: a plan of customer outcome, codebase context, competitor signals and criteria feeds coding agents, with usage data from Amplitude and PostHog looping back from the outcome

Diagram titled From software factory to product factory: a plan of customer outcome, codebase context, competitor signals and criteria feeds coding agents, with usage data from Amplitude and PostHog looping back from the outcome

We believe the software factory will be commoditized.

By software factory, we mean the system that takes a request, runs coding agents, gives them an environment to work in, tests the result, and prepares a change for review. Building that system well is hard. But we expect access to that machinery to become commonplace.

When more teams can run capable agents on similar infrastructure, having a factory stops being much of an advantage. What matters is what goes into it.

A factory can produce working code for the wrong feature. It can implement an assumption nobody agreed to. It can make a bad product decision look finished.

That's why we're focused on helping teams create better plans at LightSprint. The goal is to give coding agents the context and decisions they need to build the right thing, and give the team a clear basis for judging the result.

The machinery will become easier to get

A software factory combines several things: models, agent execution, isolated environments, tests, previews, and review controls.

We expect those capabilities to become more widely available. Teams will have more ways to assemble them, buy them, and switch between them. A particular execution setup may be valuable today without remaining a durable advantage forever.

That doesn't mean all factories will be equally good. Reliability, security, cost, and the ability to work with a difficult codebase will still matter. A poor execution system can ruin a good plan.

But a great execution system can't decide whether the feature is worth building. It can't recover customer context it was never given. It can't know that the team rejected an approach last month unless that decision is available to it.

Our bet is that execution becomes easier to buy, while the ability to turn a real problem into a good build plan remains difficult to get right.

Better agents make bad inputs more expensive

A vague request doesn't become precise because an agent can act on it.

Consider a hypothetical request: "Add customer exports."

An agent could build a download button, a CSV endpoint, and tests that confirm the file downloads. The code could work exactly as written. The feature could still be wrong.

Perhaps customers only need to export their current filtered view. Perhaps some fields must never leave the workspace. Perhaps exports need to follow an existing permission model. Perhaps a large export needs to run in the background rather than hold a browser request open.

Those aren't finishing touches. They change the implementation.

If the team resolves them after the build, it has to undo decisions the agent already made. Faster execution can shorten that rework, but it doesn't remove it. The team still has to notice the mistake, explain the intended behavior, and check the correction.

A better plan makes those decisions visible before they become code. It also marks the questions that haven't been answered, rather than letting the agent turn uncertainty into an implementation choice.

The plan is more than a prompt

The important input isn't a clever sentence that gets the model to try harder. It's a shared understanding of the change.

A useful plan connects the customer problem to the product behavior, then connects that behavior to the codebase where it has to work. It gives the agent enough direction to act without pretending every detail is known in advance.

For the export example, that means answering a few concrete questions:

  • What problem are we solving? Which customer workflow needs an export, and why is the current experience insufficient?
  • What should the user be able to do? Define the records, fields, filters, and states the export must support.
  • What already exists? Identify the relevant data model, permissions, export utilities, and team conventions before choosing an approach.
  • What must stay unchanged? Name the access boundaries and existing behavior the change must preserve. Make the first version's exclusions explicit.
  • How will we check it? Specify observable acceptance criteria and the tests or product checks needed to verify them.
  • What is still uncertain? Separate decisions the agent can investigate from questions that need a person to answer.

This is a higher bar than a long ticket. More words don't necessarily produce a better plan. A detailed document built on the wrong assumptions is still a bad input.

The quality comes from the evidence behind the decisions and how well the plan fits the actual product.

Planning has to include the people who know the problem

Engineering knows how the system works. Product knows the intended outcome. Design knows the interactions and states. Support or sales may know why the request exists at all.

A plan gets weaker when that knowledge is lost between handoffs. The agent receives the final request, but not the reasoning that made it worth doing or the constraints that shaped it.

The alternative is to let the people with that context work on the same plan. They can challenge assumptions, settle tradeoffs, and see what the agent understood before implementation gets too far.

Anthropic's AI-native SDLC playbook describes intent, specifications, and plans as artifacts that people and agents can both read and act on. It also keeps humans accountable for decisions that require judgment. That supports the distinction we're making here: an executable plan carries the team's decisions into the build. It doesn't replace their judgment.

The plan also needs to stay editable. A preview may expose a missing state. Reading the code may reveal a constraint nobody anticipated. Good planning makes those discoveries easier to handle; it doesn't promise a perfect first pass.

Why we're building around the input

LightSprint already brings PMs, designers, and engineers into shared agent sessions on an existing codebase. Shared context, past decisions, and team conventions help the team work from the same information. Previews let them inspect what the agent built, and engineering approval controls remain part of the path to shipping.

We're building on that foundation with a clear priority: help teams create the best plans they can give a coding agent.

That means helping people clarify the outcome, pressure-test assumptions against the codebase, and make the intended behavior explicit. It means keeping the reasoning available to the agent and to the people who will review its work.

We don't think the answer is to lock teams into one model or one way of executing a build. As agents improve, teams should be able to use better agents without rebuilding their understanding of the product each time.

We want the plan to hold that understanding. The agent can then focus on implementation, while the team has something concrete to compare the result against. After shipping, the outcome should feed back into that understanding rather than disappear from the workflow.

The future is a product factory

A software factory takes a plan and produces a software change. We believe the next step is a product factory that learns from the outcome and feeds that evidence back into the next plan.

Its inputs would include signals from inside and outside the product. External signals include competitor launches, customer conversations, and changes in what buyers expect. Internal signals include feature usage, onboarding drop-off, retention, and support feedback.

Tools such as Amplitude and PostHog already help teams understand product usage, conversion, and retention. In the product factory we envision, that evidence would inform planning rather than stay in a separate dashboard. A team could connect an observed problem to a proposed change, define the outcome it expects, and give coding agents a plan grounded in that evidence.

The loop wouldn't end when the code ships. The team would look at whether customers used the change, whether it helped them complete the intended task, and what friction remained. Those results would become inputs to the next plan.

For our hypothetical export feature, a successful build proves that the export works. Product usage might reveal that customers still abandon the flow before downloading, or keep asking for a field the first version excluded. That is evidence to revisit the plan, not simply generate more code.

Learning also needs judgment. A competitor's launch is a signal to investigate, not a specification to copy. A change in usage doesn't prove that the latest release caused it. The team still needs to interpret the evidence, choose what matters, and approve the next change.

That's the future we're building toward at LightSprint. Better plans are the starting point. A product factory would keep improving those plans with external signals and internal usage data, so each build starts with more evidence about what customers actually need.

A factory is only useful if it builds something worth shipping

More generated code isn't the outcome. A change that solves the intended problem, fits the existing system, and passes the right checks is.

Our prediction is that the ability to run a software factory becomes ordinary. The harder work remains deciding what to build and translating that decision into instructions an agent can execute and a team can verify.

That's where we're putting our attention at LightSprint.

When every team has a factory, the advantage is knowing what to put into it, then learning from what comes out.

Explore LightSprint.