Big Idea

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.

Who This Is For

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.

TL;DR

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.

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: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.

Atomic Insights

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.

Takeaway

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.

Glossary

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.

Resources

Things they pointed at.

04:25linkCompany Skills Marketplace Template ↗

07:27linkSkills Marketplace Waitlist ↗

00:00linkAI Strategy Call (Brad) ↗

Quotables

Lines you could clip.

00:00

“Building a second brain for your business isn't enough.”

Pattern interrupt on a popular concept — lands in 8 words→ TikTok hook↗ Tweet quote

01:52

“That's how a five person team starts shipping like a 50 person team.”

Concrete leverage claim with no setup needed→ IG reel cold open↗ Tweet quote

04:07

“You own the layer, which means the tools you run it in are replaceable.”

Ownership framing, strong anti-SaaS resonance, standalone→ newsletter pull-quote↗ Tweet quote

06:55

“Every new hire inherits every lesson learned. Every agent runs at the same level as your best operator.”

Payoff line with parallel structure, no context needed→ LinkedIn post↗ 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.

metaphoranalogy

Building 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.

A 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.

But 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.

In 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.

I'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.

So 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.

And 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.

But 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.

Instead, 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.

Today, Claude Code is out in front. Next week, it might be Codex. And in a few years' time, who knows?

The 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.

You 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.

An 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 fancier version of copy and paste.

Inside 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.

Option 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.

Because 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 single source of truth for that type of information.

A 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.

The 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.

You 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.

Your 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.

There's nothing else to it. And the reason that it works is that agent skills are an open standard. Claude code reads them natively.

Codex 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.

The 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.

Then 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.

It'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.

When 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.

Now 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.

You 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.

I 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.

It 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.

That way teammates only install what's relevant to their role. The marketplace scales the same way your org does. Your local skills will decay.

You 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.

Say 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.

You 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.

And 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 marketplace becomes the operating system of the business.

Every 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.

Both 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.

If 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.

The 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.

Frameworks

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