How I use Fable 5 to research, build, and maintain custom Claude Code plugins, marketplaces, agents, and skills—creating reusable AI tooling that works across every project.
We had four sibling repositories — call them Service A, Service B, Service C, and Shared Utils — each with its own .claude/agents/ folder. Same four agents in every repo: a locator, an impact-sweeper, a verifier, a reviewer. Identical files, copy-pasted by hand, drifting the moment anyone fixed a bug in one copy and forgot the other three.
Meanwhile Shared Utils was quietly sitting on 880 KB of maintained, cross-repo reference documentation — the kind of material an agent should read before grepping code, not instead of it. Nothing was wired up to use it.
The actual ask
"Centralize the agents somewhere all repos can pull from, and make sure they actually use the docs we already wrote."
Why build a plugin instead of copying files?
If you're working on multiple repositories, shared AI tooling deserves the same treatment as shared libraries.
Instead of maintaining duplicate agents and skills, you can package them into a Claude Code plugin and expose them through a marketplace. Projects simply install the plugin and immediately gain access to the latest version.
This brings several benefits:
A single source of truth for agents and skills.
Consistent behavior across projects.
Easier onboarding for new repositories.
Updates happen once instead of everywhere.
02 · What Claude Code plugins are, in general
Strip away the project-specific names and the mechanism is a small, general pattern — useful anywhere you have more than one repo and want shared agents, skills, or hooks without copy-paste:
A marketplace is just a folder with a manifest (.claude-plugin/marketplace.json) listing one or more plugins by name and a relative path to each.
A plugin is a folder with its own manifest (.claude-plugin/plugin.json) plus agents/ and skills/ subfolders. Claude Code auto-discovers anything in them — no registration step beyond the manifest existing.
Any other repo registers the marketplace once and installs the plugin from it. From then on its agents and skills are just there, namespaced as plugin-name:agent-name so they never collide with repo-local ones.
03 · Where Fable5 actually earned its keep
I didn't start by asking Fable 5 to "create a plugin."
Instead, I asked it to understand the problem.
The workflow looked like this:
Research the latest Claude Code documentation. Claude Code evolves quickly, so I wanted the current plugin format rather than relying on memory or outdated examples.
Understand my existing setup. Fable 5 analyzed my repositories, identified duplicated agents and reusable skills, and separated project-specific instructions from shared tooling.
Design the plugin structure. Rather than copying folders, it proposed a clean marketplace and plugin layout that could scale as more repositories were added.
Generate the manifests and configuration. It created the required plugin metadata, marketplace definitions, and installation instructions.
Verify everything. Instead of assuming success, it validated the installation, checked available commands, and confirmed the plugin loaded correctly.
That last step was particularly valuable. AI shouldn't just generate files—it should verify that they actually work.
Building reusable skills
One of the biggest advantages of plugins is reusable skills.
Instead of embedding the same instructions in every project, I created shared skills for common engineering tasks, such as: Architecture reviews, Code reviews ,Documentation lookup , Bug investigation etc.
Whenever a new project needs one of these capabilities, there's nothing to copy. Installing the plugin makes every skill available.
Creating specialized agents
Plugins also make it easy to build focused agents.
Rather than one general-purpose assistant, I created agents with clear responsibilities:
Reviewing pull requests
Locating relevant code
Investigating production issues
Explaining unfamiliar modules
Validating implementation plans
Each agent has a single purpose, making them easier to maintain and more predictable to use.
Why a marketplace matters
The marketplace is what ties everything together.
Instead of manually copying files into every repository, projects simply register the marketplace once and install the plugin.
From that point forward, every repository shares the same toolkit.
When the plugin improves, every project benefits after updating to the latest version.
It turns AI tooling into something that's versioned, reusable, and maintainable—just like any other dependency.
04 · The pattern, if you want to reuse it
| step |
what it buys you |
| shared repo hosts a marketplace |
one canonical copy of every cross-cutting agent/skill; no drift between repos |
| consumer repos install, don't copy |
a fix in the shared repo reaches every consumer on next pull — no manual sync |
| namespace everything |
toolkit:reviewer can't collide with a repo's own reviewer skill |
| docs as a first step, not a fallback |
agents cite doc#section before they grep — cheaper, and catches drift between docs and code as a side effect |
| verify the install, don't trust the config |
plugin list / plugin details tell you the true state; a settings file only tells you the intent |
Today, I primarily use Fable 5 because of its strong reasoning and research capabilities.
It excels at:
Exploring unfamiliar codebases.
Researching documentation before implementation.
Designing reusable systems.
Verifying generated changes.
Producing well-structured documentation.
As Claude Code continues to evolve, I expect to shift more of the execution work to Claude Sonnet while continuing to use this workflow. Research, planning, implementation, and verification each have different strengths, and combining the right model with the right stage of development leads to a much smoother experience.
Final thoughts
The biggest lesson wasn't how to build a Claude Code plugin—it was realizing that AI tooling should be treated like software.
Version it.
Share it.
Document it.
Verify it.
By using Fable 5 to research and build reusable Claude Code plugins, marketplaces, custom agents, and shared skills, I now have a toolkit that scales with every new repository instead of creating more maintenance work.
As AI becomes a standard part of software development, I think reusable plugins and shared skills will become just as common as shared libraries and internal developer tools. The earlier you invest in that foundation, the easier it becomes to build consistently across every project.
