Jonathon's AI Wiki

Skill Systems — Orchestrator + Child Skill Chaining Pattern (Agentic Academy)

9 min read

Source: raw/Skill_Chaining_in_Claude_OS_is_INSANE_Don_t_Fall_Behind.md — YouTube tutorial RrMTtG1ZccI, presumed Agentic Academy / Ben channel (cross-references “Aentic Academy”, “skill systems”, “AI accelerator” — matches voice + commercial pitches in claude-code-memory-architecture-comparison and ben-five-skill-aios-setup).

A correctness argument for skill systems — the orchestrator-plus-child-skill pattern — against the two opposing failure modes most builders hit when scaling Claude Code skills. Mistake 1: skills in isolation, where the human manually chains outputs from skill A into skill B. Mistake 2: mega-skills that fold the entire end-to-end workflow into one giant SKILL.md. The middle path — small focused modular skills wired together via an orchestrator skill — is what unlocks compounding leverage on Claude Code as an agentic OS.

Key Takeaways

Why skills are the part of the architecture that compounds

The video opens with a thesis about what Anthropic will and won’t solve over the next ~6 months. Eight of nine common Claude Code limitations (context recall, memory, scheduling, output separation, mobile/Telegram access, dashboards) will get fixed by Anthropic directly — Routines, scheduled tasks, agents view, Channels, Dispatch are all moving fast. The one limitation Anthropic cannot solve is producing the exact output your specific business needs — your copywriting voice, client onboarding flow, meta-ads composition style. That’s what skills are for, and that’s why investing time in skill architecture (not dashboards, not custom UIs) is the only place where work compounds.

“Skills are how you turn a generalist into a specialist. They’re how you take Claude from good-enough out of the box to indistinguishable from how you’d actually do it yourself.”

Mistake 1 — Skills in isolation

  • You download a copywriting skill → ask Claude to write a LinkedIn post → copy the draft → ask Claude to schedule it with a separate scheduling skill.
  • You are the intermediary. Progress is no better than ChatGPT prompt-by-prompt.
  • Lost leverage: no autonomy, no compounding, manual chaining is the bottleneck.

Mistake 2 — Mega-skills

  • Overcorrect to mistake 1: a single SKILL.md that handles research + writing + repurposing + scheduling + posting end-to-end.
  • Three things you lose:
    1. Modularity. Copywriting logic is locked inside one flow — can’t reuse it for emails, newsletters, landing pages.
    2. Maintainability. Want to tweak copy voice? Now you have to edit it inside the email flow, newsletter flow, landing flow, social flow — each pigeonholes its own copy of the same logic.
    3. Progressive disclosure. Anthropic designed skills to load only the context that’s needed. Mega-skills load too much at once → measurable quality drop.

The right answer — skill systems (orchestrator + child skills)

  • Skill system = an orchestrator skill with an instruction set wired around multiple smaller skills.
  • Orchestrator = the brain. Child skills = modular components that do the actual work and pass results back.
  • Same pattern as Claude Code subagents — main instance orchestrates, child agents take a slice of context and return outputs.
  • Build small, focused, reusable skills designed from day one to compose. Then write orchestrator skills that chain them end-to-end to achieve a business goal.

Real example — four skill systems sharing four skills

The video diagrams the Agentic Academy’s own production setup:

Four skill systems:

  1. Video clip short-form — upload video → 5 short-form clips ready to post.
  2. Video to article — upload video → long-form lead-magnet article.
  3. Social carousel — source material → multi-step LinkedIn carousel.
  4. Slide generation — topic → full interactive HTML slide deck.

Four shared child skills across all four systems:

  • Brand-voice / humanizing rewrite
  • Fact-checking (verify claims + figures)
  • (Two unnamed in transcript) — likely transcription + outline-extraction based on context

Plus per-system bespoke skills — each system has its own pipeline-specific skill that only it uses.

Compounding payoff

When the orchestrator pattern is in place: improve the fact-checker skill once → every system that uses it gets better automatically. Update the humanizing skill once → email, social, carousel, slide all get the same upgrade. This is the leverage Anthropic can’t ship to you — you build it once and it compounds.

Onboarding inside skill systems

Each shipped skill system has a one-time onboarding flow. Slide-generator example: asks user about style preferences (can pull from existing design system), Mac Slides preference, auto-export to PDF, auto-open in browser. Config persists. User runs the system afterward without re-prompting these decisions.

Skill system creator

Meta-skill that:

  1. Reads the user’s existing skills folder
  2. Asks what end-to-end workflow they want
  3. Searches existing skills to find reuse candidates / adapt candidates
  4. Packages the orchestrator + identified child skills into a deployable bundle
  5. Ships as a one-line install — same install pattern they use to deploy systems to community members

Community implementation — Claude as manager + cheaper-model workers (May 2026)

[Reddit signal — r/ClaudeCode 2026-05-18] Source: raw/reddit-1tgfm1x.md (153 score / 39 comments, OP 01zhas, Showcase flair).

A first-party operator describes a working orchestrator-child setup using Claude as manager and MiniMax + Kimi as worker agents, with Linear as the task pool and tmux as the control room. The pattern landed at a company with ~100 websites where headcount couldn’t scale; AI agents became the scaling mechanism.

Architecture (sketched in the post body):

  • Claude (orchestrator). Generates task briefs, manages Linear queue, assigns tasks to worker agents, reviews results, decides whether to continue or escalate.
  • MiniMax (lightweight worker). Small fixes, cleanup, simple scripts, documentation, minor refactors.
  • Kimi (heavier worker). “Sonnet Medium-level for heavier coding tasks: deeper refactors, more context-heavy changes, debugging, implementation work.”
  • Linear (source of truth). All tasks live in Linear; status transitions (Todo → In Progress → Done) drive the loop.
  • tmux (live control room). A dwh-launch-grid.sh opens a tmux grid with N panes; each pane runs dwh-auto-agent.sh — the per-agent autonomous loop.
  • Locks (duplicate protection). .agent-locks/DWH-168.lock files prevent two agents from grabbing the same task. Locks expire after 1 hour so crashed agents don’t permanently park tasks.
  • Logs (audit trail). Every agent action logs to its tmux pane.

Per-agent loop (from the post): pick task from Linear → create lock → move to In Progress → collect context → run AI coding agent → test / commit → parse result → update Linear → release lock → take next task.

Why it validates the skill-systems pattern.

  • Orchestrator-child shape with cheaper workers. Claude writes “very clear task briefs: goal, context, constraints, files to check, expected output, DoD, and what not to touch.” That’s the orchestrator’s job. The workers don’t invent architecture or guess the plan — they execute a precise task. Same principle as orchestrator-skill writing precise child-skill invocations.
  • Compounding payoff. Once the brief format is dialed in, every worker run benefits without re-writing the prompts. “Even smaller agents become much more effective.” That’s the same compounding leverage the Agentic Academy diagram describes for child skills.
  • Lightweight orchestration, not heavyweight framework. “It is not a complex orchestrator. It is mostly shell scripts, tmux, Linear statuses, lock files, logs, and clear conventions.” Matches the skill-systems thesis: avoid mega-skills, favor small composable units wired through clear conventions.

Open patterns to extract:

  • Agents create Obsidian Vault Docs in the filesystem as a reference layer they can re-read when context shifts. Skill-systems analog: shared notebook between orchestrator and child skills, persisted to disk.
  • Lock-file pattern is generalizable beyond multi-agent code grids — any time multiple orchestrator instances might pick the same child task, file-lock-with-1-hour-TTL is a robust primitive.

The post doesn’t publish a repo — the architecture is a description, not a fork-and-run. Operators building toward this pattern will need to wire the shell scripts themselves. Validation signal that the orchestrator-child thesis is being independently rediscovered, not just promulgated by the Agentic Academy creator.

Open Questions

  • “Aentic Academy” formal name + URL — the transcript spells it “Aentic” multiple times (likely “Agentic” misheard by ASR). The branded community + commercial offering is the publish destination for shipped skill systems and the skill-system-creator meta-skill.
  • Two unnamed shared child skills — the diagram shows four shared skills across the four systems; transcript names only fact-checker and humanizing. Likely transcription + outline.
  • One-line install script format — pattern referenced but not shown in transcript. Likely a bash <(curl …) style installer that drops the orchestrator + child skill files into .claude/skills/.
  • Skill system creator availability — described as in-development / inside the paid Agentic Academy community. Not confirmed as public.

Try It

  1. Audit your current skills folder. For each skill, ask: is this isolated (Mistake 1), is this a mega-skill (Mistake 2), or is this a focused composable unit?
  2. Extract one shared child skill. Pick a function that appears in 2+ skills (e.g., brand-voice rewrite, fact-check, transcription) and pull it out as its own SKILL.md. Update the parent skills to reference it.
  3. Write a simple orchestrator. Create one new skill (e.g., social-carousel) whose SKILL.md says “first call X, then Y, then Z” — let Claude handle the chaining. Don’t fold logic from X/Y/Z into the orchestrator.
  4. Build for the second system. Reuse the same X/Y/Z child skills in a different orchestrator (e.g., video-to-article). When you successfully reuse, you’ve validated the modular pattern.
  5. Run the compounding test. Edit one child skill → confirm every orchestrator system benefits without further edits. If not, the parent skills still embed local copies — refactor.
  6. Pair with skill creator. Use Anthropic’s official skill-creator skill (see skill-creator) to scaffold child skills from rough descriptions, then wire them up manually into orchestrators.

Graph View

Backlinks