Agentic Plugin Marketplace by wshobson

Install

/plugin marketplace add wshobson/agents
/plugin install python-development

This is third-party code. Review the repository files before installing.

What it does

A marketplace of isolated plugins, each bundling agents, commands and skills for a domain such as Python, frontend, security or infrastructure. Installing a plugin loads only its components into context, not the whole marketplace. One markdown source generates native artifacts for Codex CLI, Cursor, OpenCode, Antigravity, Copilot and Pi. It ships the plugin-eval framework for scoring skill quality.

Who it is for. Developers who want a large library of ready subagents and skills across stacks.

Example request

Use the Python agent to rewrite this handler with asyncio and proper task cancellation

Limitations

Antigravity, OpenCode and Pi require cloning the repo and running make. Installing skills only via gh skill or npx skills excludes agents, commands and hooks.

How to disable. Remove the installed plugin in Claude Code or delete the skill folder from the agent's skills directory.

Security check

• Some plugins include commands and hooks
• Some install paths require running make from a clone

README in short

The README describes a marketplace of agentic workflow building blocks with a single source in the plugins folder. Install paths are given per agent, plus gh skill and npx skills for skills only. It covers a tiered model strategy, the plugin-eval framework and external Pensyve and HOL Guard integrations. MIT license.

SKILL.md

---
name: async-python-patterns
description: Master Python asyncio, concurrent programming, and async/await patterns for high-performance applications. Use when building async APIs, concurrent systems, or I/O-bound applications requiring non-blocking operations.
---

# Async Python Patterns

Comprehensive guidance for implementing asynchronous Python applications using asyncio, concurrent programming patterns, and async/await for building high-performance, non-blocking systems.

## When to Use This Skill

- Building async web APIs (FastAPI, aiohttp, Sanic)
- Implementing concurrent I/O operations (database, file, network)
- Creating web scrapers with concurrent requests
- Developing real-time applications (WebSocket servers, chat systems)
- Processing multiple independent tasks simultaneously
- Building microservices with async communication
- Optimizing I/O-bound workloads
- Implementing async background tasks and queues

## Sync vs Async Decision Guide

Before adopting async, consider whether it's the right choice for your use case.

| Use Case | Recommended Approach |
|----------|---------------------|
| Many concurrent network/DB calls | `asyncio` |
| CPU-bound computation | `multiprocessing` or thread pool |
| Mixed I/O + CPU | Offload CPU work with `asyncio.to_thread()` |
| Simple scripts, few connections | Sync (simpler, easier to debug) |
| Web APIs with high concurrency | Async frameworks (FastAPI, aiohttp) |

**Key Rule:** Stay fully sync or fully async within a call path. Mixing creates hidden blocking and complexity.

## Core Concepts

### 1. Event Loop

The event loop is the heart of asyncio, managing and scheduling asynchronous tasks.

**Key characteristics:**

- Single-threaded cooperative multitasking
- Schedules coroutines for execution
- Handles I/O operations without blocking
- Manages callbacks and futures

### 2. Coroutines

Functions defined with `async def` that can be paused and resumed.

**Syntax:**

```python
async def my_coroutine():
    result = await some_async_operation()
    return result
```

### 3. Tasks

Related