The argument in one line.
A second brain without an execution layer is just documentation; the execution layer turns your company context into automated work by encoding playbooks as portable skills that scale across your team and AI tools.
Read if. Skip if.
READ IF YOU ARE…
- A founder or ops lead running a 3-15 person team who uses Obsidian for context storage and wants to automate repetitive work like proposals or SOPs without rebuilding skills per AI tool.
- An AI automation builder already using Claude or similar tools who needs a pattern to version-control and distribute skills across team members without Slack folder chaos or drift.
- A technical founder who's comfortable with GitHub and markdown but frustrated that their second brain (Obsidian, Notion) doesn't actually execute work or scale across a growing team.
SKIP IF…
- You're a solo creator or individual contributor with no team — the execution layer's main value is cross-team distribution and consistency, which doesn't apply to you.
- Your company brain already lives in a closed-ecosystem second-brain tool (Notion, Microsoft Loop) with built-in AI automation — this template is designed for Obsidian + external LLM stacks.
The full version, fast.
A second brain in Obsidian holds your company's context, but it doesn't ship work � you also need an execution layer of skills that run your playbooks over that context and return finished deliverables. Build skills as portable .md files, then distribute them through a private GitHub marketplace plugin that installs with one command and works across Claude Code, Codex, and any future tool that reads the open skill format. Reference live context from the brain inside each skill rather than hardcoding it, so updates propagate automatically. Push team-owned skills to the shared repo so every correction sharpens the standard, new hires inherit every lesson, and your five-person team starts shipping like fifty.
Members feature
Chat with this breakdown.
Modern Creator members can chat with any breakdown — ask for the hook, quote a framework, find the exact transcript moment. Unlocks at T2: refer 3 friends + add your own API key.
Create a free account →Where the time goes.
00:00 – 00:51
01 · The Missing Layer
Cold open: two-layer model introduced (context + execution). Hook: 'Building a second brain isn't enough.' Sets up the whole video premise.
00:51 – 01:21
02 · Inside My Company Brain
Obsidian demo. Shows /generate-proposal skill pulling live call transcript + pricing playbook. Brain holds context; skill ships the work.
01:21 – 01:42
03 · Why Local Skills Break for Teams
The drift problem — Slack, Drive, org skills all fail when team is split across Claude Code and Codex. Every copy diverges.
01:42 – 02:35
04 · The Private Team Marketplace
One install command, auto-sync, tool-agnostic. 'Five person team shipping like a 50 person team.' Execution + context = leverage.
02:35 – 02:48
05 · Two More Problems It Fixes
Teaser: baseline quality problem and documentation adoption. Resolved later in the PR-back loop section.
02:48 – 03:39
06 · Hard-Code vs. Reference Context
Core pattern: hard-coding context in skills = fragile. Referencing from the brain = single source of truth. Every skill that points at a live file gets the update automatically.
03:39 – 04:01
07 · Why Skills Decay on One Machine
You build a skill, get busy, file goes stale. Personal productivity up, team output flat. Team marketplace fixes the decay loop.
04:01 – 04:25
08 · Why It Works Across Every AI Tool
Just a private GitHub repo. Agent skills are an open standard — Claude Code, Codex, and whatever ships next all read the same .md format natively.
04:25 – 05:13
09 · Set Up the Free Template
Use template on GitHub, set private, name it, clone locally, ask Claude to read README and run setup, push to GitHub, copy install commands.
05:13 – 05:45
10 · Browsing and Installing Plugins
/plugins, marketplaces, Acme is there. Install team skills + marketplace admin. Fresh Claude session.
05:45 – 06:19
11 · Pushing Your Own Skills In
Marketplace manager skill copies skills from anywhere on machine. Point and say 'add this.' Plugin version bumped automatically.
06:19 – 06:42
12 · Scaling to Sub-Plugins
Sales, ops, CS plugins in the same marketplace but separate. Teammates install only what's relevant. Scales as the org grows.
06:42 – 07:03
13 · The PR-Back Loop
Correction in the field, push to marketplace, baked in for everyone next run. New hire runs on every lesson ever taught. Quality lottery gone.
07:03 – 07:27
14 · CTA + Watch Next
Watch Next card for the brain-build video. Free template and skills marketplace waitlist in description.
Lines worth screenshotting.
- A company brain without an execution layer is just a knowledge dump — it can answer questions but cannot act on them.
- The context layer holds your company knowledge in a tool like Obsidian; the execution layer holds the skills and SOPs that act on that knowledge.
- Skills stored in a private GitHub repo can be distributed across both Claude Code and OpenAI Codex without duplication.
- A skill is a reusable prompt-plus-tool bundle that any agent on your team can pull from the same repo and run independently.
- Separating context from execution means you can swap the AI model underneath without rebuilding the knowledge base.
- A team marketplace of skills turns individual workflows into organizational assets that compound over time instead of dying in a single developer's head.
- The execution layer pattern mirrors how software engineering teams manage libraries — one source of truth, many consumers.
- Storing SOPs as code in version control gives you audit history, rollback capability, and branch-based experimentation for free.
- Connecting Claude Code and Codex to the same skill repo means you can benchmark both models on identical tasks without extra setup.
- The company brain concept only scales when the retrieval step is cheap enough that agents can query it mid-task without breaking flow.
- An execution layer is the missing piece between 'our AI knows everything about us' and 'our AI can actually run our business.'
- Building the skill marketplace internally before opening it to clients gives you a portfolio of battle-tested tools rather than one-off demos.
A second brain without an execution layer ships nothing
What it teaches
Context stored in a second brain only becomes work when an execution layer — portable skill files that pull from that context and run playbooks — sits on top of it.
01The Missing Layer
- A second brain holds context; an execution layer runs playbooks over that context and returns finished work — most people build the first and skip the second.
02Inside My Company Brain
- The brain holds context (transcripts, pricing, past work); the skill is what ships the deliverable — both are required, neither does the other's job.
03Why Local Skills Break for Teams
- Skills break for teams the moment someone updates their local copy — every copy diverges, and the team loses the shared standard without realizing it.
04The Private Team Marketplace
- One install command that syncs all team skills across every machine and every AI tool is the practical answer to the drift problem.
- The leverage is not in headcount — it is in a context layer and an execution layer compounding together so a small team operates at the output of a much larger one.
05Two More Problems It Fixes
- A shared team marketplace also solves baseline quality (everyone runs from the same floor) and documentation adoption (skills that actually do work get used, unlike docs that just sit there).
06Hard-Code vs. Reference Context
- Hard-coding context into skill files is a trap: the moment anything changes, every copy must be updated manually; referencing a live file in the brain means every skill inherits the update automatically.
- Making the context layer the single source of truth turns every skill into living business methodology — the brain evolves, and every skill evolves with it.
07Why Skills Decay on One Machine
- Skills built on one machine decay — you get busy, the file goes stale, and personal productivity gains never reach the team.
08Why It Works Across Every AI Tool
- A private GitHub repo of skill files is tool-agnostic by default: any AI agent that reads markdown can consume the same skill, which means your execution layer is not locked to any single tool.
09Set Up the Free Template
- The setup sequence is: use the GitHub template, set it private, clone locally, ask the AI to read the README and run setup, push back to GitHub, copy the install commands.
10Browsing and Installing Plugins
- After installing the marketplace, starting a fresh session ensures the new skills are loaded before any work begins.
11Pushing Your Own Skills In
- A marketplace manager skill handles the import — point it at any skill file on your machine, and it copies it in and bumps the plugin version automatically.
12Scaling to Sub-Plugins
- Separating team skills into role-specific plugins lets each person install only what is relevant without cluttering everyone else's workspace.
13The PR-Back Loop
- The PR-back loop is the compound mechanism: a correction made in the field gets pushed to the shared skill, so every future run reflects it without any additional training.
- A team marketplace eliminates the quality lottery — a new hire's first run inherits every lesson the team has ever learned.
14CTA + Watch Next
- The execution layer described here depends on a context layer — the brain side must be built first for the skills to have anything meaningful to reference.
Terms worth knowing.
- Second brain
- A personal knowledge system that stores notes, documents, and reference material in a connected, searchable way so you can offload memory and retrieve context on demand.
- Context layer
- The half of an AI workflow that holds your stored knowledge — transcripts, docs, playbooks — that a model can read from but doesn't act on by itself.
- Execution layer
- The half of an AI workflow that runs playbooks and SOPs against your stored context to actually produce finished work like proposals, scripts, or reports.
- Obsidian
- A local-first note-taking app that stores notes as plain Markdown files and links them together, often used to build a personal or company knowledge base.
- Markdown file
- A plain-text file using lightweight formatting syntax (.md extension), readable by humans and easily parsed by AI tools and code editors.
- Skill
- A portable instruction file that encodes a repeatable process — like writing a proposal or thumbnail — so an AI agent can execute it consistently across runs and users.
- Slash command
- A shortcut inside an AI coding tool that triggers a named skill or workflow, typed as /name to invoke it instead of prompting from scratch.
- Claude Code
- Anthropic's command-line coding agent that runs on your machine, reads local files, and executes skills and tool calls inside a terminal or IDE.
- Codex
- OpenAI's coding agent product that runs commands and edits files locally, serving as an alternative front-end for the same kind of agentic workflows as Claude Code.
- Org skill
- A skill published at the organization level inside Claude's team plan so every member of the workspace can access and run the same version.
- Plugin
- A bundled set of skills, commands, or extensions that an AI tool can install from a marketplace, packaged so it can be versioned and shared as a unit.
- Marketplace
- A repository of installable plugins or skills that team members can browse and add to their local AI tool with one command.
- Agent skills open standard
- A shared file format for skills that multiple AI agents can read natively, so the same skill works in Claude Code, Codex, or any compliant tool without rewriting.
- Hardcoded context
- Pasting reference information like brand voice or pricing directly into a skill file, which works for solo use but goes stale when the source data changes.
- Referenced context
- Pointing a skill at an external file in your knowledge base so it pulls the current version at runtime, keeping a single source of truth.
- GitHub repo
- A project folder hosted on GitHub that tracks file history, supports collaboration, and can be cloned to any machine to share code or assets.
- GitHub template
- A repository configured so others can click "Use this template" to spin up their own copy with the same starting structure, separate from the original.
- MIT license
- A permissive open-source license that lets anyone use, modify, and redistribute the code for free, including in commercial projects, with minimal restrictions.
- Unlicensed
- Releasing a repo with no license attached, which by default reserves all rights to the author and prevents others from legally reusing the contents.
- README
- A documentation file at the root of a repo, usually named README.md, that explains what the project is, how to install it, and how to use it.
Things they pointed at.
Lines you could clip.
00:00
“Building a second brain for your business isn't enough.”
01:52
“That's how a five person team starts shipping like a 50 person team.”
04:07
“You own the layer, which means the tools you run it in are replaceable.”
06:55
“Every new hire inherits every lesson learned. Every agent runs at the same level as your best operator.”
Word for word.
metaphoranalogy
00:00Building a second brain for your business isn't enough. And it's not because they don't work, they do. But it's because you're missing the layer that turns your company context into action.
00:08A second brain that actually runs your business has two layers, and most people are only talking about one. That's the context layer. Hundreds, sometimes thousands of interconnected docs holding every piece of your context across your business.
00:20But pointing Claude at that context layer doesn't solve for actually doing the work. For that, you need the second part, and that's the execution layer. The execution layer takes that context, runs your playbooks and SOPs over the top, and returns your finished work, and almost nobody is talking about it.
00:36In this video, I wanna show you what that looks like, how to build one without locking yourself into Claude or OpenAI forever, and how to share it across your team so every new hire and every agent works at your level on day one. And the best part is I'm giving this away for free as a template so you can set it up yourself.
00:52I'm inside of my company brain in Obsidian, and here, every single meeting transcript, Slack thread, and email lands as a markdown file automatically. In fact, there's so much context in here that with the right execution layer, I can start to automate real work, like generating proposals from sales calls.
01:06So I built a skill exactly for that. It's called slash generate proposal, and it pulls the prospect's call transcript, our pricing playbook, and past proposals to tailor a document straight from the live data. That brain holds the context, but the skill is what ships the work.
01:20And that works great for me, but the second I need anyone else on my team to run it, things start to fall apart. I have some options. I could Slack the folder around, drop it into drive, and if we're on a clawed team plan, I could publish it as an org skill.
01:32But the thing is half of my team live in codecs on OpenAI, so that's out of the question as well. And the second one of them updates their copy, everyone starts to drift. So you can see it just doesn't really scale.
01:42Instead, I have a private team skills marketplace. It's one install command and every skill I've ever built shows up on their machine. Any update from me or anyone else pushes to the whole team automatically, and it works across whatever AI tool they're using, which, by the way, is the part that most people are getting wrong because every week, there's a new AI tool.
02:01Today, Claude Code is out in front. Next week, it might be Codex. And in a few years' time, who knows?
02:07The way I've built this, the marketplace doesn't care which one your team is on, and I'll show you why in a second. A skill is how you encode your standards, your processes, and your taste into one portable file that anyone can run. And it doesn't matter whether that's an agent or a person.
02:21You can drop them into a shared marketplace and the same skill that made you faster now makes the whole team faster. That's how a five person team starts shipping like a 50 person team. It's because the leverage is in the context layer and the execution layer working together, not in the additional headcount.
02:36An execution layer also fixes two other things you're probably struggling with, your team's baseline quality and whether your documentation actually gets used. I'll come back to both in a second. But first, I wanna show you the piece that marketplace into your brain because skip this and you've really just built yourself a .
02:54Inside every skill, you get two ways to handle context. Option one is that you hard code the context in. You can copy your brand voice, your pricing, or your customer avatar data straight into the skill file or create a references folder.
03:05Option two is that you reference it from somewhere else. The skill points to your brain and pulls the live version when it runs. Hard coding is fine when it's just you using the skill, but it ends up being a bit of a trap as time goes on.
03:16Because the moment some of the context changes, you've now gotta go find every skill that copied it and rewrite each one. It's a pain. Referencing is better because it makes the context layer the for that type of information.
03:28A file gets updated, and every skill that points at it gets the new version automatically. So you don't have to worry about stout context in your execution lab. This is the move that turns your skills into living business methodology.
03:39The brain evolves, and every skill evolves with it. One update to the brain, and that information is leveraged everywhere. Most people's skills are stuck on one machine.
03:48You build them, and they make you faster. But every teammate ends up rebuilding the same skill from scratch on their laptop. And personal productivity goes up, but team output stays about the same.
03:57Your team marketplace fixes that. Now I said earlier that this marketplace doesn't care which AI tool your team is on, and here's why. The whole thing is just a private GitHub repo.
04:06There's nothing else to it. And the reason that it works is that agent skills are an open standard. Claude code reads them natively.
04:13Codex reads them natively, and whatever ships next week will read them natively too because the format is the format. You own the layer, which means the tools you run it in are replaceable. I built a free GitHub template for it.
04:25The link is in the description below. You click use this template, set it to private, name it after your company, and there's two plugins that ship inside. One holds your team skills, and one is the admin plugin that handles the setup, importing skills, and publishing.
04:38Then clone the repo locally. The easiest way to do this is just to ask to do it for you. But once it is cloned, open the folder in Claude code, either in your IDE or the desktop app, and ask Claude to read the read me and run the setup.
04:49It'll scan all the files and walk you through it. The important thing here is your license because my template is MIT license, meaning you can use it for free in your business. But for your own skills, you wanna stay unlicensed.
05:00When Claude's done, ask it to push the changes up to GitHub. That'll update the read me again with the new install commands you need for Claude code and codex. Now you can just copy them in and the marketplace is installed.
05:10Now if I run slash plugins and head to marketplaces, Acme is there. I can browse plugins and you'll see the two ship five default, team skills and marketplace admin.
05:18You wanna install both and then start fresh Claude session so the new skills load in. Now I need to push some of my skills into team skills. So I've opened my main Claude repo where I keep the ones that I use daily, Instagram carousel, lead magnet, YouTube scripting, and thumbnails.
05:31I wanna ship these to the rest of my team, so I use the marketplace manager skill to add them into the marketplace. And the nice thing is you can add a skill from anywhere on your machine. Just point at it and say, add this to the team marketplace.
05:43It copies it in and bumps the plug in version. And when team skills starts feeling a bit too broad, you can scaffold this further. A sales skill plugin, an ops one, a customer success plugin, all in the same marketplace but separate plugins.
05:55That way teammates only install what's relevant to their role. The marketplace scales the same way your org does. Your local skills will decay.
06:02You build one, you get busy, and the file goes stale. And that's the end of it really. Team skills are different though, and here's why.
06:08Say your marketing lead notices an issue and corrects their version of the skill. That correction goes back into the skill dot m d, and they can push that to the marketplace. Next time anyone on the team runs that skill, the correction is baked in.
06:20You can even have permissions set up in GitHub, which allow you to control who can and cannot update those skills. That one move sorts out both of the problems I mentioned earlier. The skill doesn't rot because it's the thing actually doing the work, and every run is a chance to sharpen it.
06:35And the quality lottery is gone too because the new hire who just joined yesterday is now running on the back of every lesson your team has ever taught it. One floor going up every week. Multiply that across six skills, then 60, then across departments, and the .
06:52Every new hire inherits every lesson learned. Every agent runs at the same level as your best operator. The brain holds the context, and the marketplace runs the work.
07:01Both keep getting smarter over time. If you don't have the brain side built out yet, that should be your next watch. I walk through exactly how I run mine, including how Claude watches every piece of content I touch and feeds it straight in.
07:13If you wanna build the marketplace, the template is free and at the link in the description below. And if you want a stream of vetted production ready skills, you can drop straight into that marketplace. That's what I'm building next.
07:24The skills marketplace waitlist is in the description below.
The Hook
The bait, then the rug-pull.
Brad opens by naming the exact gap most AI-forward builders hit: a second brain full of context is not the same as a business that ships work. The promise is tight — two layers, you've only built one, here's the other — and he backs it with a working demo before the minute mark.
Named ideas worth stealing.
00:12model
The Two-Layer Brain
- Context Layer (Obsidian docs, transcripts, emails)
- Execution Layer (skills/.md files that run playbooks and return finished work)
A second brain needs two layers to actually run a business. Most people only build the context layer.
Steal forMCN+ positioning, any pitch about AI workflow automation
02:48concept
Hard-Code vs. Reference Context
- Option 1: Hard-code context (brand voice, pricing) into each skill — fragile, drifts
- Option 2: Reference context from the brain — single source of truth, auto-updates
Referencing beats hard-coding. One update propagates everywhere. Hard-coding compounds as skill count grows.
Steal forJoeFlow template system design, MCN+ skill/template architecture
03:39concept
The Decay Loop and the Fix
- Local skills decay: built, used, gets busy, goes stale
- Team marketplace breaks the loop: used, correction found, pushed, baked in for everyone
Team skills are self-sharpening because they are the thing actually doing the work, so every run is a chance to improve them.
Steal forContent about building team systems or SOPs that actually get used
04:01concept
Tool-Agnostic Marketplace
- Private GitHub repo = the marketplace
- Agent skills (.md format) are an open standard
- Claude Code, Codex, future tools all read the same files natively
- You own the layer; the tools are replaceable
Building on the open agent skills standard means your IP is portable and not locked to any one AI vendor.
Steal forOwn your stack content, MCN+ positioning against AI SaaS vendors
How they asked for the click.
07:03next-video
“If you don't have the brain side built out yet, that should be your next watch.”
Clean soft CTA — links to complementary video (the context layer build), plus template link and waitlist in description. No hard sell.
Visual structure at a glance.
