Stop Wasting Claude Code's Potential: Build a Second Brain System

Stop Wasting Claude Code's Potential: Build a Second Brain System

What if your AI assistant could remember everything about your brand, create professional presentations on demand, and connect to hundreds of external tools—without drowning in context bloat?

Most developers are barely scratching the surface of what Claude Code can do. They use it for the occasional code review, a quick refactor, maybe some debugging help. Then they close their terminal and the context vanishes into the void. The next session starts from zero. Again and again.

But a small group of developers has discovered something different. They're using Claude Code as a system for knowledge work—a true second brain that captures their brand identity, operationalizes their workflows, and connects to external services through a clever progressive disclosure architecture. The secret? It's not magic. It's just structured context done right.

This article exposes exactly how the second-brain-skills repository by Cole Medin transforms Claude Code from a general-purpose coding assistant into a specialized knowledge work powerhouse. Whether you're a technical founder documenting processes, a developer advocate creating content, or an engineering lead building internal tools, this system will fundamentally change how you think about AI-assisted productivity.

What Is second-brain-skills?

The second-brain-skills repository is a curated collection of custom Claude Skills created by Cole Medin—a developer and content creator known for pushing the boundaries of practical AI tooling. Released as an open-source project on GitHub, this collection addresses a critical gap in the Claude Code ecosystem: the lack of structured, reusable knowledge systems.

At its core, the repository implements progressive disclosure of context—a design pattern where Claude only loads detailed instructions when specifically triggered, keeping the context window lean while maintaining deep expertise for each domain. This isn't just clever engineering; it's essential for working effectively with large language models that have finite context windows.

The project is trending right now because it arrives at a pivotal moment. Developers are realizing that raw AI capability isn't the bottleneck—context management is. With the explosion of MCP (Model Context Protocol) servers, the proliferation of AI-assisted workflows, and the growing need for brand consistency across AI-generated content, second-brain-skills provides a battle-tested architecture for organizing knowledge work.

What makes this repository genuinely different from scattered prompts or generic AI tools is its systems thinking. Each skill is modular, self-contained, and designed to compose with others. The Brand & Voice Generator feeds into the PPTX Generator. The MCP Client enables external integrations without context pollution. The Skill Creator lets you extend the system infinitely. It's not a collection of tricks—it's a framework for building your own AI-native operating system.

Key Features That Make This System Insane

The second-brain-skills repository packs six distinct capabilities, each solving a specific pain point in knowledge work:

1. Progressive Disclosure Architecture This is the invisible superpower. Instead of dumping thousands of tokens of instructions into every conversation, skills use YAML frontmatter metadata that's always available, detailed Markdown^{↗ Smart Converter} instructions that load when triggered, and bundled resources (scripts, references, assets) that fetch on demand. Your context window stays clean. Your expertise stays deep.

2. Brand & Voice Generator Most AI-generated content feels generic because it lacks a consistent voice. This skill walks you through creating brand.json, config.json, brand-system.md, and tone-of-voice.md files that become the single source of truth for all content generation. Five voice templates are included: Technical Educator, Calm Authority, Builder's Perspective, Approachable Expert, and Contrarian Thinker.

3. MCP Client with On-Demand Tool Loading MCP servers like Zapier and GitHub expose massive tool schemas that would devastate your context window. This skill wraps them as a lightweight Python^{↗ Bright Coding Blog} client, loading only the tools you need when you need them. The config format matches Claude Desktop exactly, so migration is seamless.

4. PPTX Generator with Visual-First Design Forget bullet-point slides. This skill includes 16 layout templates and a decision tree that transforms content into visual layouts automatically. Multi-card slides for 3-5 items, stats slides for big numbers, circular-hero for central concepts. It also generates square 1:1 LinkedIn carousels that export to PDF.

5. SOP Creator for Actionable Documentation Nobody reads 50-page docs. This skill enforces a universal structure with Definition of Done checklists, action-first steps, warnings before dangerous operations, and clear decision points. Document types include runbooks, deployment playbooks, troubleshooting guides, ADRs, and onboarding guides.

6. Remotion Video Creator Programmatic video creation using React^{↗ Bright Coding Blog} components. The skill includes 28 modular rules covering animations, compositions, captions, charts, 3D with Three.js, and Mapbox integration. Videos render in real-time in a browser preview before export to MP4/WebM.

Use Cases: Where This System Absolutely Dominates

Technical Founder Building a Content Engine

You're running a startup and need consistent LinkedIn presence, investor decks, and documentation. The Brand & Voice Generator captures your company's voice once. The PPTX Generator creates on-brand pitch decks in minutes. The SOP Creator documents your deployment procedures so your first hire doesn't break production. All powered by the same underlying brand system.

Developer Advocate Creating Educational Content

You need to produce videos, slides, and documentation at scale. The Remotion skill lets you create programmatic video tutorials with code animations. The PPTX Generator builds workshop slides with your personal brand styling. The tone-of-voice file ensures every piece of content sounds like you, not generic AI output.

Engineering Lead Operationalizing Team Knowledge

Your team keeps solving the same incidents differently. The SOP Creator enforces consistent runbook structure with Definition of Done checklists. The Skill Creator lets you build custom skills for your internal APIs and deployment patterns. The MCP Client connects to your existing GitHub, PagerDuty, or custom internal tools without context bloat.

Solo Consultant Automating Client Deliverables

You serve multiple clients with different brand requirements. The brand system lets you maintain separate identities per client. The PPTX Generator produces professional presentations without touching PowerPoint. The MCP Client connects to each client's Zapier automations, Notion databases, or Slack workspaces on demand.

Step-by-Step Installation & Setup Guide

Getting started with second-brain-skills requires cloning the repository and understanding which skills need configuration. Here's the complete setup:

Clone and Explore

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

# Explore the skill structure
ls -la .claude/skills/

The skills live in .claude/skills/ following Claude's skill directory convention. Each skill is a self-contained folder with SKILL.md and optional bundled resources.

Zero-Configuration Skills (Use Immediately)

The SOP Creator and Skill Creator work out of the box. Simply tell Claude to use them:

"Create a deployment runbook for our Docker↗ Bright Coding Blog-based API"
"Help me build a skill for working with our internal GraphQL schema"

MCP Client Setup (Low Effort)

# Step 1: Copy the example configuration
cp .claude/skills/mcp-client/references/example-mcp-config.json \
   .claude/skills/mcp-client/references/mcp-config.json

# Step 2: Edit with your API keys
# The format matches Claude Desktop's MCP config exactly

Your mcp-config.json supports multiple transport types:

{
  "mcpServers": {
    "zapier": {
      "url": "https://mcp.zapier.com/api/v1/connect",
      "api_key": "YOUR_API_KEY_HERE"
    },
    "sequential-thinking": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-sequential-thinking"]
    }
  }
}

Critical step: After connecting servers, ask Claude to test each tool and document gotchas in your project's CLAUDE.md. This prevents repeated errors and saves context on future calls.

Remotion Video Setup (Low Effort)

# Create a new Remotion project
npx create-video@latest

# Select: Empty template + TailwindCSS + Install Skills
cd my-video
npm install
npm run dev

Then simply tell Claude: "Edit my Remotion project at /path/to/my-video"

PPTX Generator Setup (Medium Effort)

This requires a complete brand system. Use the Brand & Voice Generator skill interactively, or manually configure:

# Copy the template brand
cp -r brands/template brands/your-brand-name

# Replace all REPLACE placeholders in:
# - brands/your-brand-name/brand.json (colors, fonts, assets)
# - brands/your-brand-name/config.json (output settings)
# - brands/your-brand-name/brand-system.md (design philosophy)
# - brands/your-brand-name/tone-of-voice.md (writing voice)

Add your logo to brands/your-brand-name/assets/ and test with a simple presentation.

REAL Code Examples from the Repository

Let's examine actual code and configuration from the second-brain-skills repository to understand how this system works under the hood.

Example 1: MCP Client Configuration

The MCP Client uses a standard JSON configuration that mirrors Claude Desktop's format. Here's the exact structure from the repository:

{
  "mcpServers": {
    "zapier": {
      "url": "https://mcp.zapier.com/api/v1/connect",
      "api_key": "YOUR_API_KEY_HERE"
    },
    "sequential-thinking": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-sequential-thinking"]
    }
  }
}

What's happening here? This config defines two MCP servers with different transport mechanisms. The Zapier server uses remote HTTP transport with Bearer authentication—Claude sends your API key in the Authorization header. The Sequential Thinking server uses local stdio transport—it spawns an npx process and communicates over standard input/output.

The repository also supports SSE transport (URL ending in /sse) and Streamable HTTP (URL ending in /mcp). This flexibility means you can connect to virtually any MCP server without modifying the client code. The progressive disclosure happens in the Python wrapper: tool schemas aren't loaded until you explicitly request them with python .claude/skills/mcp-client/scripts/mcp_client.py tools <server_name>.

Example 2: MCP Client Tool Commands

The Python CLI provides three essential operations:

# List configured servers (lightweight, no schema loading)
python .claude/skills/mcp-client/scripts/mcp_client.py servers

# List tools from a specific server (loads full schemas on demand)
python .claude/skills/mcp-client/scripts/mcp_client.py tools zapier

# Execute a tool with JSON parameters
python .claude/skills/mcp-client/scripts/mcp_client.py call zapier <tool_name> '{"param": "value"}'

Why this matters: The servers command is instant because it only reads the config file. The tools command fetches full schemas—which might be thousands of tokens—but only for one server at a time. The call command executes with explicit JSON parameters, preventing the "guessing game" that plagues natural language tool use. This architecture keeps your Claude Code context efficient while maintaining full MCP capability.

Example 3: Remotion Project Initialization

For video creation, the repository integrates with Remotion's official skill. The setup commands are:

# Bootstrap a new Remotion project with the skill pre-installed
npx create-video@latest

# When prompted, select:
# - Empty template (clean slate)
# - Enable TailwindCSS (styling utility)
# - Install Skills (adds Remotion skill automatically)

# Install dependencies and start dev server
cd my-video
npm install
npm run dev

The workflow: After npm run dev opens the browser preview, you tell Claude your project path. Claude reads the React component structure in src/ and edits components directly. The skill's 28 modular rules cover everything from spring animations to Three.js integration, but crucially—you work one composition at a time. Don't ask Claude to build an entire video; iterate on individual scenes that compose into a final render.

Example 4: Brand System File Structure

The PPTX Generator expects a specific brand directory structure. From the repository's customization guide, here's what you need:

brands/your-brand-name/
├── brand.json          # Colors (10 values), fonts (3), asset paths
├── config.json         # Output directory, batch size, file naming
├── brand-system.md     # Design philosophy, color rationale, typography rules
├── tone-of-voice.md    # Voice character, vocabulary patterns, do's and don'ts
└── assets/
    └── logo.png        # Your brand logo

The insight: This separation of concerns is deliberate. brand.json is machine-readable for the Python-pptx generator. brand-system.md and tone-of-voice.md are human-readable (and Claude-readable) guidelines that ensure consistency across all skills. The config.json controls operational parameters like batch size—critical because the generator limits to 5 slides at a time for reliability, with variety enforcement rules preventing repetitive layouts.

Example 5: SOP Universal Structure

The SOP Creator enforces this exact structure in every document:

## Definition of Done
- [ ] All production services show green health checks
- [ ] Database migration version matches code version
- [ ] Rollback procedure tested on staging

## When to Use This
Deploy when: feature branch merged, hotfix approved, or security patch released.

## Prerequisites
- kubectl configured for target cluster
- Database backup completed within last 4 hours
- On-call engineer notified in #deployments

## The Process
1. **Run pre-deploy checks**: `make pre-deploy`
2. **Apply database migrations**: `make migrate` (WARNING: irreversible)
3. **Roll out canary at 10%**: `kubectl apply -f k8s/canary/`
4. **Monitor error rate for 5 minutes**: dashboard link
5. **Proceed to full rollout** or **trigger rollback**

## Verify Completion
- Check `/health` endpoint returns 200
- Confirm error rate < 0.1% in Datadog

## When Things Go Wrong
- **Migration fails**: Run `make migrate-rollback`, restore from backup
- **Canary errors spike**: `kubectl delete -f k8s/canary/`, investigate

## Questions?
Ping @platform-team in #incident-response

The psychology: Notice how warnings come before dangerous steps, not after. Action items start with verbs. Decision points use explicit if-then logic. The Definition of Done is at the top because nobody scrolls to the bottom of a 50-page doc. This structure isn't arbitrary—it's optimized for humans under stress making critical decisions.

Advanced Usage & Best Practices

Document Your MCP Gotchas Immediately The repository emphasizes this repeatedly for good reason. After connecting any MCP server, run through all tools with sample inputs and document quirks in CLAUDE.md. Example from the repo:

## MCP Tool Notes
### Zapier
- `send_gmail_email`: The `to` field must be a single email, not an array
- `create_notion_page`: Requires `database_id`, not `page_id`
- Rate limit: 2 Zapier tasks per MCP call

This single practice will save you hours of repeated debugging and context waste.

Iterate Remotion Compositions, Don't Monolith The Remotion skill explicitly warns against asking Claude to produce entire videos. Build one composition at a time, preview in the browser, then compose scenes. This mirrors professional video workflow and prevents overwhelming both Claude and yourself.

Use Visual-First Layout Selection The PPTX Generator's decision tree is the difference between amateur and professional presentations. Before defaulting to content-slide, check: 3-5 equal items? Use multi-card-slide. Big numbers? stats-slide. Comparing two things? two-column-slide. This constraint actually improves your content by forcing visual thinking.

Extend with Skill Creator, Don't Modify Core Skills The Skill Creator skill teaches you to build modular extensions. When you need company-specific functionality, create a new skill rather than hacking existing ones. This preserves update compatibility and keeps your system clean.

Comparison with Alternatives

The key differentiator is integration depth. Standalone tools might do one thing better, but none compose into a unified knowledge system. Generic prompts lack persistence and structure. Other AI coding tools don't touch presentations, videos, or documentation workflows at all.

FAQ

Q: Do I need Claude Code Pro or a paid Anthropic subscription? A: No. These skills work with standard Claude Code. However, extensive MCP usage or large document generation may consume API credits faster than casual coding.

Q: Can I use these skills with Claude Desktop instead of Claude Code? A: Partially. The MCP config format is identical, but the skill directory structure and progressive disclosure mechanisms are designed for Claude Code's terminal environment.

Q: How do I update skills when the repository changes? A: Since skills are modular, you can git pull updates and merge changes per skill. Customizations in your brands/ directory and CLAUDE.md are separate from core skill files.

Q: Is there a risk of context window overflow with all these skills? A: This is exactly what progressive disclosure prevents. Skill metadata is tiny; full instructions only load when triggered. The MCP Client specifically solves tool schema bloat.

Q: Can I share my custom skills with my team? A: Absolutely. The Skill Creator produces standard skill packages that can be versioned in Git and distributed through your organization's repositories.

Q: What programming languages do I need to know? A: Python for MCP Client and PPTX Generator, React/TypeScript for Remotion videos, Markdown for everything else. The SOP Creator requires no coding at all.

Q: How does this compare to building a custom GPT or Claude Project? A: Custom GPTs are cloud-based and limited to ChatGPT. Claude Projects lack the modular skill architecture and external integrations. second-brain-skills gives you local control, composability, and direct code execution.

Conclusion

The second-brain-skills repository by Cole Medin represents a fundamental shift in how developers should think about AI assistance. It's not about prompting harder—it's about building systems that capture your knowledge, encode your preferences, and compose into workflows that scale.

The progressive disclosure architecture alone is worth studying, but the real power emerges when skills compose: brand identity flowing into presentations, MCP integrations feeding into documented SOPs, video content maintaining visual consistency with your slide decks. This is what a genuine AI-native operating system looks like.

My take? Start with the SOP Creator and Brand & Voice Generator today. They're zero-configuration and immediately useful. Once you experience structured context done right, you'll never go back to scattered prompts and lost conversations. The MCP Client and PPTX Generator are your next milestones. Remotion when you're ready for video.

Stop treating Claude Code like a chatbot. Start building your second brain.

👉 Clone the repository now and join the developers who've already transformed their knowledge workflows. Star the repo, open an issue with your use case, and start contributing back to this growing ecosystem of practical AI tooling.