USP

It uniquely combines a diverse set of engineering, documentation, and productivity skills with an innovative code execution runtime, drastically reducing token usage (90%+) and speeding up bulk operations compared to traditional context-ba…

Use cases

01Breaking down feature requests into detailed plans
02Automating git commits and pushes
03Creating visual documentation (diagrams, flowcharts)
04Auditing code quality and bootstrapping projects
05Performing bulk code refactoring and file analysis

Detected files (8)

engineering-workflow-plugin/skills/ensemble-solving/SKILL.mdskill

Show content (5007 bytes)

---
name: ensemble-solving
description: Generate multiple diverse solutions in parallel and select the best. Use for architecture decisions, code generation with multiple valid approaches, or creative tasks where exploring alternatives improves quality.
---

# Ensemble Problem Solving

Generate multiple solutions in parallel by spawning 3 subagents with different approaches, then evaluate and select the best result.

## When to Use

**Activation phrases:**
- "Give me options for..."
- "What's the best way to..."
- "Explore different approaches..."
- "I want to see alternatives..."
- "Compare approaches for..."
- "Which approach should I use..."

**Good candidates:**
- Architecture decisions with trade-offs
- Code generation with multiple valid implementations
- API design with different philosophies
- Naming, branding, documentation style
- Refactoring strategies
- Algorithm selection

**Skip ensemble for:**
- Simple lookups or syntax questions
- Single-cause bug fixes
- File operations, git commands
- Deterministic configuration changes
- Tasks with one obvious solution

## What It Does

1. **Analyzes the task** to determine if ensemble approach is valuable
2. **Generates 3 distinct prompts** using appropriate diversification strategy
3. **Spawns 3 parallel subagents** to develop solutions independently
4. **Evaluates all solutions** using weighted criteria
5. **Returns the best solution** with explanation and alternatives summary

## Approach

### Step 1: Classify Task Type

Determine which category fits:
- **Code Generation**: Functions, classes, APIs, algorithms
- **Architecture/Design**: System design, data models, patterns
- **Creative**: Writing, naming, documentation

### Step 2: Invoke Ensemble Orchestrator

```
Task tool with:
- subagent_type: 'ensemble-orchestrator'
- description: 'Generate and evaluate 3 parallel solutions'
- prompt: [User's original task with full context]
```

The orchestrator handles:
- Prompt diversification
- Parallel execution
- Solution evaluation
- Winner selection

### Step 3: Present Result

The orchestrator returns:
- The winning solution (in full)
- Evaluation scores for all 3 approaches
- Why the winner was selected
- When alternatives might be preferred

## Diversification Strategies

**For Code (Constraint Variation):**
| Approach | Focus |
|----------|-------|
| Simplicity | Minimal code, maximum readability |
| Performance | Efficient, optimized |
| Extensibility | Clean abstractions, easy to extend |

**For Architecture (Approach Variation):**
| Approach | Focus |
|----------|-------|
| Top-down | Requirements → Interfaces → Implementation |
| Bottom-up | Primitives → Composition → Structure |
| Lateral | Analogies from other domains |

**For Creative (Persona Variation):**
| Approach | Focus |
|----------|-------|
| Expert | Technical precision, authoritative |
| Pragmatic | Ship-focused, practical |
| Innovative | Creative, unconventional |

## Evaluation Rubric

| Criterion | Base Weight | Description |
|-----------|-------------|-------------|
| Correctness | 30% | Solves the problem correctly |
| Completeness | 20% | Addresses all requirements |
| Quality | 20% | How well-crafted |
| Clarity | 15% | How understandable |
| Elegance | 15% | How simple/beautiful |

Weights adjust based on task type.

## Example

**User:** "What's the best way to implement a rate limiter?"

**Skill:**
1. Classifies as Code Generation
2. Invokes ensemble-orchestrator
3. Three approaches generated:
   - Simple: Token bucket with in-memory counter
   - Performance: Sliding window with atomic operations
   - Extensible: Strategy pattern with pluggable backends
4. Evaluation selects extensible approach (score 8.4)
5. Returns full implementation with explanation

**Output:**
```
## Selected Solution

[Full rate limiter implementation with strategy pattern]

## Why This Solution Won

The extensible approach scored highest (8.4) because it provides
a clean abstraction that works for both simple use cases and
complex distributed scenarios. The strategy pattern allows
swapping Redis/Memcached backends without code changes.

## Alternatives

- **Simple approach**: Best if you just need basic in-memory
  limiting and will never scale beyond one process.

- **Performance approach**: Best for high-throughput scenarios
  where every microsecond matters.
```

## Success Criteria

- 3 genuinely different solutions generated
- Clear evaluation rationale provided
- Winner selected with confidence
- Alternatives summarized with use cases
- User understands trade-offs

## Token Cost

~4x overhead vs single attempt. Worth it for:
- High-stakes architecture decisions
- Creative work where first attempt rarely optimal
- Learning scenarios where seeing alternatives is valuable
- Code that will be maintained long-term

## Integration

- **feature-planning**: Can ensemble architecture decisions
- **code-auditor**: Can ensemble analysis perspectives
- **plan-implementer**: Executes the winning approach

engineering-workflow-plugin/skills/feature-planning/SKILL.mdskill

Show content (3828 bytes)

---
name: feature-planning
description: Break down feature requests into detailed, implementable plans with clear tasks. Use when user requests a new feature, enhancement, or complex change.
---

# Feature Planning

Systematically analyze feature requests and create detailed, actionable implementation plans.

## When to Use

- Requests new feature ("add user authentication", "build dashboard")
- Asks for enhancements ("improve performance", "add export")
- Describes complex multi-step changes
- Explicitly asks for planning ("plan how to implement X")
- Provides vague requirements needing clarification

## Planning Workflow

### 1. Understand Requirements

**Ask clarifying questions:**
- What problem does this solve?
- Who are the users?
- Specific technical constraints?
- What does success look like?

**Explore the codebase:**
Use Task tool with `subagent_type='Explore'` and `thoroughness='medium'` to understand:
- Existing architecture and patterns
- Similar features to reference
- Where new code should live
- What will be affected

### 2. Analyze & Design

**Identify components:**
- Database changes (models, migrations, schemas)
- Backend logic (API endpoints, business logic, services)
- Frontend changes (UI, state, routing)
- Testing requirements
- Documentation updates

**Consider architecture:**
- Follow existing patterns (check CLAUDE.md)
- Identify reusable components
- Plan error handling and edge cases
- Consider performance implications
- Think about security and validation

**Check dependencies:**
- New packages/libraries needed
- Compatibility with existing stack
- Configuration changes required

### 3. Create Implementation Plan

Break feature into **discrete, sequential tasks**:

```markdown
## Feature: [Feature Name]

### Overview
[Brief description of what will be built and why]

### Architecture Decisions
- [Key decision 1 and rationale]
- [Key decision 2 and rationale]

### Implementation Tasks

#### Task 1: [Component Name]
- **File**: `path/to/file.py:123`
- **Description**: [What needs to be done]
- **Details**:
  - [Specific requirement 1]
  - [Specific requirement 2]
- **Dependencies**: None (or list task numbers)

#### Task 2: [Component Name]
...

### Testing Strategy
- [What types of tests needed]
- [Critical test cases to cover]

### Integration Points
- [How this connects with existing code]
- [Potential impacts on other features]
```

**Include specific references:**
- File paths with line numbers (`src/utils/auth.py:45`)
- Existing patterns to follow
- Relevant documentation

### 4. Review Plan with User

Confirm:
- Does this match expectations?
- Missing requirements?
- Adjust priorities or approach?
- Ready to proceed?

### 5. Execute with plan-implementer

Launch plan-implementer agent for each task:

```
Task tool with:
- subagent_type: 'plan-implementer'
- description: 'Implement [task name]'
- prompt: Detailed task description from plan
```

**Execution strategy:**
- Implement sequentially (respect dependencies)
- Verify each task before next
- Adjust plan if issues discovered
- Let test-fixing skill handle failures
- Let git-pushing skill handle commits

## Best Practices

**Planning:**
- Start broad, then specific
- Reference existing code patterns
- Include file paths and line numbers
- Think through edge cases upfront
- Keep tasks focused and atomic

**Communication:**
- Explain architectural decisions
- Highlight trade-offs and alternatives
- Be explicit about assumptions
- Provide context for future maintainers

**Execution:**
- Implement one task at a time
- Verify before moving forward
- Keep user informed
- Adapt based on discoveries

## Integration

- **plan-implementer agent**: Receives task specs, implements
- **test-fixing skill**: Auto-triggered on test failures
- **git-pushing skill**: Triggered for commits

code-operations-plugin/skills/code-execution/SKILL.mdskill

Show content (3196 bytes)

---
name: code-execution
description: Execute Python code locally with marketplace API access for 90%+ token savings on bulk operations. Activates when user requests bulk operations (10+ files), complex multi-step workflows, iterative processing, or mentions efficiency/performance.
---

# Code Execution

Execute Python locally with API access. **90-99% token savings** for bulk operations.

## When to Use

- Bulk operations (10+ files)
- Complex multi-step workflows
- Iterative processing across many files
- User mentions efficiency/performance

## How to Use

Use direct Python imports in Claude Code:

```python
from execution_runtime import fs, code, transform, git

# Code analysis (metadata only!)
functions = code.find_functions('app.py', pattern='handle_.*')

# File operations
code_block = fs.copy_lines('source.py', 10, 20)
fs.paste_code('target.py', 50, code_block)

# Bulk transformations
result = transform.rename_identifier('.', 'oldName', 'newName', '**/*.py')

# Git operations
git.git_add(['.'])
git.git_commit('feat: refactor code')
```

**If not installed:** Run `~/.claude/plugins/marketplaces/mhattingpete-claude-skills/execution-runtime/setup.sh`

## Available APIs

- **Filesystem** (`fs`): copy_lines, paste_code, search_replace, batch_copy
- **Code Analysis** (`code`): find_functions, find_classes, analyze_dependencies - returns METADATA only!
- **Transformations** (`transform`): rename_identifier, remove_debug_statements, batch_refactor
- **Git** (`git`): git_status, git_add, git_commit, git_push

## Pattern

1. **Analyze locally** (metadata only, not source)
2. **Process locally** (all operations in execution)
3. **Return summary** (not data!)

## Examples

**Bulk refactor (50 files):**
```python
from execution_runtime import transform
result = transform.rename_identifier('.', 'oldName', 'newName', '**/*.py')
# Returns: {'files_modified': 50, 'total_replacements': 247}
```

**Extract functions:**
```python
from execution_runtime import code, fs

functions = code.find_functions('app.py', pattern='.*_util$')  # Metadata only!
for func in functions:
    code_block = fs.copy_lines('app.py', func['start_line'], func['end_line'])
    fs.paste_code('utils.py', -1, code_block)

result = {'functions_moved': len(functions)}
```

**Code audit (100 files):**
```python
from execution_runtime import code
from pathlib import Path

files = list(Path('.').glob('**/*.py'))
issues = []

for file in files:
    deps = code.analyze_dependencies(str(file))  # Metadata only!
    if deps.get('complexity', 0) > 15:
        issues.append({'file': str(file), 'complexity': deps['complexity']})

result = {'files_audited': len(files), 'high_complexity': len(issues)}
```

## Best Practices

✅ Return summaries, not data
✅ Use code_analysis (returns metadata, not source)
✅ Batch operations
✅ Handle errors, return error count

❌ Don't return all code to context
❌ Don't read full source when you need metadata
❌ Don't process files one by one

## Token Savings

| Files | Traditional | Execution | Savings |
|-------|-------------|-----------|---------|
| 10 | 5K tokens | 500 | 90% |
| 50 | 25K tokens | 600 | 97.6% |
| 100 | 150K tokens | 1K | 99.3% |

code-operations-plugin/skills/file-operations/SKILL.mdskill

Show content (2540 bytes)

---
name: file-operations
description: Analyze files and get detailed metadata including size, line counts, modification times, and content statistics. Use when users request file information, statistics, or analysis without modifying files.
---

# File Operations

Analyze files and retrieve metadata using Claude's native tools without modifying files.

## When to Use

- "analyze [file]"
- "get file info for [file]"
- "how many lines in [file]"
- "compare [file1] and [file2]"
- "file statistics"

## Core Operations

### File Size & Metadata
```bash
stat -f "%z bytes, modified %Sm" [file_path]  # Single file
ls -lh [directory]                             # Multiple files
du -h [file_path]                              # Human-readable size
```

### Line Counts
```bash
wc -l [file_path]                              # Single file
wc -l [file1] [file2]                          # Multiple files
find [dir] -name "*.py" | xargs wc -l          # Directory total
```

### Content Analysis
Use **Read** to analyze structure, then count functions/classes/imports.

### Pattern Search
```
Grep(pattern="^def ", output_mode="count", path="src/")        # Count functions
Grep(pattern="TODO|FIXME", output_mode="content", -n=true)    # Find TODOs
Grep(pattern="^import ", output_mode="count")                 # Count imports
```

### Find Files
```
Glob(pattern="**/*.py")
```

## Workflow Examples

### Comprehensive File Analysis
1. Get size/mod time: `stat -f "%z bytes, modified %Sm" file.py`
2. Count lines: `wc -l file.py`
3. Read file: `Read(file_path="file.py")`
4. Count functions: `Grep(pattern="^def ", output_mode="count")`
5. Count classes: `Grep(pattern="^class ", output_mode="count")`

### Compare File Sizes
1. Find files: `Glob(pattern="src/**/*.py")`
2. Get sizes: `ls -lh src/**/*.py`
3. Total size: `du -sh src/*.py`

### Code Quality Metrics
1. Total lines: `find . -name "*.py" | xargs wc -l`
2. Test files: `find . -name "test_*.py" | wc -l`
3. TODOs: `Grep(pattern="TODO|FIXME|HACK", output_mode="count")`

### Find Largest Files
```bash
find . -type f -not -path "./node_modules/*" -exec du -h {} + | sort -rh | head -20
```

## Best Practices

- **Non-destructive**: Use Read/stat/wc, never modify
- **Efficient**: Read small files fully, use Grep for large files
- **Context-aware**: Compare to project averages, suggest optimizations

## Integration

Works with:
- **code-auditor**: Comprehensive analysis
- **code-transfer**: After identifying large files
- **codebase-documenter**: Understanding file purposes

engineering-workflow-plugin/skills/git-pushing/SKILL.mdskill

Show content (1084 bytes)

---
name: git-pushing
description: Stage, commit, and push git changes with conventional commit messages. Use when user wants to commit and push changes, mentions pushing to remote, or asks to save and push their work. Also activates when user says "push changes", "commit and push", "push this", "push to github", or similar git workflow requests.
---

# Git Push Workflow

Stage all changes, create a conventional commit, and push to the remote branch.

## When to Use

Automatically activate when the user:
- Explicitly asks to push changes ("push this", "commit and push")
- Mentions saving work to remote ("save to github", "push to remote")
- Completes a feature and wants to share it
- Says phrases like "let's push this up" or "commit these changes"

## Workflow

**ALWAYS use the script** - do NOT use manual git commands:

```bash
bash skills/git-pushing/scripts/smart_commit.sh
```

With custom message:
```bash
bash skills/git-pushing/scripts/smart_commit.sh "feat: add feature"
```

Script handles: staging, conventional commit message, Claude footer, push with -u flag.

code-operations-plugin/skills/code-refactor/SKILL.mdskill

Show content (3358 bytes)

---
name: code-refactor
description: Perform bulk code refactoring operations like renaming variables/functions across files, replacing patterns, and updating API calls. Use when users request renaming identifiers, replacing deprecated code patterns, updating method calls, or making consistent changes across multiple locations.
---

# Code Refactor

Systematic code refactoring across files. **Auto-switches to execution mode** for 10+ files (90% token savings).

## Mode Selection

- **1-9 files**: Use native tools (Grep + Edit with replace_all)
- **10+ files**: Automatically use `code-execution` skill

**Execution example (50 files):**
```python
from api.code_transform import rename_identifier
result = rename_identifier('.', 'oldName', 'newName', '**/*.py')
# Returns: {'files_modified': 50, 'total_replacements': 247}
# ~500 tokens vs ~25,000 tokens traditional
```

## When to Use

- "rename [identifier] to [new_name]"
- "replace all [pattern] with [replacement]"
- "refactor to use [new_pattern]"
- "update all calls to [function/API]"
- "convert [old_pattern] to [new_pattern]"

## Core Workflow (Native Mode)

### 1. Find All Occurrences
```
Grep(pattern="getUserData", output_mode="files_with_matches")     # Find files
Grep(pattern="getUserData", output_mode="content", -n=true, -B=2, -A=2)  # Verify with context
```

### 2. Replace All Instances
```
Edit(
  file_path="src/api.js",
  old_string="getUserData",
  new_string="fetchUserData",
  replace_all=true
)
```

### 3. Verify Changes
```
Grep(pattern="getUserData", output_mode="files_with_matches")  # Should return none
```

## Workflow Examples

### Rename Function
1. Find: `Grep(pattern="getUserData", output_mode="files_with_matches")`
2. Count: "Found 15 occurrences in 5 files"
3. Replace in each file with `replace_all=true`
4. Verify: Re-run Grep
5. Suggest: Run tests

### Replace Deprecated Pattern
1. Find: `Grep(pattern="\\bvar\\s+\\w+", output_mode="content", -n=true)`
2. Analyze: Check if reassigned (let) or constant (const)
3. Replace: `Edit(old_string="var count = 0", new_string="let count = 0")`
4. Verify: `npm run lint`

### Update API Calls
1. Find: `Grep(pattern="/api/auth/login", output_mode="content", -n=true)`
2. Replace: `Edit(old_string="'/api/auth/login'", new_string="'/api/v2/authentication/login'", replace_all=true)`
3. Test: Recommend integration tests

## Best Practices

**Planning:**
- Find all instances first
- Review context of each match
- Inform user of scope
- Consider edge cases (strings, comments)

**Safe Process:**
1. Search → Find all
2. Analyze → Verify appropriate
3. Inform → Tell user scope
4. Execute → Make changes
5. Verify → Confirm applied
6. Test → Suggest running tests

**Edge Cases:**
- Strings/comments: Ask if should update
- Exported APIs: Warn of breaking changes
- Case sensitivity: Be explicit

## Tool Reference

**Edit with replace_all:**
- `replace_all=true`: Replace all occurrences
- `replace_all=false`: Replace only first (or fail if multiple)
- Must match EXACTLY (whitespace, quotes)

**Grep patterns:**
- `-n=true`: Show line numbers
- `-B=N, -A=N`: Context lines
- `-i=true`: Case-insensitive
- `type="py"`: Filter by file type

## Integration

- **test-fixing**: Fix broken tests after refactoring
- **code-transfer**: Move refactored code
- **feature-planning**: Plan large refactorings

code-operations-plugin/skills/code-transfer/SKILL.mdskill

Show content (4167 bytes)

---
name: code-transfer
description: Transfer code between files with line-based precision. Use when users request copying code from one location to another, moving functions or classes between files, extracting code blocks, or inserting code at specific line numbers.
---

# Code Transfer

Transfer code between files with precise line-based control. **Dual-mode operation**: native tools (1-10 files) or execution mode (10+ files, 90% token savings).

## Operation Modes

### Basic Mode (Default)
Use Read, Edit, Bash scripts for 1-10 file operations. Works immediately, no setup required.

### Execution Mode (10+ files)
```python
from api.filesystem import batch_copy
from api.code_analysis import find_functions

functions = find_functions('app.py', pattern='handle_.*')
operations = [{
    'source_file': 'app.py',
    'start_line': f['start_line'],
    'end_line': f['end_line'],
    'target_file': 'handlers.py',
    'target_line': -1
} for f in functions]
batch_copy(operations)
```

## When to Use

- "copy this code to [file]"
- "move [function/class] to [file]"
- "extract this to a new file"
- "insert at line [number]"
- "reorganize into separate files"

## Core Operations

### 1. Extract Source Code
```
Read(file_path="src/auth.py")                              # Full file
Read(file_path="src/auth.py", offset=10, limit=20)         # Line range
Grep(pattern="def authenticate", -n=true, -A=10)           # Find function
```

### 2. Insert at Specific Line
Use `line_insert.py` script for line-based insertion:

```bash
python3 skills/code-transfer/scripts/line_insert.py <file> <line_number> <code> [--backup]
```

**Examples:**
```bash
# Insert function at line 50
python3 skills/code-transfer/scripts/line_insert.py src/utils.py 50 "def helper():\n    pass"

# Insert with backup
python3 skills/code-transfer/scripts/line_insert.py src/utils.py 50 "code" --backup

# Insert at beginning
python3 skills/code-transfer/scripts/line_insert.py src/new.py 1 "import os"
```

**When to use:**
- User specifies exact line number
- Inserting into new/empty files
- Inserting at beginning/end without context

### 3. Insert Relative to Content
Use **Edit** when insertion point is relative to existing code:

```
Edit(
  file_path="src/utils.py",
  old_string="def existing():\n    pass",
  new_string="def existing():\n    pass\n\ndef new():\n    return True"
)
```

## Workflow Examples

### Copy Function Between Files
1. Find: `Grep(pattern="def validate_user", -n=true, -A=20)`
2. Extract: `Read(file_path="auth.py", offset=45, limit=15)`
3. Check target: `Read(file_path="validators.py")`
4. Insert: Use `line_insert.py` or Edit based on context

### Extract Class to New File
1. Locate: `Grep(pattern="class DatabaseConnection", -n=true, -A=50)`
2. Extract: `Read(file_path="original.py", offset=100, limit=50)`
3. Create: `Write(file_path="database.py", content="<extracted>")`
4. Update imports: `Edit` in original file
5. Remove old class: `Edit` with replacement

### Insert at Specific Line
1. Validate: `Read(file_path="main.py", offset=20, limit=10)`
2. Insert: `python3 skills/code-transfer/scripts/line_insert.py main.py 25 "logger.info('...')" --backup`
3. Verify: `Read(file_path="main.py", offset=23, limit=5)`

### Reorganize Into Modules
1. Analyze: `Read(file_path="utils.py")`
2. Identify groups: `Grep(pattern="^def |^class ", -n=true)`
3. Extract each category: `Write` new files
4. Update original: Re-export or redirect

## Best Practices

**Planning:**
- Understand dependencies (imports, references)
- Identify exact start/end of code block
- Check target file structure
- Ensure necessary imports included

**Preservation:**
- Include docstrings and comments
- Transfer related functions together
- Update imports in both files
- Maintain formatting/indentation

**Validation:**
- Verify insertion placement
- Check syntax
- Test imports
- Suggest running tests

**Backups:**
- Use `--backup` for significant changes
- Critical file operations
- Large deletions

## Integration

- **code-refactor**: Refactor after transferring
- **test-fixing**: Run tests after reorganizing
- **feature-planning**: Plan large reorganizations

.claude-plugin/marketplace.jsonmarketplace

Show content (1586 bytes)

{
  "name": "mhattingpete-claude-skills",
  "owner": {
    "name": "mhattingpete",
    "email": "noreply@github.com"
  },
  "plugins": [
    {
      "name": "engineering-workflow-skills",
      "source": "./engineering-workflow-plugin",
      "description": "Skills for common software engineering workflows including git operations, test fixing, code review implementation, and feature planning with plan-implementer agent",
      "version": "1.1.0",
      "author": {
        "name": "mhattingpete"
      }
    },
    {
      "name": "visual-documentation-skills",
      "source": "./visual-documentation-plugin",
      "description": "Skills for creating stunning visual HTML documentation with modern UI design, SVG diagrams, flowcharts, dashboards, timelines, and technical documentation",
      "version": "1.0.0",
      "author": {
        "name": "mhattingpete"
      }
    },
    {
      "name": "productivity-skills",
      "source": "./productivity-skills-plugin",
      "description": "Productivity and workflow optimization skills for analyzing usage patterns, auditing code, bootstrapping projects, and generating documentation",
      "version": "1.0.0",
      "author": {
        "name": "mhattingpete"
      }
    },
    {
      "name": "code-operations-skills",
      "source": "./code-operations-plugin",
      "description": "High-precision code manipulation operations including line-based insertion, bulk refactoring, and file analysis - converted from code-copy-mcp",
      "version": "1.0.0",
      "author": {
        "name": "mhattingpete"
      }
    }
  ]
}

README

Claude Skills Marketplace

A curated marketplace of Claude Code plugins for software engineering workflows.

Repository Structure

claude-skills-marketplace/
├── .claude-plugin/
│   └── marketplace.json              # Marketplace manifest
├── execution-runtime/                 # 🚀 Code execution environment (NEW!)
│   ├── api/                           # Importable API library
│   ├── mcp-server/                    # FastMCP server
│   ├── setup.sh                       # One-command installation
│   └── README.md
├── engineering-workflow-plugin/       # Engineering workflow plugin
│   ├── .claude-plugin/
│   │   └── plugin.json               # Plugin manifest
│   ├── agents/
│   │   └── plan-implementer.md       # Plan implementation agent
│   ├── skills/
│   │   ├── feature-planning/         # Feature planning skill
│   │   ├── git-pushing/              # Git automation skill
│   │   ├── review-implementing/      # Code review skill
│   │   └── test-fixing/              # Test fixing skill
│   └── README.md
├── visual-documentation-plugin/       # Visual documentation plugin
│   ├── .claude-plugin/
│   │   └── plugin.json               # Plugin manifest
│   ├── skills/
│   │   ├── architecture-diagram-creator/  # Architecture diagram skill
│   │   ├── dashboard-creator/        # Dashboard creation skill
│   │   ├── flowchart-creator/        # Flowchart creation skill
│   │   ├── technical-doc-creator/    # Technical documentation skill
│   │   └── timeline-creator/         # Timeline creation skill
│   ├── EXAMPLES.md
│   └── README.md
├── productivity-skills-plugin/        # Productivity & optimization plugin
│   ├── .claude-plugin/
│   │   └── plugin.json               # Plugin manifest
│   ├── skills/
│   │   ├── code-auditor/             # Code auditing skill
│   │   ├── codebase-documenter/      # Codebase documentation skill
│   │   ├── conversation-analyzer/    # Usage analysis skill
│   │   └── project-bootstrapper/     # Project setup skill
│   └── README.md
├── code-operations-plugin/            # Code manipulation plugin
│   ├── .claude-plugin/
│   │   └── plugin.json               # Plugin manifest
│   ├── skills/
│   │   ├── code-execution/           # 🚀 Python execution skill (NEW!)
│   │   │   └── examples/             # Example scripts
│   │   ├── code-transfer/            # Code transfer skill
│   │   │   └── scripts/
│   │   │       └── line_insert.py    # Line-based insertion script
│   │   ├── code-refactor/            # Bulk refactoring skill
│   │   └── file-operations/          # File analysis skill
│   └── README.md
├── LICENSE
└── README.md

What are Skills and Agents?

Skills are model-invoked capabilities that extend Claude Code's functionality. Unlike slash commands that require explicit user activation, Skills are automatically triggered by Claude based on context and the Skill's description.

Each Skill consists of a SKILL.md file with:

YAML frontmatter (name, description, metadata)
Detailed instructions for Claude
Optional supporting files (scripts, templates, references)

Agents are specialized Claude instances that can be invoked by Claude to handle specific types of work. They run independently with their own context and can use different models optimized for their task.

Each Agent consists of an AGENT.md file with:

YAML frontmatter (name, description, model selection)
Specialized instructions and constraints
Decision-making frameworks for their domain

Skills and Agents work together: Skills can orchestrate when to invoke Agents, and Agents can use Skills while executing their tasks.

🚀 NEW: Execution Runtime (90%+ Token Savings)

The marketplace now includes a code execution environment implementing the Anthropic code execution pattern. Instead of loading code through context, Claude executes Python locally with API access—achieving 90-99% token reduction for bulk operations.

Quick Benefits

✅ Massive token savings: Process 100 files with 1K tokens instead of 100K ✅ Faster operations: Local execution vs multiple API round-trips ✅ Stateful workflows: Resume multi-step refactoring across sessions ✅ Auto-secure: PII/secret masking, sandboxed execution

Setup (2 minutes)

# After installing marketplace plugin
~/.claude/plugins/marketplaces/mhattingpete-claude-skills/execution-runtime/setup.sh

When It Activates

Skills automatically use execution mode for:

Bulk operations (10+ files)
Complex multi-step workflows
Iterative processing
Codebase-wide analysis

Example: "Rename getUserData to fetchUserData in all Python files"

Without execution: ~25,000 tokens (read/edit 50 files)
With execution: ~600 tokens (script + summary) - 97.6% savings

Full documentation →

Installation

Install from Marketplace

# In Claude Code - installs the entire plugin with all skills and agents
/plugin marketplace add mhattingpete/claude-skills-marketplace

This installs the engineering-workflow-plugin which includes all skills and the plan-implementer agent.

To install individual plugins:

# Install only engineering workflows
/plugin marketplace add mhattingpete/claude-skills-marketplace/engineering-workflow-plugin

# Install only visual documentation
/plugin marketplace add mhattingpete/claude-skills-marketplace/visual-documentation-plugin

# Install only productivity skills
/plugin marketplace add mhattingpete/claude-skills-marketplace/productivity-skills-plugin

# Install only code operations
/plugin marketplace add mhattingpete/claude-skills-marketplace/code-operations-plugin

Available Plugins

Engineering Workflow Plugin

Skills for common software engineering workflows including git operations, test fixing, code review implementation, and feature planning.

View Plugin Documentation →

Visual Documentation Plugin

Skills for creating stunning visual HTML documentation with modern UI design, SVG diagrams, flowcharts, dashboards, timelines, and comprehensive project architecture diagrams.

View Plugin Documentation →

Productivity Skills Plugin

Productivity and workflow optimization skills for analyzing usage patterns, auditing code quality, bootstrapping projects, and generating comprehensive documentation.

View Plugin Documentation →

Code Operations Plugin

High-precision code manipulation operations including line-based insertion, bulk refactoring, and file analysis. Converted from code-copy-mcp to native Claude Code skills.

View Plugin Documentation →

Available Skills

Feature Development

`feature-planning`

Break down feature requests into detailed, implementable plans with clear tasks that can be executed by the plan-implementer agent.

Activates when: User requests a new feature, enhancement, or complex change requiring planning.

Example usage:

"Add user authentication"
"Build a dashboard for analytics"
"Plan how to implement export functionality"

Works with: plan-implementer agent for execution

Git & Version Control

`git-pushing`

Automatically stage, commit with conventional commit messages, and push changes to remote.

Activates when: User mentions pushing changes, committing work, or saving to remote.

Example usage:

"Push these changes"
"Commit and push to github"
"Let's save this work"

Testing & Quality

`test-fixing`

Systematically identify and fix failing tests using smart error grouping strategies.

Activates when: User reports test failures, asks to fix tests, or wants test suite passing.

Example usage:

"Fix the failing tests"
"Make the test suite green"
"Tests are broken after my refactor"

Code Review

`review-implementing`

Process and implement code review feedback systematically with todo tracking.

Activates when: User provides reviewer comments, PR feedback, or asks to address review notes.

Example usage:

"Implement this review feedback: [paste comments]"
"Address these PR comments"
"The reviewer suggested these changes"

Code Operations

`code-execution` 🆕

Execute Python code locally with marketplace API access for 90%+ token savings on bulk operations.

Activates when: Bulk operations (10+ files), complex workflows, codebase-wide transformations, performance needs.

Example usage:

"Refactor 50 files to use new API"
"Extract all utility functions to separate files"
"Audit code quality across entire codebase"

Token savings: 97-99% for bulk operations (25K → 600 tokens)

`code-transfer`

Transfer code between files with line-based precision. Auto-uses execution mode for 10+ file operations.

Activates when: User requests copying code between files, moving functions/classes, extracting code, or inserting at specific line numbers.

Example usage:

"Copy the authenticate function from auth.py to utils.py"
"Move this class to a separate file"
"Extract this function to a new file"
"Insert this code at line 45"

Key feature: Includes Python script for precise line-number-based insertion where Edit tool's string matching isn't suitable.

`code-refactor`

Perform bulk code refactoring operations. Auto-switches to execution mode for 10+ files (90% token savings).

Activates when: User requests renaming identifiers, replacing deprecated patterns, updating API calls, or making consistent changes across multiple locations.

Example usage:

"Rename getUserData to fetchUserData everywhere"
"Replace all var declarations with let or const"
"Update all authentication API calls to use the new endpoint"
"Convert callbacks to async/await"

`file-operations`

Analyze files and get detailed metadata without modifying them.

Activates when: User requests file information, statistics, or analysis without making changes.

Example usage:

"Analyze this file"
"How many lines in app.py?"
"Compare the sizes of all Python files"
"Give me code quality metrics for the project"

Productivity & Analysis

`conversation-analyzer`

Analyze Claude Code conversation history to identify patterns, common mistakes, and workflow optimization opportunities.

Activates when: User wants to understand usage patterns, optimize workflow, or check best practices.

Example usage:

"Analyze my conversations"
"Review my history"
"How can I improve my workflow"

`code-auditor`

Comprehensive codebase analysis covering architecture, code quality, security, performance, testing, and maintainability.

Activates when: User wants to audit code quality, identify technical debt, find security issues, or assess test coverage.

Example usage:

"Audit the code"
"Check for issues"
"Review the codebase"
"Security audit"

`codebase-documenter`

Generate comprehensive documentation explaining how a codebase works, including architecture, key components, data flow, and development guidelines.

Activates when: User wants to understand unfamiliar code, create onboarding docs, document architecture, or explain how the system works.

Example usage:

"Explain this codebase"
"Document the architecture"
"How does this code work"
"Create developer documentation"

`project-bootstrapper`

Set up new projects or improve existing projects with development best practices, tooling, documentation, and workflow automation.

Activates when: User wants to start a new project, improve project structure, add development tooling, or establish professional workflows.

Example usage:

"Set up a new project"
"Bootstrap this project"
"Add best practices"
"Improve project structure"

Visual Documentation

`architecture-diagram-creator`

Create comprehensive HTML architecture diagrams covering business objectives, data flows, processing pipelines, features (functional and non-functional), system architecture, and deployment information.

Activates when: User requests architecture diagrams, system overviews, project documentation, or high-level system design.

Example usage:

"Create an architecture diagram for this project"
"Generate a project architecture overview"
"Document the system architecture with data flows and processing pipeline"

`flowchart-creator`

Create stunning HTML flowcharts and process flow diagrams with decision trees, color-coded stages, and swimlanes.

Activates when: User requests flowcharts, process diagrams, workflow visualizations, or decision trees.

Example usage:

"Create a flowchart for our order processing"
"Generate a process flow diagram showing deployment steps"
"Make a decision tree for our approval workflow"

`dashboard-creator`

Create professional HTML dashboards with KPI metric cards, bar/pie/line charts, and progress indicators.

Activates when: User requests dashboards, metrics displays, KPI visualizations, or data charts.

Example usage:

"Create a dashboard showing website analytics"
"Make a KPI dashboard for our sales metrics"
"Generate a performance dashboard with charts"

`technical-doc-creator`

Create comprehensive HTML technical documentation with code blocks, API workflows, and system architecture diagrams.

Activates when: User requests technical documentation, API docs, code examples, or system architecture.

Example usage:

"Create API documentation for our user endpoints"
"Generate technical docs for our authentication system"
"Document our microservices architecture"

`timeline-creator`

Create beautiful HTML timelines and project roadmaps with Gantt charts, milestones, and phase groupings.

Activates when: User requests timelines, roadmaps, Gantt charts, project schedules, or milestone visualizations.

Example usage:

"Create a timeline for our product launch"
"Generate a roadmap showing Q1-Q4 milestones"
"Make a Gantt chart for our project schedule"

Common Features (All Skills):

Modern gradient backgrounds and responsive design
Semantic color system (success/warning/error/info)
Self-contained HTML (no external dependencies)
WCAG AA accessibility compliance

Available Agents

Implementation

`plan-implementer`

Focused agent for implementing code based on specific plans or task descriptions. Uses Haiku model for efficient, cost-effective execution.

Use when: You have a clear specification or plan to execute.

Invoked by: feature-planning skill automatically, or manually via Task tool

Example usage:

Implementing tasks from a feature plan
Executing specific implementation subtasks
Following project conventions for focused code changes

Model: claude-3-5-haiku (fast and efficient for implementation tasks)

Plugin Development

Want to add your own plugin to this marketplace? Follow this structure:

your-plugin/
├── .claude-plugin/
│   └── plugin.json              # Plugin manifest
├── agents/                       # Optional: Agent definitions
├── skills/                       # Skills directory
└── README.md                    # Plugin documentation

Then add it to .claude-plugin/marketplace.json in this repository.

Creating Custom Skills

Want to create your own Skills? Follow this structure:

my-skill/
├── SKILL.md          # Main skill file with frontmatter and instructions
└── reference.md      # Optional: Additional context loaded on-demand

SKILL.md Template

---
name: my-skill-name
description: What it does and when to use it. Be specific about activation triggers.
---

# Skill Title

Brief overview of what this skill does.

## When to Use

List specific scenarios when Claude should activate this skill:
- User says X
- User mentions Y
- Context includes Z

## Instructions

Step-by-step instructions for Claude to follow...

Best Practices

Description is key: Include both what the skill does AND when to use it
Use gerund forms: Name skills with "-ing" (e.g., "git-pushing", not "git-push")
Keep concise: Skills under 500 lines load faster
Progressive disclosure: Move detailed content to separate reference files
Test across models: Verify skills work with Sonnet, Opus, and Haiku

Contributing

Contributions are welcome! To add a new skill:

Fork this repository
Create your skill in a new directory
Follow the SKILL.md template and best practices
Add your skill to this README
Submit a pull request

License

Apache 2.0 - See LICENSE file for details.

Resources

Support

Issues and questions:

Open an issue on this repository
Check Claude Code discussions

Complete Workflow Example

Here's how the skills and agent work together for a typical feature development flow:

User: "Add user authentication to the app"
feature-planning skill activates and:
- Asks clarifying questions (OAuth? JWT? Session-based?)
- Explores codebase for existing patterns
- Creates detailed plan with 8 discrete tasks
- Reviews plan with user
plan-implementer agent executes each task:
- Implements User model
- Creates auth middleware
- Adds login/logout endpoints
- Builds frontend auth flow
test-fixing skill automatically activates if tests fail:
- Identifies and groups test failures
- Fixes issues systematically
User: "Push these changes"
git-pushing skill activates:
- Creates conventional commit message
- Pushes to remote branch

Note: These skills are generalized for broad software engineering use. Adapt descriptions and instructions to fit your specific workflows.

Other Projects by the Author

personal-ai-os — Automate your digital life with natural language
agent-composer — Local-first multi-agent AI platform
outlook-mcp — MCP server for Microsoft Outlook
nemlig-shopper — CLI grocery shopping tool (PyPI)
Portfolio — Personal portfolio site

USP

Use cases

Detected files (8)

README

Claude Skills Marketplace

Repository Structure

What are Skills and Agents?

🚀 NEW: Execution Runtime (90%+ Token Savings)

Quick Benefits

Setup (2 minutes)

When It Activates

Installation

Install from Marketplace

Available Plugins

Engineering Workflow Plugin

Visual Documentation Plugin

Productivity Skills Plugin

Code Operations Plugin

Available Skills

Feature Development

feature-planning

Git & Version Control

git-pushing

Testing & Quality

test-fixing

Code Review

review-implementing

Code Operations

code-execution 🆕

code-transfer

code-refactor

file-operations

Productivity & Analysis

conversation-analyzer

code-auditor

codebase-documenter

project-bootstrapper

Visual Documentation

architecture-diagram-creator

flowchart-creator

dashboard-creator

technical-doc-creator

timeline-creator

Available Agents

Implementation

plan-implementer

Plugin Development

Creating Custom Skills

SKILL.md Template

Best Practices

Contributing

License

Resources

Support

Complete Workflow Example

Other Projects by the Author

`feature-planning`

`git-pushing`

`test-fixing`

`review-implementing`

`code-execution` 🆕

`code-transfer`

`code-refactor`

`file-operations`

`conversation-analyzer`

`code-auditor`

`codebase-documenter`

`project-bootstrapper`

`architecture-diagram-creator`

`flowchart-creator`

`dashboard-creator`

`technical-doc-creator`

`timeline-creator`

`plan-implementer`