Plugin Engineer

Transform external repositories into Claude Code plugins.

External Repo → Research → Recon → Patterns → Codify → Author → Package → Audit → Plugin

Steps

Clarify target repo and plugin goals
Load the outfitter:research skill for external discovery (docs, APIs, community patterns)
Load the outfitter:codebase-recon skill for internal analysis of target repo
Load the outfitter:patterns skill to extract repeatable patterns worth automating
Load the outfitter:codify skill to map patterns to component types
Author components using outfitter:skills-dev or outfitter:claude-skills
Load the outfitter:claude-plugins skill to package into distributable plugin
Delegate by loading the outfitter:claude-plugin-audit skill for validation

<when_to_use>

Turning a CLI tool into a Claude Code plugin
Creating skills that wrap an external library or API
Building plugin companions for MCP servers
Extracting automation opportunities from a third-party repo
Packaging workflow patterns around external tools

NOT for: plugins from scratch (use claude-plugins), single-skill creation (use skills-dev), existing Claude Code plugins (use claude-plugin-audit)

</when_to_use>

Artifact Structure

Track progress with artifacts in artifacts/plugin-engineer/:

artifacts/plugin-engineer/
├── discovery.md      # Research output (docs, APIs, community patterns)
├── recon.md          # Codebase analysis (structure, conventions, key files)
├── patterns.md       # Extracted patterns with automation value
├── mapping.md        # Pattern → component mapping decisions
├── components/       # Authored skills, agents, hooks, commands
│   ├── skill-1/
│   ├── skill-2/
│   └── ...
└── audit.md          # Plugin validation results

Quick Mode

For simple repos (single-purpose CLI, small API wrapper):

Skip stages 3-4 — go direct from recon to authoring
Create 1-2 skills covering primary use cases
Package immediately

Trigger: User says "quick", repo has < 5 main commands, or clear single purpose.

Stages

Load the maintain-tasks skill for stage tracking. Stages advance only.

Stage	Skill	activeForm
1. Discovery	`outfitter:research`	"Researching external docs"
2. Recon	`outfitter:codebase-recon`	"Analyzing target repo"
3. Patterns	`outfitter:patterns`	"Extracting patterns"
4. Mapping	`outfitter:codify`	"Mapping to components"
5. Authoring	`outfitter:skills-dev`	"Creating components"
6. Packaging	`outfitter:claude-plugins`	"Packaging plugin"
7. Audit	`outfitter:claude-plugin-audit`	"Validating plugin"

Stage 1: Discovery

Load outfitter:research skill. Gather external docs, community patterns, pain points.

See stage-1-discovery.md for details.

Stage 2: Recon

Load outfitter:codebase-recon skill. Analyze structure, API surface, conventions.

See stage-2-recon.md for details.

Stage 3: Patterns

Load outfitter:patterns skill. Extract workflows, command sequences, decision points.

See stage-3-patterns.md for details.

Stage 4: Mapping

Load outfitter:codify skill. Map patterns to component types (skill, command, hook, agent).

See stage-4-mapping.md for details.

Stage 5: Authoring

Load appropriate skill per component type. Create in artifacts/plugin-engineer/components/.

See stage-5-authoring.md for details.

Stage 6: Packaging

Load outfitter:claude-plugins skill. Create plugin structure with manifest and README.

Ask: "Do you have an existing marketplace to add this plugin to?" If yes, prepare the marketplace entry.

See stage-6-packaging.md for details.

Stage 7: Audit

Delegate by loading outfitter:claude-plugin-audit skill. Validate before distribution.

See stage-7-audit.md for details.

<decision_points>

Key decisions during engineering process:

Which patterns to automate?

High frequency + medium complexity = best ROI
Low frequency + high complexity = consider if audience is technical
One-off patterns = skip

Skills vs Commands?

Multi-step, needs guidance → Skill
Quick action, obvious usage → Command
User entry point to skill → Both (command loads skill)

Include agents?

Only for complex repos with orchestration needs
Most plugins don't need custom agents
Consider if existing agents (analyst, engineer) suffice

Quick mode vs full pipeline?

Single-purpose tool → Quick mode
Complex tool with many features → Full pipeline
Unclear → Start with recon, decide after

</decision_points>

ALWAYS:

Start with discovery before touching code
Track artifacts at each stage
Validate patterns have 3+ use cases before creating components
Use existing skills for authoring (don't reinvent)
Run audit before declaring complete

NEVER:

Skip recon stage (even for familiar repos)
Create agents without clear orchestration need
Package without audit validation
Over-engineer (simpler plugin > feature-complete plugin)

Stage guides:

overview.md — quick reference
stage-1-discovery.md — external research
stage-2-recon.md — codebase analysis
stage-3-patterns.md — pattern extraction
stage-4-mapping.md — component selection
stage-5-authoring.md — creating components
stage-6-packaging.md — plugin structure
stage-7-audit.md — validation
repo-types.md — CLI vs Library vs MCP patterns

Skills loaded:

outfitter:research — external discovery methodology
outfitter:codebase-recon — repo analysis approach
outfitter:patterns — pattern extraction
outfitter:codify — pattern-to-component mapping
outfitter:claude-plugins — plugin packaging