Skip to main content

​
The Literacy of AI Era

Every technological era introduces a structural pattern. Those who understand it build the systems. Those who don’t, use them.

​
The Pattern of Each Era

Era          What Changed           The Literacy
──────────   ───────────────────    ─────────────────────────────────
1970s        Personal computers     "How do I save and find my files?"
1980s        Networking             "How do machines talk to each other?"
1990s        The Web                "What is a client? What is a server?"
2000s        Cloud                  "Where does my code run?"
2010s        Containers             "How do I package and orchestrate services?"
2020s        AI assistants          "How do I prompt an AI to do what I want?"
2025+        AI networks            "How does AI organize AI?"
Each transition felt overwhelming at the time. Then it became obvious. “Files and folders” was once a new concept. Now five-year-olds understand it. “Client-server” was once specialized knowledge. Now it’s a whiteboard interview question. “Containers and Kubernetes” was once DevOps magic. Now it’s infrastructure 101. “AI organizing AI” is the next one. It feels new now. It will feel obvious soon. The question is whether you understand it before or after it becomes standard.

​
What Changed in 2025

Before 2025, AI was a tool. You talked to one AI. It helped you. 
Human → AI → result
Simple. One direction. One layer. The literacy was prompting — how to ask clearly. After 2025, AI became a network. AIs talk to AIs. They form teams. They spawn sub-teams. They operate across machines. 
Human → AI → AI → AI → ...
              ↕    ↕
             AI    AI → AI → AI
                         ↕
                        AI
The literacy is no longer “how to talk to AI.” It’s “how AI talks to AI, and how to design that conversation.”

​
The Two Levels of Understanding

​
Level 1: User

"Claude, build this feature."
[wait]
"Here's your PR."
You don’t need to know that 15 agents across 3 machines worked on it. You don’t need to know that research was parallel and implementation was sequential. You don’t need to know that one agent spawned its own sub-team. This is fine. This is using a car without understanding the engine. Most people will stay here. That’s okay.

​
Level 2: Designer

"This task needs:
 - 5 parallel research agents (cheap model, sandboxed)
 - 1 synthesis agent (expensive model, reads all research)
 - 2 implementation agents (expensive model, worktree-isolated)
 - 3 verification agents (medium model, sandboxed)
 - The implementation agents should be able to spawn sub-teams
 - Research runs on the GPU server, implementation on laptop
 - If Claude API goes down, fall back to Gemini"
This is designing the engine. You need to understand:
  • Parallel vs sequential: when to fan out, when to converge
  • Model routing: which AI for which task, and why
  • Isolation: worktree for file safety, sandbox for process safety
  • Recursion: when a worker should become an orchestrator
  • Distribution: which machine for which workload
  • Failure: what happens when a provider goes down
This is the ASURA-SENJU pattern. This is the literacy.

​
The Fractal

The core insight is recursive: 
An orchestrator (ASURA) manages workers (SENJU).
Any worker can become an orchestrator.
That orchestrator manages its own workers.
Any of those workers can become an orchestrator.
...
This is a fractal. The same pattern at every level. Once you see it, you see it everywhere:
  • A company CEO delegates to VPs. VPs delegate to managers. Managers delegate to engineers.
  • A conductor leads sections. Section leaders lead musicians. Each musician interprets their part.
  • A function calls functions. Those functions call functions. Each function has its own scope.
The AI version:
  • An ASURA dispatches SENJU workers. Workers become ASURAs. They dispatch their own workers.
The pattern is always the same. The depth changes. Understanding this fractal means you can design AI systems at any depth. Without understanding it, you’re stuck at depth 1 — one AI doing one thing.

​
What the Literate Person Sees

An illiterate person sees: 
"I asked Claude to build a feature. It took 5 minutes."
A literate person sees: 
"A connector.json defined a 4-phase pipeline.
 Phase 1 fanned out 5 Haiku workers for parallel research.
 Phase 2 used Opus to synthesize findings into a spec.
 Phase 3 used Opus in a worktree to implement the spec.
 Phase 3's worker decided the task was too large and
   spawned 3 sub-workers, each in their own worktree.
 Phase 4 used 3 Sonnet workers to verify, sandboxed.
 Total: 13 agents, 3 levels deep, 2 models, ~$4 in API cost.
 The $4 replaced ~8 hours of human work."
Both got the same result. One understands what happened. The other doesn’t. The one who understands can:
  • Optimize the pipeline (fewer workers where it doesn’t help)
  • Debug failures (which phase broke, which agent failed)
  • Design new pipelines for new problems
  • Teach others to do the same

​
The Vocabulary

Like every literacy, this one has vocabulary:
TermMeaning
ASURAOrchestrator role — manages phases and synthesizes
SENJUWorker role — executes in parallel
PhaseSequential step in a pipeline
Fan-outDispatching N workers simultaneously
Fan-inCollecting results from N workers
ScratchpadShared knowledge between phases/levels
MailboxMessage passing between agents
WorktreeFile-isolated workspace per agent
SandboxProcess-isolated execution environment
Dimensional growthAdding depth/direction/machines to the network
Recursive stepWhen a SENJU becomes an ASURA
You don’t need all of these to start. “ASURA orchestrates, SENJU executes, any SENJU can become ASURA” covers 80% of it.

​
Where to Start

Step 1: Run one AI.
        You already know this.

Step 2: Run two AIs on the same task.
        Claude reviews what Codex wrote, or vice versa.
        → You learn parallel execution.

Step 3: Chain them.
        Research → implement → verify.
        → You learn sequential phases (ASURA pattern).

Step 4: Combine parallel and sequential.
        5 researchers → 1 synthesizer → 2 implementers → 3 verifiers.
        → You learn ASURA + SENJU together.

Step 5: Let a worker spawn its own team.
        The implementer decides the task is too big and creates sub-workers.
        → You learn the recursive step.

Step 6: Span machines.
        Research on GPU server, implementation on laptop.
        → You learn distributed orchestration.

Step 7: Design from scratch.
        Look at a problem and instinctively see the ASURA-SENJU structure.
        → You are literate.
Each step is a connector.json. Each step builds on the previous. The tool teaches the literacy.

​
The Bet

Every era’s literacy seemed optional at first and essential in retrospect. 
1995: "Why would I need to understand client-server? I just use the web."
2005: "Why would I need to understand APIs? I just use apps."
2015: "Why would I need to understand containers? I just deploy code."
2025: "Why would I need to understand AI orchestration? I just use Claude."

2030: "How did anyone ship software without understanding fractal orchestration?"
This is the bet connector.json is making. Not that everyone will need this literacy — but that everyone who builds with AI will.