LLMs, Language, and the Need for a Semantic Substrate

Large language models have changed how we write software. You can describe a feature in English and receive working code. You can translate between programming languages in seconds. You can scaffold entire systems conversationally.

But this raises a structural question:

If English can generate code, what is the real source of truth?

• LLMs, Language, and the Need for a Semantic Substrate
• Three Layers of Specification
• 1. Natural Language
• 2. Programming Languages
• 3. The Missing Layer
• Why LLMs Increase the Need for Structure
• A Better Architecture
• What a Semantic Substrate Must Provide
• Natural Language vs World Models
• Cohesive Systems: Semantics First
• The Strategic Shift
• The Future of Programming
• References

Three Layers of Specification

There are now three competing layers:

1. Natural Language

English is:

• High bandwidth
• Flexible
• Expressive
• Ideal for exploration

But it is also:

• Ambiguous
• Context-sensitive
• Non-deterministic
• Not mechanically verifiable

Natural language captures intent. It does not define semantics.

When used as the source of truth, systems drift. Regeneration changes behavior. Intent cannot be diffed. Invariants cannot be checked.

English is an excellent design surface. It is not a stable semantic foundation.

2. Programming Languages

C#, Rust, TypeScript, SQL - these remain the operational source of truth.

They provide:

• Deterministic execution
• Type systems
• Tooling and static analysis
• Mechanical verification

But they mix:

• Meaning
• Infrastructure
• Optimization
• Incidental complexity

Programming languages are execution-oriented. They encode how more than what. LLMs can generate code in any of them, but they are still generating implementations, not semantics.

3. The Missing Layer

What is missing is a stable, high-level semantic substrate.

Something that is:

• Easy to read and write
• Declarative and composable
• Deterministic and canonical
• Verifiable
• Compilable to multiple runtimes
• Friendly to AI systems

Not English. Not raw code. A semantics-first intermediate representation.

Why LLMs Increase the Need for Structure

It might appear that AI eliminates the need for formal specification languages.

The opposite is true.

The more automation you introduce, the more you need:

• Explicit invariants
• Canonical forms
• Deterministic normalization
• Separation of semantics from execution

Without this, regeneration becomes chaotic. Systems become unstable under iteration. LLMs reduce the cost of authoring high-level abstractions. They do not remove the need for semantic anchors.

A Better Architecture

A stable future stack looks like this:

Layer 1 — Natural Language

Intent capture. Exploration. Collaboration. Conversation with AI.

Layer 2 — Semantic Substrate

Explicit domain models. Relations. Transitions. Processes. Invariants.

Layer 3 — Generated Code & Runtime

APIs. Storage. Orchestration. Infrastructure. LLMs operate between these layers. They do not replace them.

What a Semantic Substrate Must Provide

An effective substrate must:

• Represent entities as typed algebraic structures
• Represent relations as composable relational algebra
• Represent transitions as deterministic state transformations
• Represent processes as coordination semantics
• Make invariants explicit
• Separate meaning from execution strategy
• Compile to multiple targets (C#, SQL, Elastic, EDI, etc.)
• Support canonical diffing and analysis

It must be expressive enough for real systems. And precise enough for mechanical reasoning.

Natural Language vs World Models

Some AI research (e.g., predictive latent world models) suggests that intelligence arises from learned internal representations rather than symbolic structure. That may be true for general cognition.

But software engineering requires:

• Auditability
• Stability
• Determinism
• Long-term maintainability

Learned latent embeddings are not suitable as specification languages. Symbolic semantics remain necessary.

Cohesive Systems: Semantics First

Cohesive Systems treats semantics as the foundation.

Everything else is projection.

• Entities define stable data algebra.
• Relations define compositional queries and mappings.
• Transitions define deterministic state evolution.
• Processes define coordination semantics.

Execution is layered on top. Infrastructure is generated from meaning. AI assists at every level, but does not replace the substrate.

The Strategic Shift

Before LLMs, building high-level semantic DSLs was expensive.

Now:

• AI can generate boilerplate.
• AI can translate between representations.
• AI can help author semantic models directly.

This changes the economics.

We can afford to build systems where:

• Meaning is explicit.
• Code is derived.
• Infrastructure is generated.
• Semantics are stable.

The Future of Programming

English will increasingly become the interactive interface.

Programming languages will remain execution targets.

But the durable systems — the ones that scale in complexity without collapsing — will rely on a stable semantic core.

That is the direction of Semantic Systems Engineering.

Not replacing code with English.

Not replacing structure with probability.

But introducing a deterministic substrate between intent and execution.

Cohesive Systems is building that substrate.

References

Cohesive & SaaS

Cohesive Building Blocks

Cohesive Systems Language