The AI Revolution Within the Long Arc of the Information Revolution
First, let us fix the historical position precisely. The AI revolution is not a standalone revolution — it is the current stage of the information revolution that has continued since the printing press. The printing press in the 15th century, telegraph and telephone in the 19th, radio, television, computers, and the Internet in the 20th, the IT revolution at the turn of the 21st century — and now the AI stage. Each stage inherited the achievements of the previous one, produced its own contradictions, and called forth the next.
When this chapter uses "AI revolution," it refers to this currently unfolding stage of the information revolution. Understanding it as "the AI stage of the information revolution" — rather than "a new revolution that came after the IT revolution" — is what makes the structure visible.
The Half-Seen Argument About the "AI Revolution"
The phrase "AI revolution" has taken on a life of its own. Most discussions use "AI" to mean roughly "the arrival of LLMs." This is where the oversight lies.
LLMs alone do not make a revolution. What made it a revolution is that another layer changed at the same time as LLMs. AI-native work — a genuinely new form of labor — only becomes possible as the product of both layers together. Either one alone does not get you halfway there.
This chapter defines the current stage of the information revolution (the AI stage) precisely as a two-layer simultaneous change.
Layer 1 — Structuring Natural Language via LLMs
Layer 1 is well known. LLMs (Claude, GPT, Gemini, etc.) became able to return structured outputs in response to natural-language inputs.
Natural-language input (questions, instructions, dialogue)
→ Markdown summary documents (readable, structured text)
→ Programming code (Python, SQL, shell, etc.)
→ Structured data (JSON, YAML, tabular form)
→ Diagramming notation (Mermaid, PlantUML)
This is a capability that did not exist before. Taking natural language as the entry point and converting it into output that machines can execute directly — this function removed, for the first time in history, the wall between humans and machines.
But this alone does not make a revolution. It requires tools that can receive the structured form LLMs produce and execute it as-is.
Layer 2 — The Evolution of Types in Programming Languages
Layer 2 is the overlooked one. The types that programming languages can handle have been fundamentally expanded.
| Stage | Types handled | Representative languages | Era |
|---|---|---|---|
| 1. Machine code | bit, byte | Assembly | ~1960s |
| 2. Structs | int, float, struct, array | C, Pascal | 1970s–80s |
| 3. Objects | + class, interface, generics | C++, Java, C# | 1990s–2010s |
| 4. AI-native substrate | + Markdown, DataFrame, JSON, Parquet, RDB, HTML, embedding | Python (especially AI-integrated) | 2020s– |
Stage 4 is the other body of the AI revolution. Programming languages became able to treat the output formats of AI themselves as first-class "types."
In Python this is immediately apparent:
json.loads(text)receives a JSON string as a dict — no class definition neededpl.read_parquet("file.parquet")reads Parquet as a DataFrame — schema inferred automaticallyfrontmatter.load("doc.md")reads Markdown as a structured dictdf.to_dicts()emits a DataFrame as a JSON list instantly
Because the new types can be treated as types, AI output flows through directly. No upfront class definitions, no schema declarations.
The Revolution Emerges as the Product of Both Layers
This is the crux. Only when both layers are in place simultaneously does AI-native work become possible.
Natural-language instruction (human) → LLM produces structured output (Markdown, code, JSON)
→ AI-native language (Python) receives the output directly
→ Executes on the structured substrate (DataFrame, Parquet, JSON)
→ Returns results in human-readable form (Markdown, tables, charts)
→ Completes as a single unbroken flow
What happens with only one layer:
| Situation | What happens |
|---|---|
| LLM present, new types absent (C#, Java) | AI output must be translated into class definitions each time. Translation labor persists permanently |
| New types present, LLM absent (Python only) | Data processing is fast, but there is no bridge from natural language. Remains a specialist tool |
| Both layers present (Python + Claude, etc.) | A single flow from natural language to execution. Accessible to non-specialists |
"People who lack both layers cannot ride the AI revolution" is a structural fact. Thinking you are "using AI" with only one layer in place gets you only half the effect.
Isomorphism with the Printing Revolution
History offers a structurally isomorphic case. The printing revolution was also a two-layer simultaneous change.
| Layer | Old | New |
|---|---|---|
| Printing technology | Handwritten manuscripts (monasteries) | Movable-type printing |
| Language substrate | Latin (clergy only) | Vernacular languages (general public) |
Movable type alone, with Latin retained, would have amounted to efficiency gains inside the Church. The vernacular alone, with manuscripts retained, would have reached only pockets of local enlightenment. Because both layers arrived together, the Renaissance, the Reformation, and the Scientific Revolution cascaded in sequence. Ordinary citizens could read books written in their own language.
The AI revolution is isomorphic. LLMs alone limit impact to efficiency gains for engineers. Python's new substrate alone remains a specialist art for data scientists. Because both layers arrived together, non-specialists became able to do structured work in natural language. That is the precise meaning of "AI-native work."
Why So Many People Miss This Essence
There is a clear reason why the received view tends toward "AI revolution = the arrival of LLMs":
LLMs are visible: ChatGPT's chat interface, Claude's web UI — tangible, touchable, talked about. The evolution of new types is invisible: The change in which DataFrame, Parquet, JSON, and Markdown are handled as types is happening in the engineer's workspace. It does not become news.
Yet it is the invisible Layer 2 that is the foundation making the revolution general. Because Python treats dict, list, DataFrame, json, yaml, pl.DataFrame, markdown, and pandas as first-class types, LLM output works as-is.
In languages that stopped at Stage 3 — Java, C# — every piece of LLM output must be translated into pre-defined classes. That is not "using AI"; it is "using AI to assist the labor of translating AI output." You are not standing inside the revolution.
The Choice to Equip Both Layers
In practice, equipping both layers requires holding all three of the following simultaneously:
LLM → Claude, GPT, Gemini (converts natural language into structured forms)
Language → Python (handles new types directly)
Substrate → Markdown, DataFrame, JSON, Parquet, SQLite (formats for execution and storage)
With all three in place, work flows in a single stream from natural-language instruction to execution. Remove any one of them and translation labor appears at the gap, breaking the flow.
Microsoft 365 + Copilot does not have all three elements:
- LLM: present (GPT-4-class via Azure)
- Language: Excel formulas, VBA, limited Python (cloud-confined)
- Substrate: .xlsx, .docx, .pptx (binary, AI-non-native formats)
As a result, Copilot output gets stuffed into Excel cells and format conversion runs every time. The structure cannot ride the AI revolution. This is another manifestation of the same structural problem as "Microsoft's Collapse" in the previous chapter.
Conclusion — Only Those Who Have Both Layers Can Stand Inside the Revolution
The essence of the AI revolution is a two-layer simultaneous change: the co-evolution of LLMs and the language and substrate that receive their output.
People who lack both layers — for example, "Excel + Copilot," "Word + Copilot," "Outlook + Copilot" — are experiencing only half the revolution. Translation labor remains intact.
People who have both layers — "Claude + Python + Markdown/DataFrame/JSON/Parquet" — are standing inside the revolution. They can work in a single flow from natural language to execution.
The AI revolution is not only about LLMs.
The layer in which LLMs became able to convert natural language into structured forms.
The layer in which languages became able to treat the AI-native substrate as first-class types.
It is the simultaneous arrival of both that constitutes the revolution.
With only one layer, you cannot stand inside it.
The next chapter examines Layer 2 — the evolution of types in programming languages — in detail. Why Python won, and why C#/Java were left behind as "half-way languages." The structural reasons will be made clear.