From Software Factories to Semantic Systems

Software factories use AI agents to write code, run tests, review changes, and coordinate delivery. They make software production faster, but most retain the structure of the work they automate. They are like replacing steam engines with electric motors in factories still laid out for steam.

Electric power allows machines to be arranged around the work itself, freeing the factory from the central engine and its transmission shafts. AI opens a similar opportunity in software: reconsider what we author and how we express the system we want to build.

The Factory Layout

Today's software factories operate largely on repositories, tickets, prompts, and tests. Agents reconstruct the system's meaning from those sources, then encode their decisions in more implementation. The rules governing identity, state changes, authority, and coordination remain scattered across code and context that each change must recover.

Spec-driven development approaches the work through explicit specifications. Agents can now implement those specs, taking on work previously done by humans. When the specs remain natural-language documents, however, the human interface for describing the system stays the same. Authors still write prose whose types, references, and consistency require interpretation.

Natural language provides no built-in type checking, reference checking, or normalization, and leaves verification and validation dependent on additional tools and judgment. Agents make these documents easier to realize, while the limitations of their form remain.

A Language for Systems

Programming languages give us abstractions over instructions, memory, and execution. Frameworks add concepts for particular kinds of applications, but specifying a whole system still requires us to assemble its meaning across many tools and conventions.

The new opportunity is a language for specifying systems with primitives designed for that purpose. An entity has identity and state. A transition states how that state may change. An invariant states what must remain true. Processes describe coordination over time, while authority and effects make permissions and consequences explicit.

Authors can express the system's rules in these terms. A shipment can be dispatched only after approval; its carrier must be notified after the state change commits. A system language gives these relationships explicit types and references, so tools can check them as authors compose the system.

Semantic Source

Cohesive captures these definitions as semantic source: readable, modular artifacts with defined syntax and semantics. Its compiler checks and normalizes the definitions into a semantic system graph. The graph connects the system's meaning to code, APIs, workflows, and infrastructure. As the system changes, its definitions provide a durable basis for generating implementations and checking whether they preserve its rules.

Software factories and spec-driven development can use semantic source to guide production. Authors get feedback on the definitions themselves, and agents can explore implementations within explicit constraints. Verification and validation can use the declared rules to check implementations and assess whether the system serves its intended purpose. The authored system survives changes in the framework, runtime, or agent that realizes it.

Where Cohesive Fits describes how this language works alongside software factories and coding harnesses.