One Open Source Project a Day (No.34): second-brain-skills - A Skill Toolkit That Turns Claude Code Into a Knowledge Work Expert

Introduction

"The limits of your AI are the limits of what you've equipped it with."

This is article No.34 in the "One Open Source Project a Day" series. Today's project is second-brain-skills (GitHub).

Most people treat Claude Code as a programming tool — write code, fix bugs, refactor. But if you're a content creator, indie developer, or a one-person company juggling technical docs, presentation decks, and brand building, you quickly realize Claude Code's default capabilities cover only a fraction of your actual work.

second-brain-skills changes that. Opened by AI Agent engineer Cole Medin, this project upgrades Claude Code from a coding specialist to a full-spectrum knowledge work partner through a set of carefully designed Claude Code Skills: brand guidelines, professional PPTX decks, operations runbooks, external MCP service connections, and even programmatic video generation — all following the principle of "Progressive Disclosure of Context" to avoid wasting your precious context window.

What You'll Learn

• A new take on "Second Brain" in the context of AI workflows
• The design philosophy behind Claude Code Skills: progressive context disclosure
• The functionality and usage of all 6 production-ready Skills
• How to connect to external services (Zapier, GitHub) via the MCP Client Skill
• How to build your own custom Skills based on this framework

Prerequisites

• Familiarity with Claude Code basics
• Understanding of Markdown syntax
• Python basics (for MCP Client)

Project Background

What Is It?

"Second Brain" is a classic personal knowledge management (PKM) concept popularized by Tiago Forte in Building a Second Brain — using digital systems as an extension of your mind to systematically capture, organize, and apply knowledge.

second-brain-skills brings this concept into AI workflows: through Claude Code's Skill mechanism, Claude dynamically loads the relevant instructions, templates, and tools for a given domain only when needed — a true extension of your "second brain."

Unlike typical RAG solutions, this project requires no vector database or retrieval system. Context is loaded progressively via carefully structured Markdown files.

About the Author

• Author: Cole Medin (coleam00)
• Company: Dynamous (AI education & tools)
• YouTube: @ColeMedin (practical AI Agent content creator)
• GitHub Followers: 6,500+
• Notable Projects: Archon (13.9k ⭐), context-engineering-intro (13.1k ⭐), ottomator-agents (5.5k ⭐)

Cole is one of the most active practitioners in the Claude Code ecosystem, focused on engineering AI Agent technology into real-world workflows — strong on implementation, not just theory.

Project Stats

• ⭐ GitHub Stars: 648
• 🍴 Forks: 195
• 🔄 Last Updated: January 2026
• 📄 License: Not explicitly declared (copyright retained by author)

Key Features

Core Design Philosophy: Progressive Context Disclosure

The most important idea in this project isn't any single feature — it's Progressive Disclosure of Context:

Load relevant context only when needed, rather than stuffing everything into the context window upfront.

The traditional approach is to pack all knowledge into the system prompt, burning tokens on every conversation. second-brain-skills uses a three-layer on-demand loading model instead:

This design lets Claude Code manage dozens of Skills while keeping each conversation's context lean and efficient.

The 6 Core Skills

1. Brand & Voice Generator

Creates a complete brand configuration system for your company/project, outputting 4 standardized files:

• brand.json — colors, fonts, visual specs
• config.json — brand metadata
• brand-system.md — complete brand system documentation
• tone-of-voice.md — brand voice and tone guidelines

These 4 files become the "single source of truth" for your brand, used by subsequent Skills (PPTX Generator, content creation) to maintain consistency automatically.

2. PPTX Generator

Generates brand-consistent professional slide decks with 16 visually-first slide layout templates — no more "wall of text" presentations:

Also supports LinkedIn carousel format (square) for social media content.

3. SOP Creator

Generates structured operations manuals, technical documentation, and runbooks for:

• Team operations and process documentation
• Technical runbooks and incident response playbooks
• Product playbooks
• Employee onboarding guides

4. Skill Creator

Guides you through creating a new custom Skill that conforms to the framework's conventions, with built-in best practice checks to ensure your new Skill follows progressive context disclosure principles.

5. MCP Client

Connects to external MCP servers via a unified interface, supporting 4 transport protocols:

• stdio: Local subprocess (command-line tools)
• SSE: Server-Sent Events
• Streamable HTTP: HTTP streaming
• FastMCP: Bearer Token authentication

Ships with ready-to-use configs for Zapier, GitHub, Sequential Thinking, and more.

6. Remotion Video Creator

Programmatically generate videos with React components — Remotion translates code into MP4 files. Perfect for:

• Product demo videos
• Data visualization animations
• Short-form social media content

Quick Start

# Clone the repository
git clone https://github.com/coleam00/second-brain-skills.git

# Option 1: Use in your own project
# Copy the .claude/ directory to your project root
cp -r second-brain-skills/.claude /your-project/

# Option 2: Open Claude Code directly in the repo
cd second-brain-skills
# Open Claude Code — Skills are ready to use

Configure MCP Client (optional):

cd .claude/skills/mcp-client/references/
cp example-mcp-config.json mcp-config.json
# Edit mcp-config.json and fill in your API keys

Install Python dependencies (for MCP Client):

pip install mcp fastmcp

Using Skills — trigger with natural language in Claude Code:

"Create a brand config for WonderLab"
→ triggers Brand & Voice Generator

"Make an AI trends report deck using our brand"
→ triggers PPTX Generator

"Write a runbook for our Docker deployment process"
→ triggers SOP Creator

"Connect to Zapier MCP and list available actions"
→ triggers MCP Client

How It Compares

Deep Dive

Skill File Structure Anatomy

Every Skill follows a consistent directory convention:

.claude/skills/
└── skill-name/
    ├── SKILL.md          # Required: trigger conditions + workflow instructions
    ├── scripts/          # Optional: executable scripts (deterministic operations)
    ├── references/       # Optional: reference docs (loaded on demand at runtime)
    └── assets/           # Optional: templates, fonts, images (not auto-loaded)

SKILL.md structure (SOP Creator example):

---
name: SOP Creator
description: Creates runbooks, playbooks, and technical documentation
---

## Trigger Conditions
Activate when the user needs to create an operations manual, runbook, playbook,
or technical documentation.

## Workflow

### 1. Gather Information
First ask:
- Document type (Runbook / Playbook / SOP / Onboarding guide)
- Target audience
- Core process or scenario being documented

### 2. Structure Generation
Generate the document structure using this template:
- Overview and Purpose
- Prerequisites
- Step-by-step Instructions (with command examples)
- Troubleshooting
- Related Documentation Links

### 3. Formatting Rules
- Use Markdown throughout
- Wrap all commands in code blocks
- Add warning callouts for critical steps

The description field in the YAML frontmatter is how Claude Code decides when to activate this Skill — it's the Skill's "trigger dictionary."

PPTX Generator's Cookbook Mechanism

The core innovation in PPTX Generator is the Cookbook design. Each slide layout is an independent Python script; Claude selects and combines them as needed when generating a deck:

# cookbook/stats-slide.py (simplified)
from pptx import Presentation
from pptx.util import Inches, Pt
from pptx.dml.color import RGBColor

def create_stats_slide(prs, brand_config, stats_data):
    """
    Create a statistics/data showcase slide
    brand_config: loaded from brand.json
    stats_data: [{"label": "Users", "value": "10,000", "growth": "+23%"}]
    """
    slide_layout = prs.slide_layouts[6]  # Blank layout
    slide = prs.slides.add_slide(slide_layout)

    # Apply brand background color
    bg_color = RGBColor.from_string(brand_config["colors"]["background"])
    # ... render stats numbers, growth indicators, etc.

The "cookbook" design has three key advantages:

1. Each layout is independently maintained — changes to one don't affect others
2. Claude can autonomously combine layouts to build a complete deck
3. Users can add custom layouts without modifying any core logic

MCP Client's Unified Interface

mcp_client.py uses Python asyncio to provide a unified abstraction over all 4 transport protocols:

# scripts/mcp_client.py (simplified)
from contextlib import asynccontextmanager
from mcp import ClientSession, StdioServerParameters
from mcp.client.stdio import stdio_client
from mcp.client.sse import sse_client

@asynccontextmanager
async def connect_to_server(server_config: dict):
    """Unified connection interface — auto-selects transport based on config"""
    transport = server_config.get("transport", "stdio")

    if transport == "stdio":
        params = StdioServerParameters(
            command=server_config["command"],
            args=server_config.get("args", []),
            env=server_config.get("env")
        )
        async with stdio_client(params) as (read, write):
            async with ClientSession(read, write) as session:
                await session.initialize()
                yield session

    elif transport in ("sse", "streamable-http"):
        async with sse_client(
            url=server_config["url"],
            headers=server_config.get("headers", {})
        ) as (read, write):
            async with ClientSession(read, write) as session:
                await session.initialize()
                yield session

Config file (mcp-config.json) example:

{
  "mcpServers": {
    "zapier": {
      "transport": "sse",
      "url": "https://mcp.zapier.com/api/v1/connect",
      "headers": {
        "Authorization": "Bearer YOUR_ZAPIER_API_KEY"
      }
    },
    "sequential-thinking": {
      "transport": "stdio",
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-sequential-thinking"]
    },
    "github": {
      "transport": "stdio",
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-github"],
      "env": {
        "GITHUB_PERSONAL_ACCESS_TOKEN": "YOUR_TOKEN"
      }
    }
  }
}

Brand System: Single Source of Truth

The 4 files output by Brand & Voice Generator form an interconnected brand system:

brands/
└── your-brand/
    ├── brand.json         # Visual specs (colors, fonts, spacing)
    ├── config.json        # Brand metadata (name, industry, target audience)
    ├── brand-system.md    # Full brand guidelines (human-readable)
    └── tone-of-voice.md   # Voice style (formal/casual/technical/etc.)

Example brand.json:

{
  "name": "WonderLab",
  "colors": {
    "background": "0A0A0A",
    "primary": "6366F1",
    "accent": "8B5CF6",
    "text": "F9FAFB",
    "muted": "6B7280"
  },
  "fonts": {
    "heading": "Inter",
    "body": "Inter",
    "code": "JetBrains Mono"
  },
  "spacing": {
    "slide_padding": 60,
    "element_gap": 24
  }
}

PPTX Generator automatically reads this file, ensuring every slide stays on-brand — no need to re-specify colors and fonts each time.

Resources

Official

• 🌟 GitHub: https://github.com/coleam00/second-brain-skills
• 🎬 Author's YouTube: @ColeMedin (includes tutorial videos)
• 🐛 Issues: https://github.com/coleam00/second-brain-skills/issues

Other Projects by the Author

• Archon (13.9k ⭐): Deterministic AI Agent framework
• context-engineering-intro (13.1k ⭐): AI context engineering tutorial
• mcp-crawl4ai-rag (2.1k ⭐): Web scraping + RAG solution for AI Agents

Summary

Key Takeaways

1. Progressive Context Disclosure: Three-layer on-demand loading is far more efficient than "stuff everything into the system prompt" — this is the most transferable design insight from the project
2. Skills as Markdown: Defining AI workflows in Markdown creates zero barrier to entry; anyone can write a custom Skill without touching Python
3. Brand system integration: The Brand Skill → PPTX Skill workflow turns brand consistency from a manual effort into an automated process
4. MCP unified abstraction: 4 transport protocols behind a single config-file interface makes connecting external services trivially simple
5. Solo creator friendly: The project's scope maps almost perfectly onto the needs of a "one-person company" — from technical docs to content creation, fully covered

Who Should Use This

• Indie developers / one-person companies: Full-stack knowledge workers handling tech, content, and brand simultaneously
• Content creators: Anyone who needs to produce brand-consistent PPT decks and documents at scale
• Technical writers: Engineers responsible for maintaining large collections of SOPs, runbooks, and playbooks
• Claude Code power users: Developers who want to transform Claude Code into a personalized work platform

Visit my personal site for more useful knowledge and interesting products