I Built a Meta-Plugin for Claude Code (And It's Meta All the Way Down)

So I built a plugin for Claude Code that helps you build other Claude Code projects. It's Claude Code for Claude Code. Meta all the way down. If you're thinking "that sounds unnecessarily recursive," you're absolutely right, and that's what makes it beautiful.

Here's the thing: I've been using Claude Code for everything lately—building this blog, tracking my running workouts, automating content creation, the whole nine yards. I wrote about building claude-code-meta—a meta-project that generates entire specialized Claude Code projects from templates. It's been incredibly useful for spinning up complete projects like a running coach or this blog's content pipeline.

But after using claude-code-meta for a while, I noticed something. Some of the skills and tools I built were useful outside the context of full project generation. Sometimes I just needed to create a single CLAUDE.md file for an existing project. Or generate one custom skill without all the scaffolding. Or capture knowledge from a work session without initializing an entire project structure.

That's how the claude-code-meta-plugin was born. Version 0.0.1. A plugin that generates the very things you need to extend Claude Code: CLAUDE.md files, custom skills, slash commands, and even a /meta:retrospective command that captures knowledge from your work sessions and turns it into reusable artifacts.

It's the programming equivalent of teaching someone to fish, except you're teaching an AI to teach itself to fish, and then it documents the whole fishing process in a markdown file with perfect YAML frontmatter.

The Problem: Extending Claude Code Is Harder Than It Should Be

Don't get me wrong—Claude Code is incredibly powerful. But actually extending it? That's where things get complicated.

Want to create a CLAUDE.md file? You need to understand progressive disclosure patterns, the WHAT/WHY/HOW framework, and stay under the ~300 line guideline (because LLMs have instruction-following limits when context gets too large). You're trying to balance comprehensive documentation with staying under an arbitrary line count, which is a bit like trying to write a novel on Twitter.

Want to write a custom skill? You need to nail the YAML frontmatter syntax, understand auto-discovery patterns so Claude actually finds your skill, follow verb-noun naming conventions (analyze-data, not data-analyzer or DataAnalyzer), and organize files correctly in the .claude/skills/ directory. Get any of that wrong and your skill just... won't work. No error message, no feedback. It'll just sit there being useless.

Want to create a slash command? You need correct markdown structure, optional YAML frontmatter for metadata, proper argument patterns, tool restrictions (because some commands shouldn't have access to everything), and validation logic. Again, mess up the syntax and you get silence instead of helpfulness.

And here's the worst part: after you have a really productive session where you solve a hard problem or figure out a great workflow, all that knowledge just... evaporates. Unless you manually document it, which you probably won't because you're already thinking about the next thing. Your hard-won insights disappear into the void like tears in rain.

I got tired of this. So I did what any reasonable developer would do: I automated myself out of the problem.

The Solution: A Meta-Plugin That Builds Claude Code Tools

The claude-code-meta-plugin has three core components:

1. Three Auto-Discovered Skills

These skills automatically activate when Claude detects you need them. No manual invocation required.

claudemd-generator creates CLAUDE.md files following all the official best practices. It doesn't just spit out a template—it consults the claude-code-guide agent at runtime to get the current best practices (not hardcoded knowledge that gets stale), asks you clarifying questions about your project, generates content with proper structure and progressive disclosure, and validates everything before writing.

skill-generator designs domain-specific skills with complete scaffolding. Again, it researches current conventions, creates proper YAML frontmatter, generates workflow steps with error handling, includes concrete examples, and validates syntax.

command-generator creates slash commands with correct structure. Same pattern: research, generate, validate. You start to see a theme here.

2. One Slash Command

/claude-code-meta:retrospective is where things get really interesting. This command analyzes your entire conversation history, identifies successful approaches and reusable patterns, captures common pitfalls you solved, and then generates artifacts based on what it finds. It might create a skill for automation you just figured out, or a command for manual operations you'll repeat, or update your CLAUDE.md with project-wide guidelines.

This creates a knowledge accumulation loop. Each work session can contribute to your project's institutional knowledge instead of just disappearing into the ether.

The Retrospective Workflow: Capturing Ephemeral Knowledge

The /claude-code-meta:retrospective command represents something genuinely novel in AI-assisted development. Here's how it works:

You finish a productive session where you debugged something gnarly or figured out a clever workflow. Instead of letting that knowledge vanish, you run /claude-code-meta:retrospective. The command reads your entire conversation history, looking for patterns. Did you solve a memory leak using a specific approach? Did you automate something that could be reused? Did you discover project-wide conventions worth documenting?

Then it generates the appropriate artifacts. Maybe it creates a memory-leak-debugger skill that captures your debugging methodology. Maybe it adds a section to CLAUDE.md about debugging guidelines. Maybe it creates a /debug-memory slash command for quick invocation. You end up with persistent, reusable knowledge instead of just a vague memory of "yeah, I fixed something like that before."

It's the difference between having a conversation about how to fix your car versus having an actual repair manual. The conversation is helpful in the moment, but the manual is useful forever.

Why This Works: Research, Don't Hardcode

The key innovation here is that these generator skills don't rely on hardcoded knowledge. They consult the claude-code-guide agent every single time they run.

This means they always get the latest best practices from official documentation. No stale knowledge. No "this used to be the right way but now it's deprecated and nobody told you." They trust official sources over assumptions and stay current with Claude Code's evolution automatically.

Think about that for a second. Most documentation and tutorials are snapshots in time. They're correct when written and increasingly wrong as time passes. But these skills regenerate their knowledge from the source of truth every time. It's like having a textbook that rewrites itself to stay current.

Validation: Trust, But Verify

Every generator includes comprehensive validation because generating broken artifacts is worse than generating nothing at all.

YAML syntax checking catches frontmatter errors. Markdown structure validation ensures proper heading hierarchy and code blocks. Naming convention enforcement makes sure you're using kebab-case and verb-noun patterns. File placement verification confirms everything goes in the right directory. Conflict detection warns you if files already exist so you don't accidentally overwrite something important.

This catches about 90% of configuration issues before you even try to use what was generated. It's like having a really pedantic code reviewer who only cares about syntax and structure but is never wrong.

Real-World Impact: Significant Time Savings

The time savings are substantial, but honestly the bigger win is reducing frustration.

Before this plugin:

• Creating a skill meant researching best practices, trial and error with YAML, and fixing syntax errors
• Writing CLAUDE.md required learning the framework, organizing content, and staying under line limits
• Generating a command involved understanding markdown structure, frontmatter syntax, and validation logic

With this plugin:

• Creating a skill: Answer a few questions, watch it generate and validate
• Writing CLAUDE.md: Guided generation with current best practices baked in
• Generating a command: Automated and validated

No more fighting with YAML syntax. No more wondering if you're following best practices. No more "why isn't my skill activating" debugging sessions.

Why Skills Over a Global Tool?

You might ask: "Why make this a plugin with skills instead of just one global skill or command?"

Because auto-discovery is better UX.

Skills activate automatically when Claude detects you need them. You don't have to remember specific invocations or guess which command to run. You just start talking about what you want to do, and Claude brings in the right tool.

If I say "I need to create a CLAUDE.md file for my project," the claudemd-generator skill activates automatically. I don't need to remember /generate-claudemd or whatever the command would be. The system is context-aware instead of command-driven.

It's the difference between a smartphone that predicts what you need versus an old command-line interface where you have to remember exact syntax. Both work, but one is significantly friendlier.

Design Decisions That Shaped This

Why Namespace Commands as /claude-code-meta:*?

The /claude-code-meta:retrospective command uses a namespace prefix for a reason. It prevents conflicts with user's own commands (you might have your own /retrospective), makes plugin commands discoverable (you can see at a glance which commands came from the plugin), and follows plugin best practices.

It's respectful isolation. The plugin doesn't try to take over your namespace or assume it's the only thing that matters.

The Knowledge Accumulation Loop

Here's what makes this plugin philosophically interesting: it creates a feedback loop where knowledge compounds over time instead of evaporating.

Work Session → Learnings → Retrospective → Artifacts → Better Future Sessions
     ↑                                                           ↓
     └───────────────────────────────────────────────────────────┘

Session 1: You capture initial workflows. Maybe you generate 3 skills.

Session 5: You've refined patterns and discovered new workflows. Now you have 7 skills and 4 commands.

Session 20: You have a mature knowledge base. 15 skills, 10 commands, a rich CLAUDE.md full of domain expertise.

Each session teaches the next. This is institutional knowledge for individuals. Traditionally, "institutional knowledge" meant team or company knowledge—the stuff that lives in wikis or senior engineers' heads. But this plugin enables individual institutional knowledge. Your debugging patterns become skills. Your shortcuts become commands. Your conventions become documentation. Your expertise becomes agents.

It's like having a second brain that never forgets and gets smarter every time you use it.

What This Represents: Meta-Programming with AI

This plugin is part of a new category: AI tools that help you build better AI workflows.

Traditional programming: you write code that runs.

AI-assisted programming: AI helps you write code.

Meta AI programming: AI helps you build better AI assistants.

We're at the very beginning of this. Right now, most AI tooling is focused on the first two categories. Generate code. Explain code. Fix bugs. But the third category—using AI to improve your AI workflows—is largely unexplored territory.

The claude-code-meta-plugin is a small step in that direction. It's not just a tool. It's a template for self-improving AI systems. You use it to build better projects, which makes you more productive, which gives you insights, which you capture with retrospectives, which makes the system better.

It's bootstrapping all the way down.

Challenges I Ran Into

Challenge 1: Avoiding Circular Dependencies

The problem: A meta-plugin needs skills to generate skills, but it IS those skills. How do you bootstrap that without creating circular dependencies or infinite loops?

The solution: Make each skill self-contained with inline instructions. Each skill can generate OTHER skills but doesn't modify itself. There's a clear separation between generation logic (the generator skill) and generated output (the new skill you're creating). It's like the difference between a compiler and the programs it compiles—the compiler doesn't recompile itself during normal operation.

Challenge 2: Keeping Current with Claude Code

The problem: Claude Code evolves. Best practices change. Hardcoded knowledge becomes stale. How do you stay current without manually updating the plugin constantly?

The solution: All skills consult claude-code-guide at runtime. They get the latest best practices from official documentation every time they run. They trust official sources over assumptions. The knowledge stays fresh automatically because it's pulled from the source of truth each time.

Challenge 3: Validation Without Over-Engineering

The problem: You need validation to catch errors, but you can't run full linters or parsers because you're in a constrained environment. How do you validate effectively without over-engineering?

The solution: Mental YAML/markdown validation using structural checks and pattern matching. Look for common errors (missing colons, unclosed quotes, broken indentation). Provide clear error messages with examples when something's wrong. Trust but verify—assume things are mostly correct but check the critical parts.

Future Directions

This is version 0.0.1. The initial release. Here's what I'm thinking about for future versions:

Skill templates by domain. Pre-built skill templates for common domains like software development, content creation, data analysis. You pick a template, customize it, and you're off to the races.

Plugin generator. Create entire plugin scaffolds, not just individual skills. Bundle multiple skills, commands, and agents together. Generate the plugin.json with all metadata. Make it stupid easy to publish plugins.

MCP server discovery. Search and recommend MCP servers based on your use case. Auto-generate .mcp.json configurations. Test MCP connections to verify everything works before you commit.

Hook generator. Create pre-tool-use and post-tool-use hooks for common patterns like linting, formatting, and validation. Because everyone needs linting, but nobody wants to configure it manually.

Marketplace integration. Generate marketplace.json files for publishing. Validate plugins before submission. Create plugin listings automatically. Make the whole publishing process less painful.

But I'm starting simple and adding complexity as I actually need it. Progressive enhancement beats premature optimization every single time.

Try It Yourself

If you use Claude Code regularly, I highly recommend trying this approach. Think about the projects you're building. Are you creating CLAUDE.md files manually? Writing skills from scratch? Wishing you could capture workflows from productive sessions?

That's exactly what this plugin handles.

Installing it is dead simple. Just run this command in Claude Code:

/plugin add https://github.com/nickwinder/claude-code-meta-plugin

That's it. The plugin installs, the skills auto-discover, and you're ready to start generating CLAUDE.md files, custom skills, and slash commands. Or run /claude-code-meta:retrospective after your next productive session and watch it capture your hard-won knowledge into reusable artifacts.

You can also check it out on GitHub, fork it, modify it, break it, fix it. The whole point is to help you build better Claude Code projects faster with less frustration and more captured knowledge.

And if you build something cool with it, let me know. I'd genuinely love to hear what kinds of meta workflows people come up with. Because if there's one thing better than using AI to build better AI workflows, it's seeing other people use AI to build even better AI workflows that you haven't thought of yet.

Meta all the way down.

---

Questions or feedback? Find me on X/Twitter, LinkedIn, or email me at nicholastwinder@gmail.com. I promise I actually read messages, unlike those "contact us" forms that vanish into the corporate void.