Software factories and the agentic company

I’d heard the phrase “software factory” before. It only clicked after I accidentally assembled one.

My current mobile development loop looks roughly like this:

Intent → Linear → Cursor Cloud → GitHub → CodeRabbit / agent review → next decision → repeat

Linear holds the durable intent. Cursor implements asynchronously. GitHub holds the resulting state. CodeRabbit reviews the implementation. Another agent can inspect what changed and help decide what should happen next.

Increasingly, my job in that loop is not operating every tool or writing every line. It is setting direction, reviewing outcomes, and making decisions between specialized systems.

That is the more interesting meaning of a software factory: not one powerful coding agent, but a pipeline of specialized workers where the output of one stage becomes the input or event for another.

Why would this stop at software?

If the pattern works, each business function could develop its own factory:

• Engineering: work item → coding agents → GitHub → review → deploy
• Marketing: brief → research / content / design agents → review → CMS / publish
• Support: ticket / signals → investigation → response → knowledge updates
• Sales: account signals → research → outreach → CRM updates
• Product: feedback / signals → analysis → spec / prioritization → work

The exact tools will differ. The pattern is similar: specialized agents operate systems, evaluate one another’s output, and hand work between stages while humans supervise goals, exceptions, and important decisions.

The future may be less “one giant AI employee” and more a company made of many increasingly capable functional factories.

The coordination problem

Companies do not operate as independent functions.

A software factory can successfully ship a feature while creating consequences elsewhere:

• pricing may need updating
• docs may become stale
• support guidance may now be wrong
• sales collateral may need new language
• onboarding may need to change
• another agent may now be operating from an outdated assumption

The same is true in the other direction. A support factory might discover a recurring product issue. A marketing factory might change positioning that affects sales enablement. A sales factory might uncover information that should influence product work.

Each factory can optimize its own domain while the company still has to operate as a coherent whole.

Agents optimize locally. Companies need global coherence.

Why this gets harder

Agents dramatically increase the rate at which a company can act.

That means they also increase the rate at which the company changes.

Humans currently provide a surprising amount of connective tissue between functions. Someone remembers that a packaging decision affects the pricing page. Someone tells Support about the new behavior. Someone realizes a sales deck contains an outdated claim.

As more execution becomes autonomous, the amount of human attention available to notice those second-order consequences does not scale at the same rate.

The company already has a dependency graph. Much of it lives implicitly in people’s heads.

The scarce resource in an agentic company may become attention to the consequences of change.

The open question

Software factories may be the first visible example of a pattern that spreads to every business function.

If every function becomes capable of acting autonomously, what keeps the company coherent?