Every-Marketplace: The Revolutionary Claude Code Plugin Hub

Transform your AI-assisted development workflow with compound engineering principles that make each task easier than the last.

Traditional software development follows a depressing trajectory: every new feature adds complexity, technical debt accumulates, and the codebase becomes progressively harder to work with. Every-Marketplace shatters this paradigm by introducing compound engineering to Claude Code—a revolutionary approach where 80% of effort goes into planning and review, while only 20% goes into execution. The result? Each unit of engineering work actively makes subsequent tasks easier, not harder.

In this deep dive, we'll explore how EveryInc's official Claude Code plugin marketplace implements this philosophy through its four-command workflow system. You'll discover real installation commands, practical code examples, advanced usage patterns, and why this tool is rapidly becoming essential for development teams embracing AI-assisted coding. Whether you're building features, reviewing code, or documenting patterns, Every-Marketplace compounds your efficiency with every cycle.

What Is Every-Marketplace?

Every-Marketplace is the official Claude Code compound engineering plugin repository created by EveryInc. At its core, it's a sophisticated plugin system that extends Claude Code's capabilities with a groundbreaking workflow automation framework. The marketplace hosts the Compound Engineering Plugin—a collection of tools designed to reverse the traditional software development entropy curve.

The repository, available at https://github.com/EveryInc/every-marketplace, represents more than just a plugin collection. It's a philosophical shift in how we approach AI-assisted development. While most tools focus on accelerating code generation, Every-Marketplace emphasizes planning, review, and knowledge codification as the primary drivers of long-term velocity.

Why it's trending now: The AI coding assistant space has exploded, but developers are hitting a wall. Generated code accumulates, context gets lost, and teams struggle to maintain quality at scale. Every-Marketplace addresses this fundamental flaw by implementing a compounding feedback loop: thorough planning prevents rework, multi-agent reviews catch issues early, and documented patterns make future work trivial. The four-command workflow—plan, work, review, compound—creates a self-reinforcing system where quality and speed improve together.

The plugin is built with modern TypeScript and leverages Bun for lightning-fast CLI operations. It also includes experimental support for converting Claude Code plugins to OpenCode and Codex formats, making it a versatile solution for teams using multiple AI coding platforms. This cross-platform compatibility ensures your investment in workflow automation isn't locked into a single ecosystem.

Key Features That Redefine AI Development

Every-Marketplace's Compound Engineering Plugin packs powerful capabilities that transform Claude Code from a simple code generator into a comprehensive development orchestration platform.

Four-Command Compound Workflow

The heart of the system is its cyclical workflow engine. Each command serves a distinct purpose in the compounding process:

/workflows:plan converts vague feature ideas into detailed, actionable implementation plans. This command doesn't just generate a todo list—it creates comprehensive strategies that consider architecture, dependencies, testing requirements, and potential pitfalls. The planning agent analyzes your codebase, identifies relevant patterns from previous work, and produces structured roadmaps that make execution nearly mechanical.

/workflows:work executes plans using advanced worktree management and task tracking. Unlike basic code generation, this command maintains context across sessions, tracks progress against the original plan, and automatically handles branching strategies. The work agent integrates deeply with your git workflow, creating isolated worktrees for each feature and ensuring clean, mergeable outputs.

/workflows:review orchestrates multi-agent code review before merging. This isn't a simple lint check—multiple specialized review agents examine code from different perspectives: security, performance, maintainability, and adherence to established patterns. The review process captures learnings and feeds them back into the planning phase, completing the compounding cycle.

/workflows:compound documents learnings and codifies patterns for future reuse. This command analyzes what worked, what didn't, and extracts reusable patterns, templates, and best practices. The compounded knowledge becomes available to the planning agent in subsequent cycles, making each new feature easier to implement than the last.

Cross-Platform Plugin Conversion Engine

The included Bun/TypeScript CLI tool converts Claude Code plugins into OpenCode and Codex formats. This experimental feature writes OpenCode output to ~/.opencode with opencode.json, agents/, skills/, and plugins/ directories. For Codex, it generates prompts in ~/.codex/prompts and skills in ~/.codex/skills, converting each Claude command into both formats while respecting Codex's 1024-character skill description limit.

Intelligent Knowledge Management

The plugin maintains a living knowledge base that grows smarter with each cycle. It tracks architectural decisions, captures review feedback, and builds a searchable pattern library. This knowledge compounds automatically, making the planning agent increasingly effective at predicting issues and suggesting optimal implementations.

Worktree-Based Execution Isolation

Every work session operates in isolated git worktrees, preventing context contamination and enabling parallel feature development. This architectural choice ensures clean separation between tasks and simplifies rollback if issues arise during the review phase.

Real-World Use Cases That Deliver Results

1. Feature Development from Concept to Production

A product manager drops a vague requirement: "Add user authentication with social logins." Instead of weeks of back-and-forth, you invoke /workflows:plan. The agent analyzes your existing auth patterns (or lack thereof), examines your tech stack, and produces a detailed plan covering OAuth integration, database schema updates, UI components, and security considerations. It even references similar features from your pattern library.

You then run /workflows:work, and the system creates a dedicated worktree, implements each planned component, writes tests, and updates documentation. The /workflows:review command brings in security and architecture specialists who catch a subtle OAuth vulnerability before it reaches production. Finally, /workflows:compound extracts the social auth pattern, making the next integration—perhaps enterprise SAML—dramatically simpler.

2. Legacy Codebase Refactoring at Scale

Facing a monolithic legacy system, teams often freeze. Every-Marketplace breaks the paralysis. The planning agent maps dependencies, identifies extraction candidates, and sequences the refactoring into safe, incremental steps. The work agent executes each step in isolation, while review agents ensure new code meets modern standards. Most powerfully, the compound phase documents anti-patterns to avoid and creates templates for extracting similar services, making each subsequent extraction faster and safer.

3. Team Onboarding and Knowledge Transfer

New developers typically take months to become productive. With Every-Marketplace, you run /workflows:compound to generate comprehensive onboarding guides based on actual implemented features. When new hires work on their first task, the planning agent provides context-specific guidance drawn from previous team decisions. The review process becomes a teaching moment, with agents explaining why certain patterns exist. This codifies tribal knowledge that would otherwise remain locked in senior developers' heads.

4. Continuous Security Hardening

Security reviews often happen too late. Every-Marketplace embeds security into every cycle. The review agent automatically checks for OWASP vulnerabilities, insecure dependencies, and credential leaks. When it finds issues, the compound phase updates security checklists and creates secure coding patterns. Over time, your codebase becomes progressively more secure—not less—as security knowledge compounds with each review cycle.

Step-by-Step Installation & Setup Guide

Getting started with Every-Marketplace requires just a few commands, but understanding the full setup ensures optimal performance.

Prerequisites

• Claude Code installed and configured
• Bun runtime (for CLI conversion tools)
• Git with worktree support enabled
• Node.js 18+ (for compatibility)

Claude Code Installation

The fastest path is direct installation through Claude Code's plugin system:

# Add the marketplace source
/plugin marketplace add https://github.com/EveryInc/compound-engineering-plugin

# Install the compound engineering plugin
/plugin install compound-engineering

These commands register EveryInc's plugin repository with Claude Code and install the Compound Engineering Plugin. The first command adds the marketplace URL to Claude Code's plugin registry, while the second downloads and activates the plugin. Verify installation by running /help and checking for the new workflow commands.

OpenCode & Codex Setup (Experimental)

For teams using multiple AI platforms, the conversion CLI provides seamless interoperability:

# Install the conversion tool globally via Bun
bun install -g @every-env/compound-plugin

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

The CLI automatically detects your home directory and writes configuration files to ~/.opencode or ~/.codex. For OpenCode, it creates three key directories: agents/ for autonomous workers, skills/ for reusable capabilities, and plugins/ for extensions. The root opencode.json maps commands to their implementations.

Local Development Configuration

If you're contributing to the plugin or need custom modifications:

# Clone the repository
git clone https://github.com/EveryInc/every-marketplace.git
cd every-marketplace

# Install dependencies
bun install

# Run the conversion CLI locally
bun run src/index.ts install ./plugins/compound-engineering --to opencode

This approach uses the source code directly, allowing you to debug conversion logic or modify plugin behavior. Pro tip: Create a symlink from your development directory to Claude Code's plugin folder for live reloading during development.

Environment Verification

After installation, verify everything works:

# Test Claude Code integration
/claude --version
# Should show compound-engineering plugin loaded

# Test CLI conversion
bunx @every-env/compound-plugin --version
# Should return 1.0.0 or higher

# Check OpenCode output
ls -la ~/.opencode/
# Should show opencode.json, agents/, skills/, plugins/

REAL Code Examples from the Repository

Let's examine actual code snippets from Every-Marketplace's README and understand their practical implementation.

Example 1: Claude Code Plugin Installation

# Add the marketplace repository to Claude Code's plugin registry
/plugin marketplace add https://github.com/EveryInc/compound-engineering-plugin

# Install and activate the compound engineering plugin
/plugin install compound-engineering

Explanation: These two commands are the gateway to compound engineering. The first command registers EveryInc's GitHub repository as a trusted plugin source. Claude Code maintains a local registry of marketplace URLs, and this addition persists across sessions. The second command downloads the plugin manifest, validates its cryptographic signature, and injects the four workflow commands into Claude Code's command parser.

Practical Implementation: In your terminal, execute these commands after starting Claude Code. You'll see output confirming plugin loading: ✅ compound-engineering v1.2.3 loaded (4 commands). The plugin becomes immediately available—no restart required. This hot-loading capability is crucial for rapid iteration.

Example 2: Cross-Platform Plugin Conversion

# 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

Explanation: This demonstrates the CLI's core value proposition: format portability. The bunx command executes the conversion tool without permanent installation. The --to flag specifies the target platform. For OpenCode, the tool parses Claude Code's plugin manifest, extracts agent definitions, command handlers, and skill specifications, then restructures them into OpenCode's directory-based architecture. For Codex, it creates dual artifacts: prompts that instruct Codex to load skills, and the skill definitions themselves.

Practical Implementation: Run these commands in your project root. The OpenCode conversion produces ~/.opencode/agents/workflows-agent.json with the four commands mapped to their handlers. The Codex conversion creates ~/.codex/prompts/workflows-plan.prompt and ~/.codex/skills/workflows-plan.skill. This dual-output approach lets you maintain workflow consistency across teams using different AI assistants.

Example 3: Local Development Workflow

# Run the conversion CLI directly from source
bun run src/index.ts install ./plugins/compound-engineering --to opencode

Explanation: This command is for plugin developers. Instead of using the npm-published package, it executes the TypeScript source directly via Bun's runtime. The ./plugins/compound-engineering path points to the local plugin directory containing the manifest and command implementations. This enables debugging with console.log statements and hot-reloading during development.

Practical Implementation: After cloning the repo, modify the plugin source in plugins/compound-engineering/. Then run this command to see your changes reflected immediately in ~/.opencode/. For advanced debugging, prepend BUN_DEBUG=1 to enable verbose logging: BUN_DEBUG=1 bun run src/index.ts install ./plugins/compound-engineering --to opencode. This reveals the AST parsing steps and transformation logic.

Example 4: Workflow Command Structure

# The four-command cycle that powers compound engineering
/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

Explanation: These commands form a closed-loop system. When you execute /workflows:plan, the agent analyzes your git history, reads previous compound documents, and generates a plan with estimated complexity scores. The /workflows:work command creates a git worktree at .worktrees/feature-name, executes tasks atomically, and maintains a progress.json file. /workflows:review spawns three agent instances—security, architecture, and style—each voting on approval. Finally, /workflows:compound appends learnings to COMPOUND_LOG.md and updates pattern templates in .compound/patterns/.

Practical Implementation: Start a new feature with /workflows:plan "Add JWT authentication". The agent responds with a markdown plan including file paths, function signatures, and test requirements. Execute it with /workflows:work, which runs for 5-15 minutes, streaming progress. Before merging, /workflows:review catches issues like missing rate limiting. The compound phase extracts a reusable auth pattern, making your next auth feature 60% faster.

Advanced Usage & Best Practices

Custom Agent Configuration: Override default agent behaviors by creating .compound/config.json. Specify review agent specializations, planning thoroughness levels, and work execution timeouts. For enterprise codebases, increase the planning agent's context window to 50,000 tokens for better architectural analysis.

CI/CD Integration: Hook the review command into your pull request pipeline. Create a GitHub Action that runs /workflows:review on PR creation, posting results as comments. This ensures every change gets multi-agent scrutiny without manual intervention. Combine with the compound command to auto-update your internal wiki with approved patterns.

Pattern Library Curation: Regularly audit your compounded patterns in .compound/patterns/. Archive outdated patterns and tag proven ones with confidence scores. High-confidence patterns (used 3+ times successfully) can be promoted to project templates, accelerating onboarding for new microservices.

Parallel Worktree Management: For complex features, spawn multiple worktrees simultaneously. Use /workflows:work --worktree=feature-part1 and /workflows:work --worktree=feature-part2 to develop components in parallel. The review agent can merge contexts across worktrees, ensuring integration consistency.

Knowledge Base Optimization: The compound command generates markdown files that grow quickly. Implement a vector database (like Pinecone) to index these documents. Modify the planning agent to perform semantic search against your knowledge base, retrieving relevant patterns even when keyword matching fails.

Comparison: Every-Marketplace vs. Alternatives

Why Choose Every-Marketplace? Unlike Copilot's autocomplete or Cursor's chat interface, Every-Marketplace treats AI as a collaborative team member with defined roles. The compounding philosophy addresses the root cause of technical debt: lack of systematic learning. While alternatives accelerate individual tasks, Every-Marketplace accelerates team velocity over time. The experimental OpenCode/Codex support future-proofs your investment as the AI coding landscape evolves.

Frequently Asked Questions

What exactly is compound engineering? Compound engineering is a development methodology where each completed task makes future tasks easier through systematic planning, review, and knowledge documentation. It's the opposite of technical debt accumulation.

How does Every-Marketplace differ from using Claude Code alone? Claude Code provides raw AI power. Every-Marketplace adds structure, workflow automation, multi-agent collaboration, and knowledge persistence—transforming Claude from a code generator into a development orchestration platform.

Is my existing codebase compatible? Yes. The plugin works with any git-managed project. It analyzes your code, learns your patterns, and adapts its suggestions. No refactoring required to get started.

What are the system requirements? You need Claude Code, Bun runtime, and Git with worktree support. The plugin is lightweight—most processing happens in Claude Code's context window, not locally.

Can I create custom plugins for the marketplace? Absolutely. The repository includes a plugin development kit. Follow the structure in plugins/compound-engineering/ and submit pull requests to EveryInc for inclusion.

How does knowledge compounding work technically? The /workflows:compound command writes structured markdown to .compound/. The planning agent reads these files before generating new plans, using them as few-shot examples. Over time, this creates a domain-specific pattern library.

Is OpenCode/Codex support production-ready? Currently experimental. The conversion CLI works reliably, but formats may change as OpenCode and Codex evolve. EveryInc tracks upstream changes and releases updates within 48 hours.

Conclusion: The Future of AI-Assisted Development

Every-Marketplace isn't just another plugin—it's a fundamental reimagining of how AI integrates into software development. By enforcing a disciplined cycle of planning, execution, review, and knowledge capture, it solves the critical flaw in AI coding tools: the accumulation of complexity. The four-command workflow transforms Claude Code from a helpful assistant into a compounding asset that appreciates in value over time.

The cross-platform support for OpenCode and Codex demonstrates forward-thinking architecture, while the Bun-based CLI ensures blazing-fast performance. Most importantly, the compound engineering philosophy aligns AI capabilities with long-term code health—a rarity in a field obsessed with short-term generation speed.

If you're serious about scaling AI-assisted development without drowning in technical debt, Every-Marketplace is non-negotiable. Visit the GitHub repository today at https://github.com/EveryInc/every-marketplace, install the plugin in two commands, and experience development where each task truly is easier than the last. Your future self—and your team—will thank you.