Modern Creator Network
Bitwise AI · YouTube · 04:34

He Open-Sourced His Claude Folder. 68K Stars on GitHub.

How a folder of markdown files beat BMAD, GSD, and most of the agent-framework ecosystem in 90 days.

Posted
5 days ago
Duration
Format
Essay
educational
Channel
BA
Bitwise AI
§ 01 · The Hook

The bait, then the rug-pull.

One folder. No runtime. No orchestrator. No twelve-agent hierarchy. Just markdown the agent reads on demand, and 68,000 GitHub stars in ninety days, more than Next.js collected in its first three years. Matt Pocock open-sourced his ~/.claude/skills/ directory and accidentally wrote the thesis statement for a new era of AI-assisted development.

§ · Stated Promise

What the video promised.

stated at 00:13So what's actually in this folder? And why are real engineers throwing out SpecKit and BMAD to copy it?delivered at 01:01
§ · Chapters

Where the time goes.

00:0000:47

01 · Hook + social proof

Cold open with star count, comparison to Next.js, sets up the core question: why are real engineers abandoning BMAD and SpecKit to copy a folder of text files?

00:4701:01

02 · Inside the repo

Walks the folder structure: engineering/, productivity/, personal/, misc/ — each leaf contains a single SKILL.md file. No runtime, no orchestrator.

01:0101:36

03 · The vibe coding problem

Names the failure mode: vague request to agent guesses to ships wrong thing to prompt fixing loop. Introduces the repo as a kill-switch for this pattern.

01:3602:10

04 · Skill 1: /grill-me

Agent interviews you relentlessly before writing any code. One question at a time. The fix for misalignment is friction applied to the developer, not the agent.

02:1002:37

05 · Skill 2: context.md verbosity fix

Shared language file compresses repeated domain context from 28 words to 8. Same bug, same agent, half the tokens. Pocock calls it the single coolest technique in the repo.

02:3703:03

06 · Skill 3: /tdd

Bans horizontal slicing (write all tests first). Enforces red-green-refactor one slice at a time. Tests verify actual behavior, not imagined behavior.

03:0303:34

07 · Skill 4: /diagnose

Six phases: Reproduce, Minimize, Hypothesize, Instrument, Fix, Regression-Test. Real trick: rank and pick the right feedback loop first. Failing automated test is best.

03:3403:58

08 · Framework showdown

Bar chart: SpecKit 93K, GSD 61K, BMAD 46.7K, mattpocock/skills 68.8K. Just markdown beats two of three.

03:5804:13

09 · The thesis: skills vs frameworks

Big frameworks own the process. When something breaks you do not know which layer to fix. Skills are single files: read it, fork it, delete it. No lock-in. No magic. The catalog is the artifact.

04:1304:34

10 · Distribution move + verdict

Pocock shipped an installer: npx skills@latest add. Distribution as a feature. Skills are the new package.json. Steal his version.

§ · Storyboard

Visual structure at a glance.

ONE FOLDER.
hookONE FOLDER.00:00
68,842 stars in 90 days
hook68,842 stars in 90 days00:04
68K > Next.js in 3 years
hook68K > Next.js in 3 years00:11
Inside the repo
promiseInside the repo00:20
Each leaf: a SKILL.md
valueEach leaf: a SKILL.md00:35
VIBE CODING.
valueVIBE CODING.00:58
/grill-me Skill #1
value/grill-me Skill #101:01
/grill-me in action
value/grill-me in action01:49
Friction applied to you
valueFriction applied to you02:09
Verbosity to context.md
valueVerbosity to context.md02:12
Half the tokens, same bug
valueHalf the tokens, same bug02:37
/tdd Skill #3
value/tdd Skill #302:57
TDD loop diagram
valueTDD loop diagram03:31
/diagnose Skill #4
value/diagnose Skill #402:35
10 feedback loops ranked
value10 feedback loops ranked02:52
Just markdown beats two
valueJust markdown beats two03:29
Skills do the opposite
valueSkills do the opposite03:34
skills.sh installer
valueskills.sh installer04:13
npx skills@latest add
ctanpx skills@latest add04:21
STEAL POCOCK VERSION
ctaSTEAL POCOCK VERSION04:34
Skills are the new package.json
ctaSkills are the new package.json04:38
§ · Frameworks

Named ideas worth stealing.

00:21concept

The Skills Pattern

Folder of markdown files, each a SKILL.md. No runtime, no orchestrator. Agent reads on demand. Fork any one, delete any one.

Steal forAny project using Claude Code, Cursor, or Codex — replace monolithic CLAUDE.md with modular skill files
01:36concept

/grill-me

Agent interviews developer relentlessly before writing any code. One question at a time. Kills vibe coding.

Steal forAny session where the ask is vague
02:13concept

context.md shared vocabulary

Domain-specific terms defined once in context.md. Cuts repeated prompt verbosity in half. Same bug, same agent, roughly 50% fewer tokens.

Steal forAny project with domain jargon repeated in every prompt
02:57concept

Vertical slice TDD

  1. Write one failing test
  2. Make it pass
  3. Refactor
  4. Repeat

Bans horizontal slicing. Red-green-refactor per feature slice. Tests verify actual behavior, not imagined behavior.

Steal forAny agent-driven feature build
02:35list

/diagnose six-phase loop

  1. Reproduce
  2. Minimize
  3. Hypothesize
  4. Instrument
  5. Fix
  6. Regression-Test

Structured bug diagnosis. Build the right feedback loop before anything else. Failing test is best. Bash-driving a human is last resort.

Steal forAny debugging session
04:08concept

Distribution as a feature

Ship an installer alongside the content. One command picks skills, picks agent, wires them in. Most open-source projects forget this.

Steal forAny tool or framework Joe ships — bundle an installer, not just files
§ · Quotables

Lines you could clip.

01:36
Interview me relentlessly until we reach a shared understanding.
Direct quote from skill file, instantly usable standalone principleTikTok hook
02:10
Same bug, same agent, half the tokens.
Tight three-beat punchline with measurable resultIG reel cold open
02:35
Build the right feedback loop, and the bug is 90% fixed.
Quotable thesis, works as standalone clip with zero setupNewsletter pull-quote
03:34
Big frameworks own the process. Skills do the opposite.
Clean antithesis, the core argument in two sentencesTikTok hook
04:31
Skills are the new package.json. Start curating yours or someone else will.
Perfect closing line, urgency plus identity plus analogyIG reel cold open
02:10
The fix for misalignment is friction applied to you.
Counter-intuitive insight, friction on the human not the AINewsletter pull-quote
§ · Pacing

How they spent the runtime.

Hook length9s
Info densityhigh
Filler0%
§ · Resources Mentioned

Things they pointed at.

03:02toolSpecKit
03:02toolGSD (Get Stuff Done)
03:02toolBMAD
§ · CTA Breakdown

How they asked for the click.

04:21link
Command on screen. Repos in the description. Skills are the new package dot JSON. Start curating yours or someone else will. Sub for the next one.

Install command shown visually on screen, repo URL shown, subscribe ask buried at the very end. Extremely clean, non-pushy.

§ · The Script

Word for word.

HOOKopening / re-engagementCTAthe pitchmetaphoranalogystory
00:00HOOKMatt Pocock open sourced his dot claud folder. Just the markdown files he keeps in there. Ninety days later, 68,000 stars. More than Next. Js got in its first three years.
00:13HOOKSo what's actually in this folder? And why are real engineers throwing out SpecKit and BMAD to copy it? Here's the whole repo, folder of folders. Engineering, productivity, personal,
00:26misc. Inside each folder, more folders. Inside those, a single file called skill dot m d. That's it. No runtime, no orchestrator, no 12 agent hierarchy.
00:39Just mark down the agent reads on demand. 68,000 stars for a folder of text files. You know the loop. You type a vague request. Agent guesses. Agent ships the wrong thing.
00:51You fix the prompt. Agent guesses harder. Pocock has a name for this. Vibe coding, and the whole repo is built to kill it. Skill number one,
01:02slash grill me. The agent stops being polite. It interviews you about your plan, one question at a time,
01:10walks every branch of the decision tree, makes you commit before any code gets written. Quote from the skill file. Interview me relentlessly until we reach a shared understanding. Pocock's most used skill by his own admission.
01:27The fix for misalignment is friction applied to you. Skill number two solves verbosity. Before, there's a problem when a lesson inside a section of a course is made real,
01:40given a spot in the file system. After, with a shared language file called context dot m d, there's a problem with the materialization cascade.
01:50Same bug, same agent, half the tokens. Pocock calls this the single coolest technique in the repo. He's not wrong. Skill number three slash TDD.
02:02Most people let the agent write all the tests first, then all the code. Pocock's skill literally says, do not do this. One test, one implementation,
02:13one green bar, repeat. He calls the wrong way, horizontal slicing. Tests written in bulk verify imagined behavior,
02:22not actual behavior. Vertical slices, tracer bullets, red green refactor,
02:29boring, old, works. Skill number four, slash diagnose.
02:35Six phases. Reproduce, minimize, hypothesize,
02:40instrument, fix, regression test. But the real trick is phase one, building a feedback loop.
02:47Pocock lists 10 ways, ranked, failing test at the top, driving a human with a bash script at the bottom, last resort. Quote, build the right feedback loop, and the bug is 90
03:00fixed. Compare the field. SpecKit, 93,000
03:05stars. GitHub published, has a constitution file. GSD, get stuff done, 61,000
03:12stars, opinionated framework just for Claude code. BMAD, 46,000
03:19stars, 12 specialized agents doing product, architecture, UX, dev, QA, scrum master. Pocock's repo,
03:28just markdown, beats two of them already. Here's the thesis. Big frameworks own the process. They give you 12 agents and a constitution and a methodology.
03:39And when something breaks, you don't know which layer to fix. Skills do the opposite. Each one is a single file. You can read it. You can fork it. You can delete it. No lock in. No magic. No Kool Aid.
03:53The catalog is the artifact. And here's the part that explains the star count. Pocock didn't just publish files. He shipped an installer. One command picks your skills, picks your agent, Claude code, codex, whatever,
04:08wires them in, distribution as a feature. Most open source projects forget that part. Verdict. If you're using Claude code, cursor, or codex,
04:18CTAyou're already running this pattern badly. Steel Pocock's version. Command on screen. Repos in the description.
04:26CTASkills are the new package dot JSON. Start curating yours or someone else will. Sub for the next one.
§ · For Joe

This is the modular skills playbook you are already running.

JoeFlow builder lens

Pocock proved that a curated folder of markdown skill files, no framework, no runtime, is worth more than any 12-agent system. Joe is already building this.

  • Your ~/.claude/skills/ folder IS this pattern. You have mod-watch, goldmine, creator-research, deploy-joeflow. Name it, ship it, give it an installer.
  • The /grill-me pattern maps directly to how good client sessions should start. Relentless scoping before any code. Build a JoeFlow equivalent.
  • context.md is the LFB Line session prep play: define domain terms once, cut prompt verbosity 50% every session.
  • The /diagnose feedback loop ranking (failing test is best, bash-driving a human is last resort) is a direct checklist for any JoeFlow bug triage.
  • Distribution as a feature: when you ship MCN+ tool skills, ship an installer command. One npx line beats a README every time.
  • Skill catalogs are a pricing anchor. Pocock's is free, yours bundled with MCN+ is a compounding moat.
§ · For You

How to stop fighting with your AI coding assistant.

If you use Claude Code, Cursor, or Copilot

The reason your AI assistant ships the wrong thing is not the AI. It is that you gave it a vague request and expected it to read your mind.

  • Before you type a coding request, ask the AI to interview you about your plan one question at a time before touching any code.
  • If you repeat the same domain explanation in every prompt, write a context.md file with your project key terms and reference it instead of re-explaining.
  • If you let an AI write all your tests upfront, you are verifying imagined behavior. Write one test, make it pass, repeat.
  • When you hit a bug, build a feedback loop first. A failing test that reproduces it is worth more than any amount of explaining.
  • Install Pocock's skills with: npx skills@latest add mattpocock/skills. Works with Claude Code, Cursor, and Codex.
§ · Frame Gallery

Visual moments.

§ · Watch next

More from this channel + related dossiers.