By JokerRun
AI-powered development tools. 29 agents, 24 commands, 18 skills, 1 MCP server for code review, research, design, and workflow automation.
Have multiple specialized agents review the technical approach and architecture of a plan in parallel
Run comprehensive agent-native architecture review with scored principles
Create engaging changelogs for recent merges to main branch
Create or edit Claude Code skills with expert guidance on structure and best practices
Enhance a plan with parallel research agents for each section to add depth, best practices, and implementation details
Brutally honest Rails code review from DHH's perspective. Use when reviewing Rails code for anti-patterns, JS framework contamination, or violations of Rails conventions.
Researches and synthesizes external best practices, documentation, and examples for any technology or framework. Use when you need industry standards, community conventions, or implementation guidance.
Gathers comprehensive documentation and best practices for frameworks, libraries, or dependencies. Use when you need official docs, version-specific constraints, or implementation patterns.
Visually compares live UI implementation against Figma designs and provides detailed feedback on discrepancies. Use after writing or modifying HTML/CSS/React components to verify design fidelity.
Iteratively refines UI design through N screenshot-analyze-improve cycles. Use PROACTIVELY when design changes aren't coming together after 1-2 attempts, or when user requests iterative refinement.
Browser automation using Vercel's agent-browser CLI. Use when you need to interact with web pages, fill forms, take screenshots, or scrape data. Alternative to Playwright MCP - uses Bash commands with ref-based element selection. Triggers on "browse website", "fill form", "click button", "take screenshot", "scrape page", "web automation".
Build applications where agents are first-class citizens. Use this skill when designing autonomous agents, creating MCP tools, implementing self-modifying systems, or building apps where features are outcomes achieved by agents operating in a loop.
This skill should be used when writing Ruby gems following Andrew Kane's proven patterns and philosophy. It applies when creating new Ruby gems, refactoring existing gems, designing gem APIs, or when clean, minimal, production-ready Ruby library code is needed. Triggers on requests like "create a gem", "write a Ruby library", "design a gem API", or mentions of Andrew Kane's style.
This skill should be used before implementing features, building components, or making changes. It guides exploring user intent, approaches, and design decisions before planning. Triggers on "let's brainstorm", "help me think through", "what should we build", "explore approaches", ambiguous feature requests, or when the user's request has multiple valid interpretations that need clarification.
Capture solved problems as categorized documentation with YAML frontmatter for fast lookup
External network access
Connects to servers outside your machine
Uses power tools
Uses Bash, Write, or Edit tools
Own this plugin?
Verify ownership to unlock analytics, metadata editing, and a verified badge. GitHub access is read-only (username + org membership).
Sign in to claimOwn this plugin?
Verify ownership to unlock analytics, metadata editing, and a verified badge. GitHub access is read-only (username + org membership).
Sign in to claimBased on adoption, maintenance, documentation, and repository signals. Not a security audit or endorsement.
No model invocation
Executes directly as bash, bypassing the AI model
No model invocation
Executes directly as bash, bypassing the AI model
Runs pre-commands
Contains inline bash commands via ! syntax
Runs pre-commands
Contains inline bash commands via ! syntax
A Claude Code plugin marketplace featuring the Compound Engineering Plugin — tools that make each unit of engineering work easier than the last.
/plugin marketplace add https://github.com/EveryInc/compound-engineering-plugin
/plugin install compound-engineering
This repo includes a Bun/TypeScript CLI that converts Claude Code plugins to OpenCode, Codex, and Factory Droid.
# convert the compound-engineering plugin into OpenCode format
bunx @every-env/compound-plugin install compound-engineering --to opencode
# convert to Codex format
bunx @every-env/compound-plugin install compound-engineering --to codex
# convert to Factory Droid format
bunx @every-env/compound-plugin install compound-engineering --to droid
Local dev:
bun run src/index.ts install ./plugins/compound-engineering --to opencode
OpenCode output is written to ~/.config/opencode by default, with opencode.json at the root and agents/, skills/, and plugins/ alongside it.
Codex output is written to ~/.codex/prompts and ~/.codex/skills, with each Claude command converted into both a prompt and a skill (the prompt instructs Codex to load the corresponding skill). Generated Codex skill descriptions are truncated to 1024 characters (Codex limit).
Droid output is written to ~/.factory/ with commands, droids (agents), and skills. Claude tool names are mapped to Factory equivalents (Bash → Execute, Write → Create, etc.) and namespace prefixes are stripped from commands.
All provider targets are experimental and may change as the formats evolve.
Sync your personal Claude Code config (~/.claude/) to OpenCode or Codex:
# Sync skills and MCP servers to OpenCode
bunx @every-env/compound-plugin sync --target opencode
# Sync to Codex
bunx @every-env/compound-plugin sync --target codex
This syncs:
~/.claude/skills/ (as symlinks)~/.claude/settings.jsonSkills are symlinked (not copied) so changes in Claude Code are reflected immediately.
Plan → Work → Review → Compound → Repeat
| Command | Purpose |
|---|---|
/workflows:plan | Turn feature ideas into detailed implementation plans |
/workflows:work | Execute plans with worktrees and task tracking |
/workflows:review | Multi-agent code review before merging |
/workflows:compound | Document learnings to make future work easier |
Each cycle compounds: plans inform future plans, reviews catch more issues, patterns get documented.
Each unit of engineering work should make subsequent units easier—not harder.
Traditional development accumulates technical debt. Every feature adds complexity. The codebase becomes harder to work with over time.
Compound engineering inverts this. 80% is in planning and review, 20% is in execution:
npx claudepluginhub jokerrun/compound-engineering-plugin --plugin compound-engineeringPersonalized coding tutorials that use your actual codebase for examples with spaced repetition quizzes
Core skills library for Claude Code: TDD, debugging, collaboration patterns, and proven techniques
Harness-native ECC operator layer - 67 agents, 278 skills, 94 legacy command shims, reusable hooks, rules, selective install profiles, and production-ready workflows for Claude Code, Codex, OpenCode, Cursor, and related agent harnesses
Comprehensive skill pack with 66 specialized skills for full-stack developers: 12 language experts (Python, TypeScript, Go, Rust, C++, Swift, Kotlin, C#, PHP, Java, SQL, JavaScript), 10 backend frameworks, 6 frontend/mobile, plus infrastructure, DevOps, security, and testing. Features progressive disclosure architecture for 50% faster loading.
Access thousands of AI prompts and skills directly in your AI coding assistant. Search prompts, discover skills, save your own, and improve prompts with AI.
Reliable automation, in-depth debugging, and performance analysis in Chrome using Chrome DevTools and Puppeteer
Comprehensive feature development workflow with specialized agents for codebase exploration, architecture design, and quality review
Matt Pocock's agent skills for real engineering — grilling, spec/ticket flows, TDD, code review, domain modelling and more. Plug-and-play, not vibe coding.