External Pattern Integrator Skill

<source_refs>$ARGUMENTS</source_refs>

External Pattern Integrator

Systematically analyze external agent/skill definitions and integrate their strengths into local skills while maintaining workflow coherence.

Arguments

<source_refs/>

Workflow Overview

Phase 1: Parallel Candidate Mapping
├── For each external source (concurrent):
│   ├── Fetch/read the external file
│   ├── Analyze its purpose and patterns
│   └── Scan local files for candidates (frontmatter only)
└── Output: Tracking document with source → candidates mapping

Phase 2: Contextual Enhancement (concurrent per source)
├── Understand local file's workflow context FIRST
├── Compare against external patterns
├── Identify enhancements that fit the workflow stage
├── Add external artifact recognition for interoperability
└── Edit files with coordinated changes

Phase 3: Validation
└── Run linting on all modified files

Phase 1: Parallel Candidate Mapping

Step 1.1: Create Tracking Document

Create a tracking file at .claude/external-pattern-integration-{date}.md:

# External Pattern Integration

**Date**: {YYYY-MM-DD}
**Sources**: {list of URLs/files from arguments}
**Status**: IN_PROGRESS

## Source Analysis

### Source 1: {URL or path}

**Purpose**: {What this external agent/skill does}
**Key Patterns**:
- {Pattern 1}
- {Pattern 2}

**Local Candidates** (by frontmatter similarity):
| Local File | Similarity Reason | Priority |
|------------|-------------------|----------|
| {path} | {why it matches} | {High/Medium/Low} |

### Source 2: {URL or path}
...

Step 1.2: Fetch External Sources

For each URL/file in <source_refs/>:

If URL: Use WebFetch or curl to download to /tmp/external-pattern-{slug}.md If local file: Read directly

Step 1.3: Analyze External Source

For each external source, extract:

Purpose: What problem does it solve?
Key Patterns: What techniques does it use?
Artifact Files: What files does it create/read? (for interoperability)
Workflow Stage: Where in a development workflow does it fit?

Step 1.4: Scan Local Candidates

Scan these locations for candidates (frontmatter only, not full files):

plugins/*/skills/*/SKILL.md
plugins/*/agents/*.md
.claude/skills/*/SKILL.md
.claude/agents/*.md

Match by:

Similar purpose (from description field)
Similar workflow stage
Overlapping functionality

Priority Assignment:

High: Direct functional overlap (same workflow stage, similar purpose)
Medium: Adjacent functionality (related workflow stage)
Low: Tangential (shared patterns but different purpose)

Step 1.5: Deduplicate Candidates

If a local file appears as candidate for multiple external sources:

Assign to the BEST match (highest similarity)
Note secondary matches for cross-reference during enhancement

Phase 2: Contextual Enhancement

Run concurrently for each external source. For each candidate local file:

Step 2.1: Understand Workflow Context

BEFORE comparing, determine:

Is this file part of a multi-file workflow?
- Check for references to other skills/agents in the file
- Check if other files reference this one
- Look for phase indicators (discovery → planning → implementation → verification)
What stage of the workflow is this file for?
- Discovery/Research (gathering context)
- Planning (creating specs, acceptance criteria)
- Implementation (writing code)
- Verification (testing, validation)
- Orchestration (coordinating other agents)
What are the upstream/downstream dependencies?
- What artifacts does this file expect as input?
- What artifacts does this file produce?

Step 2.2: Compare and Identify Enhancements

Read the full external source and full local file. Identify:

| Enhancement Type | Description | Fits Current Stage? | | -------------------- | --------------------------------------------- | ------------------- | | Missing pattern | External has X, local lacks it | Yes/No | | Stronger guidance | External has better instructions for Y | Yes/No | | Better structure | External organizes Z more clearly | Yes/No | | Artifact recognition | External creates files local should recognize | Yes/No |

Critical Rule: Only recommend enhancements that fit the file's workflow stage. If an enhancement belongs in a different stage, note which file should receive it instead.

Step 2.3: Add External Artifact Recognition

For interoperability, add a section to context-gathering skills:

## External Framework Artifacts

<external_artifacts>

When gathering context, also check for these artifacts from external frameworks:

**Get Shit Done (GSD)**:
- `STATE.md` - Current project state and progress
- `ROADMAP.md` - Feature roadmap and planning
- `codebase-map.md` - Generated codebase structure
- `research-*.md` - Research documents
- `plan-*.md` - Execution plans

**BMAD-METHOD**:
- `*.agent.yaml` - Agent definitions
- `workflows/*.md` - Workflow definitions
- `party-mode-session.md` - Multi-agent collaboration notes

If found, incorporate their context into discovery.

</external_artifacts>

Step 2.4: Coordinate Cross-File Changes

If enhancements affect multiple files in a workflow:

List all affected files
Determine the order of changes (upstream before downstream)
Ensure consistency (same terminology, compatible artifacts)
Make changes atomically (all or none)

Step 2.5: Apply Enhancements

Edit local files with:

Clear section markers for new content
Source attribution: SOURCE: Adapted from {external source URL/path}
Preserved existing functionality (additive changes preferred)

Phase 3: Validation

Step 3.1: Run Linting

uv run prek run --files {all modified files}

Fix any issues before proceeding.

Step 3.2: Update Tracking Document

Update the tracking file with:

## Results

**Files Modified**:
| File | Enhancements Applied | Source |
|------|---------------------|--------|
| {path} | {what was added} | {external source} |

**Deferred Enhancements** (didn't fit current files):
| Enhancement | Reason Deferred | Suggested Location |
|-------------|-----------------|-------------------|
| {pattern} | {why} | {where it should go} |

**Status**: COMPLETE

Step 3.3: Add Deferred Items to Backlog

If there are deferred enhancements, create per-item files in .claude/backlog/ via the backlog script:

For each deferred enhancement, invoke the backlog script with appropriate priority:
- P1 (Should Have): Patterns that would significantly improve workflows
- P2 (Could Have): Nice-to-have patterns or minor improvements
- Ideas: Patterns worth exploring but unclear fit

Entry format:

### {Enhancement title}

**Source**: [{tracking-document}]({path-to-tracking-document})
**Added**: {YYYY-MM-DD}
**Description**: {What needs to be done}
**Patterns from**: {external-source-name}
**Suggested location**: {path/to/file.md}

Note in tracking document: "Deferred items added to .claude/backlog/ as per-item files"

Step 3.4: Commit Changes

Stage and commit with message:

feat(skills): integrate patterns from {source names}

Enhancements:
- {file1}: {what was added}
- {file2}: {what was added}

Sources:
- {URL1}
- {URL2}

Success Criteria

[ ] All external sources fetched and analyzed
[ ] Tracking document created with candidate mapping
[ ] Workflow context understood before making changes
[ ] Enhancements fit the file's workflow stage
[ ] Cross-file changes coordinated
[ ] External artifact recognition added for interoperability
[ ] All modified files pass linting
[ ] Deferred enhancements added as per-item files in .claude/backlog/ with priority
[ ] Changes committed with source attribution

Example Usage

User: /external-pattern-integrator https://github.com/glittercowboy/get-shit-done/blob/main/agents/gsd-codebase-mapper.md

Agent Skills: External Pattern Integrator

Install this agent skill to your local

Skill Files