Big Idea

The argument in one line.

Adding context_fork to any Claude Code skill file creates an orchestrator that runs multiple sub-skills sequentially, with each step reading the previous step output, collapsing a five-command workflow into a single slash command.

Who This Is For

Read if. Skip if.

READ IF YOU ARE…

You already use Claude Code slash commands and have built at least two or three individual skill files.
You run multi-step workflows -- research, then copy, then email -- where you manually paste outputs from one step into the next.
You use Obsidian or any local note system and want topic-level synthesis on demand.
You want to reduce the number of decisions you make during a production run without going fully agentic.

SKIP IF…

You have never written a Claude Code SKILL.md file -- the demo assumes that baseline.
You want a zero-to-hero Claude Code setup guide; this is a single advanced feature, not an onboarding video.

TL;DR

The full version, fast.

Claude Code skills can orchestrate other skills when you add context_fork to the frontmatter of a parent skill file. The orchestrator runs each named sub-skill in its own context window, each step reads from a shared output folder, and the final step synthesizes everything into one artifact. The demo shows a five-skill launch pipeline producing a market scan, sales page, email sequence, social posts, and a PDF brief from one command, plus a three-skill Obsidian brain-brief that retrieves vault notes, extracts insights, and synthesizes a topic summary in about sixty seconds.

Free for members

Chat with this breakdown — free.

Sign in and you get 23 free chat messages on us — ask for the hook, quote a framework, find the exact transcript moment, generate a markdown action plan. Bring your own key when you want unlimited.

Create a free account →

Chapters

Where the time goes.

00:00 – 00:40

01 · Cold open -- the workshop question

Sets up the discovery story: asked at a workshop whether skills can chain, said no, went back and found the answer. Promises to show the most powerful way to use Claude Code skills that nobody is talking about.

00:40 – 02:45

02 · Live demo -- launch offer chain (5 skills)

Runs /launch-offer with a workshop pitch as the input. Watches in real time as Claude executes market-scan, sales-page, email-sequence, social-announce, and launch-brief in sequence. Each step completes and immediately triggers the next.

02:45 – 03:11

03 · Final output PDF walkthrough

Opens the consolidated launch brief PDF. Shows executive summary, pricing tiers, competitive landscape, gaps, sales copy, email sequence, social media copy -- all generated from one command.

03:11 – 03:19

04 · Second brain demo teaser

Brief mention of the brain-brief chain to come later in the video.

03:19 – 04:34

05 · Sponsor -- Claude Code Magic Course (living course)

Pitches a living course in his skool community that updates as Claude Code changes. Framed as the responsible alternative to static courses that are obsolete before shipping.

04:34 – 05:28

06 · Why it matters -- the glue problem

Explains the problem: each skill is useful alone, but the creator is the glue between them. Chaining preserves human-in-the-loop nuance while removing the copy-paste steps. Chained skills produce contextually better output because each step is aware of preceding outputs.

05:28 – 07:29

07 · How it works -- context_fork and the orchestrator SKILL.md

Shows the actual SKILL.md file in the terminal. Walks through the frontmatter: name, description, context_fork, agent, allowed-tools. Then the body: Step 1 runs /market-scan, Step 2 /sales-page, etc. The folder is the shared brain. Walks the data flow diagram.

07:29 – 08:54

08 · Live demo -- brain brief chain (3 skills, Obsidian)

Runs /brain-brief with a query about Claude Code workshop structure. Shows /brain-search combing the Obsidian vault, /brain-extract pulling key insights, /brain-synthesize writing the comprehensive brief. 33 relevant notes found, 25 key insights extracted, full output in ~60 seconds.

08:54 – 09:31

09 · How to build your own

Recap: (1) keep building individual skills normally, (2) when you see leverage, create an orchestrator skill with context_fork, (3) list the sub-skill commands in order and specify what output to return.

09:31 – 10:29

10 · Final CTA + outro

Points to the free Skill Chaining Kit (link 2 in description) and the Claude Code Magic Course community (link 1). Standard like/comment/subscribe outro.

Atomic Insights

Lines worth screenshotting.

context_fork is one line in a skill file frontmatter that runs the skill in its own context window -- separate brain, narrow focus, single output.
Each chained skill reads from a shared output folder rather than from the chat context, so long pipelines do not hit context limits.
You are already the glue between your skills -- skill chaining formalizes that glue into a file so Claude runs it without you in the loop.
A pseudo-army of skills beats a real army of agents when you need nuance and human-in-the-loop checkpoints at the end, not full autonomy.
The orchestrator SKILL.md is just markdown -- no code, no framework. Step 1: run /market-scan. Step 2: run /sales-page. That is the entire syntax.
Obsidian plus three chained skills (search, extract, synthesize) replaces an afternoon of manual note review with a sixty-second command.
Skill chaining is not deterministic automation -- it preserves the human-in-the-loop while removing the copy-paste steps between commands.
The shared output folder is the context. Skill 1 writes market_scan.md; Skill 5 reads everything in the folder. No vector store required.
A living course that updates as Claude Code changes is the only responsible way to sell Claude Code education -- static courses are deprecated before they ship.
Each sub-skill stays useful on its own; the orchestrator only adds value at the junction points where you would otherwise be the bridge.

Takeaway

One line converts your skill library into a pipeline.

WHAT TO LEARN

context_fork is the missing abstraction between running one skill at a time and building full agents -- it chains your existing skill files into a sequence without any new code.

01Cold open -- the workshop question

A public mistake is a better hook than a public win -- admitting you were wrong in public, then correcting it, builds more trust than claiming expertise from the start.

02Live demo -- launch offer chain (5 skills)

Demo-first structure earns the explanation. Watching all five steps execute before any theory is explained gives the viewer a concrete mental model to attach the mechanics to.
Each step transition in the terminal output is the real proof. The value is not the PDF -- it is watching step 2 begin immediately when step 1 finishes, with no human prompt in between.

06Why it matters -- the glue problem

Name the tax before you offer the remedy. The glue problem -- manually bridging every skill output to the next skill input -- is the invisible cost most Claude Code users pay daily without realizing it.
The distinction between deterministic automation and human-in-the-loop orchestration is load-bearing. Skill chains are not bots -- they run without stopping, but with a human reviewing the end state.

07How it works -- context_fork and the orchestrator SKILL.md

context_fork is just a frontmatter field in a markdown file. The entire mechanism that feels magical is six words in a YAML header.
The data flow diagram (Skill 1 writes, Skill 2 reads 1+2, Skill 5 reads everything) reveals the design principle: the output folder is the only shared state. This is simpler and more debuggable than any database-backed agent memory.

08Live demo -- brain brief chain (3 skills, Obsidian)

The Obsidian demo generalizes the pattern beyond business use cases. Any large text corpus (notes, transcripts, emails) can be searched, extracted, and synthesized with three chained skills.
Using grep and glob as a CLI fallback means the brain-brief chain requires zero Obsidian plugins or API access -- just the vault folder on disk.

09How to build your own

The build sequence matters: individual skills first, orchestrator second. Trying to design the chain before the sub-skills exist produces brittle pipelines with no fallback when a step fails.

Glossary

Terms worth knowing.

context_fork: A single-line directive in a Claude Code SKILL.md frontmatter that runs the skill in its own isolated context window, separate from the main session. Enables skills to call other skills without polluting shared context.
orchestrator skill: A parent SKILL.md file whose body is a numbered list of sub-skill commands to execute in sequence. The orchestrator itself produces no content -- it coordinates the sub-skills and specifies what output to return at the end.
sub-skill: An individual slash command skill (e.g., /market-scan, /sales-page) that a parent orchestrator calls. Each sub-skill runs independently and writes its output to a shared folder the next sub-skill reads from.
shared output folder: A file-system directory that serves as the memory between chained skills. Skill 1 writes its output there; Skill 2 reads that file plus adds its own; by Skill 5, the folder contains the full pipeline output.
brain brief: The output of a three-skill Obsidian chain (search, extract, synthesize) that produces a comprehensive topic summary from vault notes on demand, triggered by a single slash command.

Resources

Things they pointed at.

03:19productClaude Code Magic Course (living course) ↗

03:19productEarly AI-dopters (skool community) ↗

07:29toolObsidian ↗

07:29channelAndrei Karpathy (cited for popularizing Obsidian)

10:02productSkill Chaining Kit (free) ↗

Quotables

Lines you could clip.

00:19

“There is one line that you can add to any skill that lets you execute a series of skills in sequence from one single source.”

The payoff line -- self-contained, specific, no setup needed.→ TikTok hook↗ Tweet quote

05:04

“Instead of using an army of agents, you are using a pseudo army of skills to create a cohesive output.”

Quotable contrast that positions the mechanism without jargon.→ IG reel cold open↗ Tweet quote

05:28

“Running it in that window gives it a separate context window, a narrow focus on running these all one after the other, and then bringing back the output, which is all you care about at the end of the day.”

Cleanly explains the mechanism and the user value in one breath.→ newsletter pull-quote↗ Tweet quote

09:31

“Continue building your skills as you have been on their own, but where it makes sense and where you see opportunities for leverage, you can then combine them into one unified super skill.”

Action instruction that respects the viewer already has skills.→ newsletter pull-quote↗ Tweet quote

The Script

Word for word.

Read-along

Don't just watch it. Burn it in.

See every word as it's spoken — crank it to 2× and still catch all of it. The same dual-channel trick behind Amazon's Kindle + Audible.

metaphorstory

I was giving a Claude code workshop the other week, and someone asked, can you change skills together? Meaning, can you run one skill that once it's done triggers another skill and another until you have one unified output from one single command? And initially, I said no.

But after going back and forth with Cloud Code and looking through the documentation, I realized I was wrong. There is one line that you can add to any skill that lets you execute a series of skills in sequence from one single source.

So in this video, I'm gonna show you the single most powerful way to use Claude code skills that nobody's talking about. Let's get into it. Alright.

So before we go into the how and the why, let's go through the what. Let's actually see it in action. So I have a series of commands now that are chained.

If I use this specific command, let's do launch offer. So this command is meant to take an idea, do market research on it, put together the sales copy for a landing page, and execute the entire funnel to give you the eighty twenty to get started.

So given that myself and my agency, prompt advisers, we give all kinds of workshops to Fortune 500 companies, SMBs on using Cloud Code and CoWork, I will do the following. So I'll go right here and I'll say, I wanna be able to create perfect premium workshops for Claude Code and Claude CoWork that we deliver to companies of any industry in any size.

So when we run this, right away, it should execute the first nested skill, which should be the market scanner. This will use the web search tool to go and see similar offers as of 2026.

So it's now gonna search through. And any moment now, there we go. It's reading the skill for launch offer, and we should see the first of the multiple skills executed.

So now that it briefed itself on all of the skills, it'll have to execute in sequence, it's running the first one, which is doing all of this web search as you can see here, cloud code workshops, pricing. It's looking for anything that's semantically similar to my original prompt.

And now that it has the research, it goes and writes the market scan document. So the first output will be a document. That document will then trigger the next skill to take said document and create a sales landing page copy from it.

And here's the part where step one is complete and it's moving immediately to the sales page. So now this is the second skill. And in this step two, it should load the sales page skill and then go from there.

And now we have this sales copy asset as the output. It then takes that and it moves immediately to the email sequence. So now it writes using the skill for email sequences, and now we wait for step four, which is now creating the social announcement on platforms like LinkedIn, like x, like YouTube.

And then it will go to the final stage, which is stage five. And then step five is the launch brief PDF. So it goes through all of the market intelligence.

It unifies everything together to give us one specific file. And the final output is something like this where we have all of the workshops, the executive summary, the pricing tiers, the competitive landscape, all the gaps, the sales copy like I said, the email sequence, the social media copy, and this could be whatever you want.

You can make this your own. I'll even show you later on in this video another skill that I call brain brief that will go through a particular topic and search different parts of my second brain in Obsidian. And by the way, if you enjoy my content and the way I teach, I've just released a brand new what I call living course in my community called the Claude code magic course.

And the whole point of this is that if you've seen other creators, they will release a course and it'll be static. And by the time that course is out, it'll already be obsolete or deprecated. So my course really dials in the way of thinking in Claude code systems.

How do you imagine what to do and what is worth doing in a world where you can build anything? And going through this course will give you every single thing that you need architecturally to self serve and use Cloud Code to its full potential.

And as things get deprecated, I will be slotting in and slotting out brand new modules so that this course is always up to date with the latest and greatest. So if that interests you and you wanna learn Cloud Code from someone who's actually used it for close to a year and is actually teaching other clients and businesses how to use it as well, then check out the first link in the description below, and I'll see you inside.

Let's get back to the video. So now we'll go through the why and the how. So in terms of the why, out of the box, all of these skill files on their own are markdown files.

And there are some cases where maybe you only wanna use one particular skill at a specific time, but you also wanna be able to have leverage when it makes sense to. So instead of having to always be the glue between different skills, especially if you wanna run them in an order of operations, but it's not as deterministic as running them in a Python automation.

You wanna run it with some nuance, some human loop, some area where you can step in as the 20% to the eighty twenty and add your own flavor. So although you can run one skill after the other and the context from the output from said skill will be in your context window, When you run them in sequence and each one is aware of the preceding skills output, you get a contextually better output from the collective working together.

So in a way, instead of using an army of agents, you're using a pseudo army of skills to create a cohesive output. And the one line that changes everything is something I've already gone over on this channel. But as a concept on its own, it's a boring concept.

But boring is very helpful. In this case, when you write context fork, this one line, in a skill file, it will run that skill in its own separate context window. Running it in that window, combining it with the ability to execute other commands that you can specify within the skill itself gives it a separate context window, a narrow focus on running these all one after the other, and then bringing back the output, which is all you care about at the end of the day.

So if we go back to the terminal and we run this very basic bash command to take a little preview at our skill and we go to the very top, this is what it looks like. And I will give you a copy of this and the other sample one in the second link in the description below. So you can see here, we have the name, launch offer, then we have the description.

Naturally, we want the description to be as descriptive as possible, but also really touch on the triggers. When should this skill be invoked? This will be extra helpful when you're training them.

Then we add this magical line that's called context fork. This will run it in its own context window. And in terms of these two other parameters right here, these are optional.

I like to write agent general purpose, and I like to really specify which tools are allowed for this specific skill. And the real magic is here. So you could see we have the slash market scan in these single quotes, and we're just telling it to run each one in sequence.

So this is step one, step two, and we're just naming the actual skill that lives on its own. And then after completion, it's good to specify what is the main thing we want back in our context window. So in this case, we are asking it to bring the PDF that I showed you earlier.

And just to drive it home, I will walk through this diagram. So we have skill number one. It will write something.

In this case, it will write the market scan MD file. Then we have sales page. They'll read number one.

Then email sequence will read the outputs of number one and two. Each one of these is executing a markdown file, and at the end, we combine all of these outputs together to create one unified file. So you go from something like this to something like this, and you can even really map out all the reads and writes in your entire data flow.

Now just to show you another example, given how popular Obsidian is with Andrei Karpathy's recent contributions, what if you hooked up your second brain using Obsidian and you had all of these different commands? Maybe you have one command that finds each and every note in your vault.

Then you have one that extracts key insights and tasks and another one that synthesizes them. But what you care about is your general brain brief about a particular topic. So if you pop into the terminal and we write this brain brief and then we'll add some form of parameter.

So in this case, can you go through and grab all the notes on how I like to structure my Claude code workshops? So this should be able to go through the entire vault in every folder and subfolder and bring back the overall synthesis. And right away, it's executing step one, is using the skill brain search.

It will search the entire Obsidian vault comprehensively for everything related to the topic, and it will use the command line interface if it needs a fallback. So now that step one completed after a few minutes, it executes number two, which extracts all the core insights from the search results and initially created a full markdown file with deep research on every part of the vault that seemed contextually relevant.

And you can see here that step two has also completed, and now we're doing the very last step, which is synthesizing all the insights that were extracted from the initial search.

And now you could see we have all we need for the pipeline to write the next part, and then we'll get one resulting response. Now after it's done running, we have the full output of every single thing that happens. So we have the output of the general structure, then we have the three files produced.

This is from each and every stage, and it breaks down everything it found, and now it has full contextual awareness of the entire pipeline that ran. So to sum it up, all you have to do is create your orchestrator skill. This will have that line we specified, context fork.

If you wanna be able to dictate full tool access, what has access, what doesn't have access, what it can or can't do, highly recommend it. And then in the body of the skill itself is primarily composed of what is step one through five or six and which command is executed with which step. So all you have to do is continue building your skills as you have been on their own, but where it makes sense and where you see opportunities for leverage, you can then combine them into one unified super skill.

And that's pretty much it. So hopefully this shows you the power of creating these compound skills that you can bring to all kinds of processes that not necessarily need to be deterministic a to z that run hands off, but do need a level of human in the loop.

And like I said, I'll make both of these skills available to you in the second link in the description below so you can use it, take advantage of it, and pretty much emulate my style and apply it to your processes. And again, for those interested in really taking their Claude Code prowess to the next level and doing it in a community that really supports you from a personnel standpoint, coaching, well as content, check out the first link in the description below, and maybe I'll see you inside.

And for those on the outside, if you found this video helpful, please let me know by leaving a like and a comment on the video. Subscribe if you haven't, and I'll see you in the next one.

The Hook

The bait, then the rug-pull.

Mark opens with a confession: he was wrong in public, told a room full of workshop attendees that skill chaining was not possible, then went home and proved himself wrong. The hook works because the mistake is credible -- even an expert can miss a one-line feature buried in the documentation -- and the payoff is proportionally satisfying: one line unlocks the entire thing.

Frameworks

Named ideas worth stealing.

05:52model

Skill Chain Architecture

Orchestrator SKILL.md with context_fork in frontmatter
Step 1: /market-scan -- writes market_scan.md
Step 2: /sales-page -- reads step 1, writes sales_page.md
Step 3: /email-sequence -- reads steps 1+2
Step 4: /social-announce -- reads previous outputs
Step 5: /launch-brief -- reads all, produces consolidated PDF

The orchestrator file runs in its own context window, invokes each sub-skill in sequence, and passes a shared output folder as the persistent memory each step reads from and writes to. No API calls, no vector store -- just files.

Steal forany multi-step content production workflow: research to copy to email to social to PDF

07:32model

Second Brain Chain (brain-brief)

/brain-search: searches entire Obsidian vault comprehensively, uses grep/glob as CLI fallback
/brain-extract: pulls key insights and tasks from search results
/brain-synthesize: writes the comprehensive brief from extracted insights

Three skills, one /brain-brief topic command, ~60 second execution. Works against any local vault with no special Obsidian plugin required.

Steal forknowledge retrieval, pre-call prep, topic synthesis against large note libraries

05:00concept

Pseudo-Army of Skills vs. Real Army of Agents

Chained skills are not agents. They run sequentially with human-in-the-loop at the end, not in parallel with autonomous decision-making mid-run. The trade-off: less autonomy, more determinism, lower cost, easier to debug.

Steal forframing the difference between skill orchestration and full agent architectures in Claude Code education

CTA Breakdown

How they asked for the click.

VERBAL ASK

10:02product

“I will make both of these skills available to you in the second link in the description below so you can use it, take advantage of it, and pretty much emulate my style and apply it to your processes.”

Two CTAs: mid-video sponsor for the Claude Code Magic Course (skool, link 1), end-video gift pitch for the free Skill Chaining Kit (gumroad, link 2). The free kit as a second link is smart -- lower friction close on a how-to video where viewers want the files, not the course.

MENTIONED ON CAMERA

03:19productClaude Code Magic Course (living course) ↗

03:19productEarly AI-dopters (skool community) ↗

07:29toolObsidian ↗

10:02productSkill Chaining Kit (free) ↗

FROM THE DESCRIPTION

PRIMARY CTAWhere the creator wants you to go next.