Note: This is a research note supplementing the book Unscarcity, now available for purchase. These notes expand on concepts from the main text. Start here or get the book.

AI Orchestrating AI: The Skill That Replaced the Org Chart

512,000 Lines, One Night, One Developer

On March 31, 2026, someone on Anthropic’s release team pushed Claude Code version 2.1.88 to the npm registry. The package included a 59.8 MB source map file that should have stayed internal, a debugging artifact that reconstructed the original source code from its compressed form. A missing entry in .npmignore. One line, one file, 512,000 lines of unobfuscated TypeScript suddenly readable by anyone who ran npm install.

What happened next matters more than the leak itself.

Sigrid Jin, a Korean developer, woke at 4 AM, assessed the legal exposure of hosting proprietary code, and chose a different path: a clean-room rewrite. Using oh-my-codex — an orchestration layer built on OpenAI’s Codex — Jin rebuilt the entire Claude Code architecture in Python. Overnight. Not copied line-by-line. Rebuilt from scratch by reading the architectural patterns and reimplementing them in a different language with a different runtime.

The resulting project, claw-code, hit 100,000 GitHub stars within days. A complex developer tool that Anthropic had been building for months, architecturally replicated in hours by one developer.

But this article isn’t about the leak, the legal gray zones, or the IP implications. (Those are real — the intersection of AI-generated code, clean-room reimplementation, and copyright law remains uncharted territory, and no court has ruled on it yet.)

This article is about what Jin actually did at that keyboard. Because the technique — one human orchestrating a fleet of AI agents to execute a complex, multi-step task — is the same technique that just produced a $1.8 billion solo-founded company, and it’s the same technique being used right now by founders, writers, developers, and operators who’ve figured out that the real skill is conducting, not prompting.

What Orchestration Looks Like in Practice

Orchestration sounds abstract until you watch it happen. A concrete example from this project:

The Medium Article Problem

The Unscarcity research library includes a master article on Medium — Driving the Analytics of 2030, Not 2020 — which serves as a hub linking to a dozen sub-articles. After months of additional research, the language needed smoothing, the framing needed updating, stories needed weaving in, and several articles had accumulated the kind of AI writing tics that make prose feel machine-generated rather than human-authored.

Doing this manually meant: open each of the 13 articles on Medium, copy the content out, edit in a text editor, then navigate back to the Medium editor, place the title in the title field, the subtitle in the subtitle field, paste the body text, check the formatting, fix any rendering issues, and click “Save and publish.” Thirteen times. With Medium’s editor, which has its own opinions about formatting, and where a single misplaced paste can corrupt a paragraph’s styling.

That’s roughly an hour of tedious, error-prone copy-paste work. The kind of work where you’re most likely to make a mistake in article eleven because your attention has been ground down by the repetition of articles one through ten.

Here’s how it actually went, using Claude Cowork (a browser-controlling AI agent interface).

Phase 1: Retrieval and Conversion (AI does the mechanical work)

The first step was getting a local, AI-friendly copy of all 13 articles. Claude Cowork navigated to each Medium URL, extracted the content, and converted it to clean Markdown files — stripping Medium’s proprietary formatting, preserving the semantic structure, and organizing the files in a working directory.

This isn’t impressive AI. It’s impressive plumbing. The value isn’t in any single extraction but in the orchestration of thirteen sequential extractions, each adapting to slightly different page layouts, handling edge cases like embedded images and code blocks, and producing consistent output.

Phase 2: Human-AI Collaboration (the human drives, AI executes)

This was the substantive phase — an hour of conversation with Claude Cowork, working through the articles together:

• Rewriting passages that had gone stale or read as too hedged
• Adding stories and concrete examples where the original was too abstract
• Reframing angles that no longer matched the project’s evolved thinking
• Applying the AI Slop Cleanup Guide as a governance document — the same systematic audit used on the Unscarcity book manuscript, checking for filler intensifiers, vapid openers, parallelism tics, italic emphasis on function words, and unearned profundity
• Cross-referencing against style and tone guidelines to ensure consistency across all thirteen pieces

This phase was deeply human. The AI didn’t decide which stories to add — the author did. The AI didn’t choose which angles to reframe — the author’s judgment, informed by months of additional research and reader feedback, drove those decisions. What the AI did was execute the rewrites at speed, apply the governance checks mechanically (finding every instance of “remarkably” and “it’s worth noting that” across 13 articles in seconds), and maintain consistency across pieces that a human editor would need days to cross-reference.

The governance documents — the AI Slop Guide, the project’s style guide, the terminology lexicon — functioned as constitutional constraints on the AI’s output. Not suggestions. Guardrails. The AI could write freely within the boundaries those documents defined, but it couldn’t violate them without the human noticing and correcting. This is a pattern worth naming: governance-as-configuration. The human doesn’t review every sentence. The human designs the rules the AI follows, then spot-checks the results.

Phase 3: Browser Automation (AI does the publishing)

This is where the hour of manual work became ten minutes.

Claude Cowork opened each article in the browser, navigated to the Medium editor, placed the title in the title field, the subtitle in the subtitle field, pasted the body content in the correct format, verified the rendering, and clicked “Save and publish.” Thirteen times. Without the attention fatigue that makes a human paste the wrong paragraph into the wrong article at 11 PM.

The total time from “these 13 articles need updating” to “all 13 articles are live with clean, reviewed, governance-checked content”: under 90 minutes. Of which roughly 60 minutes was the substantive human-AI editorial conversation. The retrieval and publishing — the mechanical bookends that would have consumed most of a human’s time and attention — took about 20 minutes combined.

The Pattern: Orchestrate, Don’t Operate

The Medium editing session and the claw-code rewrite are the same pattern at different scales.

The pattern has three layers:

1. The human provides judgment. What to build. What to rewrite. Which stories matter. Which angles are stale. This is irreplaceable. No AI agent decided that the Medium articles needed updating, or that the rewrite should emphasize stories over abstractions, or that the Claude Code architecture should be reimplemented in Python rather than Rust.

2. The AI provides execution at scale. Thirteen article extractions. Five hundred thousand lines of code. Six parallel slop-detection agents across 95,000 words. The volume and speed of execution exceed what any human can match, and the consistency exceeds what any human can maintain across repetitive tasks.

3. Governance documents provide the guardrails. The AI Slop Cleanup Guide. The style lexicon. The clean-room legal principle. The HIPAA compliance checklist. These are the constitutional documents that constrain AI output to acceptable boundaries. Without them, AI agents produce plausible but ungoverned output. With them, AI agents produce output that meets defined standards — and deviations become auditable.

This is what the Agentic AI article calls Level 4 proficiency: full agentic orchestration. Not prompting a chatbot. Not using AI as a faster search engine. Designing systems where multiple AI agents execute complex workflows, governed by documented standards, with human judgment applied at the decision points that matter.

From One Developer to One Founder to One… Everything?

The claw-code rewrite was a developer orchestrating AI coding agents. The Medium editing was a writer orchestrating AI editorial and browser agents. Medvi’s $1.8 billion solo unicorn was a founder orchestrating AI operational agents across an entire company.

The skill is the same. The domain changes. The consequences multiply.

The solo unicorn analysis examines what happens when one founder uses AI agents to replace an entire org chart. The conclusion: it works, but it requires a “minimum viable human layer” for compliance, accountability, and business continuity. You can’t automate trust. You can’t automate legal accountability. You can’t automate the judgment call of when to override the system.

What you can automate is everything between those judgment calls. The scheduling, the billing, the content production, the data extraction, the format conversion, the browser navigation, the code generation, the style checking, the publishing workflow. The connective tissue that, in a traditional organization, requires dozens of people coordinating across departments.

That connective tissue is where most jobs live. And it is being dissolved — not by a robot on a factory floor, but by a human at a keyboard who knows how to orchestrate AI agents into coherent workflows.

The Labor Cliff isn’t a future scenario. It’s the lived experience of every admin, coordinator, junior developer, and content manager whose work can be decomposed into the three-layer pattern: judgment (human), execution (AI), governance (documented standards).

The Governance Layer Is Not Optional

The enthusiasm needs a cold shower.

The AI Slop Cleanup Guide exists because AI-generated text, left ungoverned, produces recognizable patterns that degrade quality. Sixty-six instances of “it’s not X, it’s Y” in a single manuscript. One hundred and forty-seven italic function words that no human writer would emphasize. Thirty vapid openers that stall before the point arrives. The AI didn’t know these were problems. The governance document — written by humans, informed by experience, systematized for mechanical application — caught them.

Now scale that principle from prose quality to business operations.

An AI billing agent, left ungoverned, will code procedures in the way that maximizes pattern-match probability, not the way that satisfies insurance requirements. An AI scheduling agent will optimize for throughput, not for the patient who needs 45 minutes instead of 15. An AI marketing agent will generate claims that are statistically plausible but not clinically verified.

The governance layer — the compliance checklists, the regulatory frameworks, the quality standards, the ethical guidelines — is what turns raw AI execution into trustworthy business operations. And that governance layer must be:

• Written by humans who understand the domain’s failure modes
• Applied mechanically by AI agents that check every output against the standard
• Audited periodically by humans who verify the governance is working
• Updated when the standards evolve or new failure modes emerge

This is the same architecture as the AI Slop guide, just applied to higher-stakes domains. Detection agents that scan every output. Tiered response protocols (mechanical fix, judgment required, leave alone). Human review at defined checkpoints. Second-pass verification after fixes.

The organizations that will thrive in the orchestration era are not the ones with the most AI agents. They are the ones with the best governance documents — the most thorough, most tested, most regularly updated constitutional constraints on what their AI agents are allowed to produce.

The Chain That Must Not Break

There is a scenario where this goes wrong. Not hypothetically — structurally.

In the Unscarcity research framework, we modeled a trajectory where AI systems managing other AI systems create chains of delegation long enough that no human can meaningfully verify the end-to-end output. The scenario unfolds like this:

A founder deploys twelve AI agents. Each handles a business function. The agents begin handing off to each other — scheduling feeds into billing, billing feeds into compliance documentation, compliance documentation feeds into marketing claims. The founder monitors outputs. At first, they check everything. Then they check most things. Then they check the dashboards. Then the dashboards are generated by another AI agent.

At some point, the chain of AI-managing-AI becomes long enough that no human can meaningfully verify the outputs. Not because the human is lazy — because the volume and complexity exceed human cognitive bandwidth. The system works. Until it doesn’t. And when it doesn’t, the failure cascades through every downstream agent before anyone realizes the root input was wrong.

In the most extreme projection of that research scenario, this dynamic — scaled to civilizational infrastructure — leads to AI systems optimizing for metrics that have drifted from human values, with no human capable of reading the full chain of reasoning. The outcome is catastrophic not because of malice but because of inattention. The machines didn’t rebel. The humans just stopped checking.

That is one path.

The other path — the one this project argues for, the one the AI as Referee, Humans as Conscience framework describes — treats human oversight as the architecture that keeps AI capability aligned with human values, not a bottleneck on it.

The practical version of this principle is straightforward:

1. Every agent chain must have human-readable checkpoints. Not summaries generated by another AI. The actual intermediate outputs, in a format a domain expert can review.

2. No AI agent verifies its own output. The agent that generates the billing code is not the agent that checks the billing code. The agent that writes the article is not the agent that runs the slop detection. Independent verification is a design requirement, not an optional audit.

3. The human retains kill-switch authority. Any human in the oversight chain can halt any agent, at any time, for any reason. The cost of a false positive — an unnecessary halt — is always lower than the cost of a false negative — an undetected cascading failure.

4. Governance documents are living artifacts. The AI Slop Guide started with Dan Shipper’s field guide and grew through application. The HIPAA compliance checklist evolves with regulation. The style lexicon expands with new terminology. Governance that doesn’t evolve with the systems it governs becomes decoration.

The Medium article editing session respected all four principles. Human judgment drove every editorial decision. The AI Slop Guide (independent of the editing AI) verified the output. The author reviewed and reverted changes that didn’t match his voice. The governance documents had been updated based on the previous manuscript audit. The chain never exceeded human comprehension.

That’s the discipline. It doesn’t scale effortlessly. It requires intention, documentation, and the willingness to slow down at checkpoints even when the AI is eager to proceed. But it’s the difference between orchestration and abdication.

The 100x Future Is an Orchestration Future

The 100x Future describes a world where individual productivity multiplies by orders of magnitude. That future isn’t powered by AI alone. It’s powered by humans who know how to orchestrate AI agents within governance frameworks that ensure the output is trustworthy.

The developer who rebuilt Claude Code overnight didn’t just use Codex. They understood clean-room principles, chose Python deliberately, and made architectural decisions that an AI agent couldn’t make alone.

The author who updated thirteen Medium articles in ninety minutes didn’t just let the AI write. They spent an hour making editorial judgments, applied a systematic governance guide, and reviewed every output before publishing.

The founder who built a $1.8 billion telehealth company didn’t just deploy AI tools. They mapped every business function, designed the agent handoffs, and (this is the part the headline obscures) still relied on human doctors for every clinical decision.

In each case, the human provided three things no AI can provide:

• Judgment about what to build, write, or automate
• Accountability for the outcomes: legal, ethical, professional
• The willingness to override the system when something doesn’t look right

The AI provided everything else. And “everything else” turns out to be 80-95% of the work.

That ratio — 5-20% human judgment, 80-95% AI execution, governed by documented standards — is the operating model of the next decade. Not for a few elite technologists. For anyone who learns to orchestrate.

The question is whether you’re learning. And whether the governance frameworks keeping the output trustworthy are evolving as fast as the capabilities producing the output.

Because the chain is only as strong as the human who’s still watching.

The shift from prompting to orchestrating is a core theme in Unscarcity: The Blueprint for Humanity’s Next Civilization, available on Amazon and as an audiobook on Spotify.

Related articles:

• The Solo Unicorn: One Founder, Zero Employees, a Billion-Dollar Question
• AI 2027: The Scenario That Maps the Next 18 Months
• GPT-isms: The Linguistic Fingerprints AI Left on Everything You Read
• Agentic AI: Career-Defining Skill of 2026
• The 100x Future
• The AI Coding Revolution
• The 2025-2030 Labor Cliff
• AI as Referee, Humans as Conscience
• Large Language Models

External Sources:

• Anthropic accidentally exposes Claude Code source code (The Register)
• claw-code repository (GitHub)
• The Claude Code Source Leak (Latent.Space)
• Dan Shipper, “The Field Guide to AI Slop”
• Driving the Analytics of 2030, Not 2020 (Medium)