Skip to content
/
Tier B A19 Token-efficient encoding

Claude Skills Marketplace (mhattingpete)

claude-skills-marketplace-mhatting · mhattingpete/claude-skills-marketplace · ★ 586 · last commit 2026-03-06

Primitive shape 20 total
Skills 18 Subagents 1 MCP tools 1
00

Summary

Claude Skills Marketplace (mhattingpete) — Summary

This is a curated multi-plugin Claude Code marketplace shipping five plugin collections across engineering workflow, visual documentation, productivity, code operations, and a code execution runtime. The standout feature is an optional FastMCP-based code execution environment that routes bulk file operations through a Python MCP server, achieving claimed 90-99% token savings by executing code locally rather than loading file contents into context. The marketplace ships 18 skills and 1 subagent (plan-implementer) across four plugin bundles. The execution runtime requires a one-time setup.sh and runs Python scripts locally via a FastMCP server on localhost. Skills auto-activate based on context; the agent in engineering-workflow-plugin orchestrates feature planning, test fixing, git automation, and code review as a coordinated pipeline.

differs_from_seeds: Closest to superpowers (Archetype 1: skills-only behavioral framework) in that all work is done through auto-activating skills, but adds a dedicated subagent (plan-implementer) for implementation work and an optional MCP execution server for token-efficient bulk operations — neither of which superpowers ships. Unlike openspec (Archetype 2: mirror commands+skills), there are no slash commands, only skills. The MCP execution runtime pattern is closer to claude-flow's MCP-anchored toolserver archetype, though much lighter in scope.

01

Overview

Claude Skills Marketplace (mhattingpete) — Overview

Origin

Created by mhattingpete as a curated collection of Claude Code plugins for software engineering workflows, published with Apache-2.0 license. The repository is structured as a Claude Code plugin marketplace with a marketplace.json manifest.

Philosophy

Stated in README: "Skills are automatically triggered by Claude based on context and the Skill's description." The author explicitly explains the skills vs slash-commands distinction:

"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."

The most distinctive opinion is around the code execution runtime:

"Instead of loading code through context, Claude executes Python locally with API access — achieving 90-99% token reduction for bulk operations."

The project cites the Anthropic code execution pattern as inspiration for the execution runtime.

Key Design Choices

  1. No slash commands — all entry points are auto-activating skills
  2. Subagent for implementation — plan-implementer.md is invoked by planning skills for focused execution
  3. Optional execution MCP — skills auto-switch to code execution mode for bulk operations (10+ files)
  4. Plugin-per-domain — four distinct plugin bundles, each installable independently

Timeline

  • Initial plugins: engineering-workflow-plugin, visual-documentation-plugin, productivity-skills-plugin, code-operations-plugin
  • NEW addition: execution-runtime — code execution environment implementing the Anthropic code execution MCP pattern
02

Architecture

Claude Skills Marketplace (mhattingpete) — Architecture

Distribution

  • GitHub repository: mhattingpete/claude-skills-marketplace
  • Install: /plugin marketplace add mhattingpete/claude-skills-marketplace then /plugin install <plugin>
  • License: Apache-2.0
  • Primary language: HTML (demo assets) + Markdown (skills/agents)

Directory Structure

claude-skills-marketplace/
├── .claude-plugin/
│   └── marketplace.json              # Marketplace manifest
├── .claude/
│   ├── settings.json                 # Claude Code settings
│   ├── agents/                       # Top-level agents (if any)
│   ├── commands/                     # Top-level commands (if any)
│   └── skills/                       # Top-level skills (if any)
├── execution-runtime/                # Optional MCP execution server
│   ├── api/                          # Importable Python API
│   ├── mcp-server/                   # FastMCP server
│   ├── setup.sh                      # One-command install
│   └── README.md
├── engineering-workflow-plugin/
│   ├── .claude-plugin/
│   │   └── plugin.json
│   ├── agents/
│   │   └── plan-implementer.md
│   └── skills/
│       ├── feature-planning/
│       ├── git-pushing/
│       ├── review-implementing/
│       ├── test-fixing/
│       └── ensemble-solving/
├── visual-documentation-plugin/
│   └── skills/
│       ├── architecture-diagram-creator/
│       ├── dashboard-creator/
│       ├── flowchart-creator/
│       ├── technical-doc-creator/
│       └── timeline-creator/
├── productivity-skills-plugin/
│   └── skills/
│       ├── code-auditor/
│       ├── codebase-documenter/
│       ├── conversation-analyzer/
│       └── project-bootstrapper/
└── code-operations-plugin/
    └── skills/
        ├── code-execution/
        ├── code-transfer/
        ├── code-refactor/
        └── file-operations/

Required Runtime

  • Claude Code (primary target)
  • Python 3.x + FastMCP (for optional execution runtime)
  • setup.sh installs execution runtime dependencies

Target AI Tools

Primary: Claude Code. Skills use standard SKILL.md format compatible with any skill-aware agent platform.

03

Components

Claude Skills Marketplace (mhattingpete) — Components

Plugins (4 plugins + 1 execution runtime)

engineering-workflow-plugin

Agent (1):

Name Purpose
plan-implementer Senior software engineer specialized for focused, incremental implementation. Invoked by planning skills. Has explicit conflict-resolution protocol: when best practices vs simplicity conflict, presents 3 options and waits for user choice.

Skills (5):

Name Purpose
feature-planning Break down feature requests into detailed implementation plans with codebase exploration via Task tool
git-pushing Git automation — stage, commit, push with conventional commit messages
review-implementing Code review workflow — analyze diff, suggest improvements
test-fixing Automated test failure diagnosis and fix loop
ensemble-solving Multi-approach problem solving using ensemble techniques

visual-documentation-plugin

Skills (5):

Name Purpose
architecture-diagram-creator Auto-generate architecture diagrams from codebase
dashboard-creator Create dashboard views for project metrics
flowchart-creator Generate flowcharts from code/process descriptions
technical-doc-creator Structured technical documentation generation
timeline-creator Project timeline/roadmap visualization

productivity-skills-plugin

Skills (4):

Name Purpose
code-auditor Automated code quality audit
codebase-documenter Generate documentation across the codebase
conversation-analyzer Analyze Claude Code usage patterns for insights
project-bootstrapper Project setup and scaffolding automation

code-operations-plugin

Skills (4):

Name Purpose
code-execution Python execution via MCP server (NEW — token-efficient bulk operations)
code-transfer Code transfer across files using scripts/line_insert.py
code-refactor Bulk codebase refactoring
file-operations File analysis and batch file operations

Execution Runtime (optional MCP server)

  • FastMCP Python server
  • setup.sh one-command installation
  • Skills auto-activate execution mode for bulk operations (10+ files)
  • Claims 90-99% token reduction for batch file operations

Total Primitive Count

  • Skills: 18
  • Agents: 1
  • Commands: 0
  • Hooks: 0 (execution runtime uses MCP, not lifecycle hooks)
  • MCP servers: 1 (execution runtime)
05

Prompts

Claude Skills Marketplace (mhattingpete) — Prompts

Prompt File 1: feature-planning SKILL.md (excerpt)

Technique: Step-decomposition with explicit codebase exploration instruction.

---
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

## 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

### 3. Create Implementation Plan

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

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

### 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)


**Technique**: Task-tool exploration directive — explicitly instructs Claude to use the Task tool's `subagent_type='Explore'` parameter before planning. This is a **pre-planning subagent dispatch pattern** not common in the seed frameworks.

## Prompt File 2: `plan-implementer` Agent (excerpt)

**Technique**: Conflict-escalation protocol — hard stop when tradeoff detected.

```markdown
---
name: plan-implementer
description: Implement code based on a specific plan or task description.
---

## Core Principles

3. **Conflict Resolution**: When best practices and simplicity conflict, you MUST:
   - Stop implementation immediately
   - Present exactly 3 distinct options to the user
   - Clearly explain the trade-offs of each option
   - Wait for explicit user choice before proceeding
   - Never make this decision autonomously

## Decision-Making Framework

When you encounter a choice between best practice and simplicity:

**Option Template**:

I've identified a conflict between best practices and simplicity. Here are three options:

Option 1: [Best Practice Approach]

  • Pros: [specific benefits]
  • Cons: [specific drawbacks, including complexity]
  • Code complexity: [High/Medium/Low]

Option 2: [Balanced Approach] ...

Technique: Mandatory human escalation gate — "MUST stop" and "Never make this decision autonomously" are Iron Law-style constraints that override default agent behavior. Similar to superpowers' Iron Law pattern but scoped to a single decision class (best-practice vs simplicity tradeoffs).

09

Uniqueness

Claude Skills Marketplace (mhattingpete) — Uniqueness

differs_from_seeds

Closest to superpowers (Archetype 1: skills-only behavioral framework) — all work is mediated through auto-activating SKILL.md files with no slash commands. However, it adds a named subagent (plan-implementer) as a dedicated implementation role, and an optional MCP execution server for token-efficient bulk operations. The latter pattern is closer to claude-flow (Archetype 3: MCP-anchored toolserver), but is optional and lightweight rather than the framework's primary delivery mechanism. The conflict-resolution escalation gate in plan-implementer (mandatory hard stop + 3-option presentation) is a design choice not present in any of the 11 seeds.

Most Distinctive Feature

The execution-runtime adds an optional code-execution MCP layer that auto-activates for bulk operations, positioning this as a skills pack that can reduce token consumption on large-scale refactoring tasks. This is architecturally novel in the personal-curation category: most skill packs are prompt-only, but this one bundles an execution runtime for efficiency.

Positioning

  • Mid-sized personal marketplace (18 skills, 1 agent) focused on SW engineering workflows
  • Unique token-efficiency play via execution offloading
  • Clear plug-and-play approach: each plugin is independently installable

Observable Failure Modes

  1. Execution runtime latency: The FastMCP server adds a startup cost; bulk file scripts may fail on sandboxed environments or repos with restricted tooling.
  2. Plan-to-agent handoff relies on context: The implementation plan generated by feature-planning is passed in-context to plan-implementer — if the session compacts before the agent reads it, the plan may be lost.
  3. No hooks for lifecycle events: No PostToolUse validation or Stop hooks means there is no automated quality gate after agent work completes.
  4. 18 skills = significant system prompt load: Auto-activating skills add to every session's context overhead even when not needed.
04

Workflow

Claude Skills Marketplace (mhattingpete) — Workflow

Feature Development Workflow

Skills auto-activate based on context; no explicit slash commands.

Phase Trigger Artifact
Requirements "add user auth", "build dashboard" Clarification Q&A → feature plan
Planning feature-planning skill activates Implementation plan: tasks, components, dependencies
Implementation plan-implementer agent invoked Code changes in discrete incremental steps
Testing test-fixing skill activates when tests fail Fixed tests, passing suite
Review review-implementing skill activates after changes Review comments, suggested fixes
Commit git-pushing skill activates Conventional commit + push

Bulk Operation Workflow (Execution Runtime)

For 10+ file operations, skills auto-switch to MCP execution mode:

Phase Without Execution With Execution
50-file rename ~25,000 tokens (load/edit each) ~600 tokens (Python script + summary)
Execution Multiple Read+Edit calls Single Python script via MCP

Example from README:

"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

Approval Gates

  • Conflict resolution gate: plan-implementer agent explicitly stops and presents 3 options when best-practices vs simplicity conflict arises — waits for user choice before proceeding
  • No other explicit approval gates documented

Phase-to-Artifact Map

Phase Artifact
Feature planning Markdown implementation plan with tasks and file paths
Implementation Code changes, new files
Test fixing Fixed test files, test results
Code review Review comments document
Git Committed + pushed changes

Spec Format

None formally. Plans are generated as Markdown during the feature-planning skill and passed to plan-implementer as context.

06

Memory Context

Claude Skills Marketplace (mhattingpete) — Memory & Context

State Storage

No persistent state beyond the code changes written to disk. Plans are generated in-context and passed to the plan-implementer agent as prompt content, not written to files.

Memory Type

None — file-based only in the sense that the code the agent produces lives on disk. No dedicated memory system.

Context Efficiency

The most distinctive feature is the execution runtime token savings:

  • Skills auto-detect bulk operations (10+ files) and switch to MCP code execution mode
  • Python scripts run locally via FastMCP server, returning only summaries to Claude's context
  • This is an architectural approach to context management through execution offloading

Cross-Session Handoff

None documented. Work is ephemeral to the session.

Compaction Handling

Not explicitly handled. The execution-runtime approach reduces context growth indirectly by replacing large tool-output sequences with compact script-execution summaries.

Context Between Plan and Implementation

The feature-planning skill generates a structured Markdown plan. The plan-implementer agent receives this plan as its task specification. This is a simple prompt-chaining pattern: plan output becomes implementation input, but there is no separate state file — the plan lives in the conversation history.

07

Orchestration

Claude Skills Marketplace (mhattingpete) — Orchestration

Multi-Agent

Yes — one named subagent (plan-implementer) plus the main Claude context acting as orchestrator.

Orchestration Pattern

Sequential. Skills trigger in sequence:

  1. feature-planning skill activates → generates plan
  2. plan-implementer agent invoked → implements tasks sequentially
  3. test-fixing skill activates on test failures
  4. review-implementing skill activates after changes
  5. git-pushing skill activates for commit

Subagent Definition Format

persona-md — plan-implementer.md is a Markdown agent file with role description, principles, and decision framework (not a code class).

Spawn Mechanism

Claude's Task tool (skill invokes task_tool with agent specification). The feature-planning skill explicitly instructs use of Task tool with subagent_type='Explore'.

Isolation Mechanism

None — work happens in-place in the repository. No git-worktree or container isolation.

Multi-Model

No — single model for all roles.

Execution Mode

Interactive-loop — skills auto-activate based on context; no explicit CLI invocation. Session continues until work is complete.

Prompt Chaining

Yes — feature-planning output (the plan document) is explicitly the input prompt for plan-implementer.

Consensus

None.

08

Ui Cli Surface

Claude Skills Marketplace (mhattingpete) — UI & CLI Surface

CLI Binary

None. Installation is via Claude Code's /plugin system.

Local UI

None. No web dashboard or TUI.

IDE Integration

  • Claude Code: Primary target. Plugin marketplace install via /plugin marketplace add mhattingpete/claude-skills-marketplace
  • Installation installs skills/agents into ~/.claude/plugins/

Execution Runtime Surface

The optional execution runtime exposes:

  • setup.sh — one-command install script
  • FastMCP server running locally (port unspecified in examined docs)
  • Python execution environment with PII/secret masking and sandboxed execution

Observability

  • Execution runtime claims "JSONL history tracking" for executed scripts (from README description of the execution runtime's features)
  • No audit log for the skills themselves
  • No metrics endpoint

Transport (Execution Runtime)

  • MCP (the execution runtime communicates with Claude via the MCP protocol)

Related frameworks

same archetype · same primary tool · same memory type

Context Mode ★ 16k
A19 Token-efficient encoding

Keeps raw tool output data out of the context window via sandbox execution and SQLite+FTS5 session indexing, reducing context…

lean-ctx ★ 2.2k
A19 Token-efficient encoding

A full-session context runtime that compresses file reads (10 modes), shell output (60+ patterns), and session memory (CCP) to…

Nemp Memory ★ 101
A19 Token-efficient encoding

Persists AI agent context across sessions as 100%-local plain JSON files with zero dependencies, zero cloud, and agent identity…

CogniLayer v4 ★ 28
A19 Token-efficient encoding

Provides AI coding agents with typed semantic memory, tree-sitter code intelligence, and a multi-agent coordination protocol to…

cursor-coding-agent-os (Mugiwara555343) ★ 3
A19 Token-efficient encoding

Lean/Verbose dual-mode Agent OS fork for solo developers on token budgets.

rtk (Real Token Killer) ★ 55k
A19 Token-efficient encoding

Intercepts Claude Code's Bash tool calls at the PreToolUse hook and compresses verbose CLI output (git status, test runners,…