OpenCode has about 220,000 stars on GitHub. The project reports around 8 million monthly developers and supports more than 70 model providers. Out of the box, however, the agent retains no memory between sessions, has no knowledge of how a codebase is structured, and consumes tokens on output that the user did not request.

OpenCode reads skills from .opencode/skills, .claude/skills, and .agents/skills, both in the project directory and in the home directory. For this reason, tools built for Claude work without modification. Skills load on demand. The agent sees only a short name and description until a task requires the skill. It then loads the full SKILL.md file.

This article reviews six open-source projects that extend OpenCode.

1. GitNexus: Codebase Dependency Graph

Coding agents often lack knowledge of how code components connect. For example, an agent asked to change how a pricing helper rounds numbers may edit the function without identifying that checkout, invoices, and three reports depend on its return value. The result can be a breaking change reported as complete.

GitNexus converts the entire repository into a knowledge graph. It exposes dependencies, call chains, and execution flows to the agent through MCP tools. The graph is computed at index time. Standard graph setups provide the model with raw edges and rely on the model to explore them. GitNexus pre-computes clusters and traces, so a single tool call returns the complete answer.

The tool provides 19 MCP tools. The three most used are:

• impact: shows the blast radius of a change.
• trace: finds the path between two functions.
• detect changes: runs before a commit.

Setup

Run two commands from the project root:

npx gitnexus analyze
npx gitnexus setup

• analyze indexes the code, installs the skills, and writes context into AGENTS.md. OpenCode 2 reads AGENTS.md.
• setup detects OpenCode and adds the MCP entry to the configuration.

Limitations

• Claude Code and Codex receive hooks that add graph context automatically. OpenCode receives the tools and skills but not the hooks. Users must instruct the agent explicitly, for example: "Run impact before you edit this."
• The license is Polyform Non-Commercial. Verify the license before using the tool in client work.
• On NPM 11, the installation can fail. Install globally or use PNPM.

2. Matt Pocock's Skills: Process Control

Matt Pocock's skills repository has nearly 300,000 stars, the most of any project in this list. Its premise is that large frameworks attempt to control the entire development process, which makes failures difficult to diagnose and repair. His skills are small, independent files that users combine as needed.

The skills address four failure modes of coding agents:

1. The agent builds the wrong thing.
2. The agent produces excessive output.
3. The code does not work.
4. The codebase degrades over time.

Skills by Failure Mode

• Wrong output: grill-me and grill-with-docs. Before writing code, the agent interviews the user until the plan is clear. grill-with-docs also builds a shared vocabulary file, now named glossary.md. Once the agent learns the project's terms, it uses fewer words to express the same concept.
• Broken code: A TDD skill enforces a red, green, refactor cycle. A diagnosing-bugs skill resolves issues one gated step at a time.
• Architectural decay: An improve-codebase-architecture skill scans the repository and produces a visual report.

Installation

OpenCode has no plugin marketplace for these skills. Install them with the Skills CLI:

npx skills@latest add mattpocock/skills

When prompted, select the skills to install and include the setup skill. Run the setup skill once per repository.

The skills are plain files within the project, not a self-updating plugin. Update them with:

npx skills@latest update

Users can open any SKILL.md file and modify it.

3. UI UX Pro Max: Design System Generation

AI-generated interfaces often share the same visual characteristics, including a purple gradient, the same font, and cards nested within cards. UI UX Pro Max addresses this problem by generating a design system before any code is written.

The user describes the product. The tool runs five searches in parallel across product types, styles, color palettes, landing page patterns, and font pairings. It ranks the results and produces a complete design system, including elements to avoid. For a banking application, the tool classifies purple AI-style gradients as prohibited.

Version 2 Dataset

• 192 reasoning rules
• 192 color palettes
• 74 font pairings
• 119 UX guidelines
• 22 technology stacks, including Laravel with Blade, Livewire, and Inertia

Installation

npm install -g ui-ux-pro-max-cli

Then, inside the project:

ui-pro-init --ai opencode

The tool has no slash command. It activates automatically when the user requests UI work.

Persist Feature

The persist feature saves the design system to a master.md file. Page-specific overrides are stored alongside it, which keeps pages consistent across sessions.

Requirements and Limitations

• Requires Python 3.
• Logos and brand assets are available only in a paid tier.

4. Claude-Mem: Persistent Session Memory

GitNexus provides knowledge of how code connects. Claude-Mem records what occurred during prior sessions. Although the name references Claude, the project includes a native OpenCode installation.

Every new OpenCode session otherwise begins without prior context. Claude-Mem runs in the background and records agent activity through lifecycle hooks. It compresses the records with AI and returns relevant information to the next session automatically.

The repository has more than 100,000 stars and is at version 14.

Search Process

Claude-Mem does not load the full history into context. It retrieves results in three stages:

1. Index search: Returns a compact index, about 50 to 100 tokens per result.
2. Timeline view: Shows the events surrounding a selected result.
3. Detail retrieval: Fetches full details only for the entries the user selects.

The project states that this process reduces token usage by approximately 10 times. Content wrapped in private tags is never stored.

Installation

npx claude-mem install --ide opencode

The tool requires OpenCode 1.3.4 or later, including OpenCode 2. Restart OpenCode after installation.

The installer prompts for sign-in to the hosted memory service, which includes a 30-day free trial. After the trial, the service falls back to the user's Anthropic plan. To skip this prompt, pass the provider flag during installation.

Memory is shared with Claude Code and Codex. Session history remains available when the user switches tools.

5. Everything Claude Code (ECC): Complete Agent System

Everything Claude Code, abbreviated ECC, has about 284,000 stars. Despite the name, it includes an OpenCode build. Where Matt Pocock's skills provide individual components, ECC provides a complete system. The system contains agents, skills, commands, hooks, rules, memory, and a security scanner named Agent Shield.

The workflow the project recommends has seven steps: plan, test, implement, review, verify, remember, and improve. The review step runs in a fresh context, so the session that wrote the code does not evaluate it.

OpenCode Build Scope

The OpenCode build is labeled beta. It includes a subset of the full catalog:

Installation

git clone <ECC repository>
cd <ECC directory>
npm install
npm run build:opencode

The build step is required. Without it, OpenCode displays the slash commands but silently omits the hooks and custom tools.

Known Issue

An open issue reports that some agents, including the code reviewer, are fixed to Anthropic models. On other providers, the reviewer fails unless the model is changed in the configuration.

Commands

Common commands include /plan, /tdd, /code-review, and /security.

The author advises against running ECC and Matt Pocock's skills together.

6. Caveman: Token Reduction

Caveman began in April 2026 as a joke. The premise was that an agent speaking in a caveman style would use fewer tokens. The project reached first place on Hacker News. A well-known developer commentator responded that the approach could not work. The project was then cited in an Adobe Research paper. JetBrains ran an A/B test on 86 real coding tasks and reported no measurable loss in quality.

Version 4 extends beyond output style and includes three components:

• Say less: Shortens responses and keeps code, commands, and error messages unchanged.
• Read less: Reduces logs, JSON, and test output before the model reads them. The project's benchmark reports 33.2% fewer input tokens across full sessions.
• Auto: Selects the model and effort level for each request. On 85 coding tasks, the project reports a cost 54% lower than Opus at the highest effort level, with approximately the same score.

Documented Limitation

The project's documentation states that, compared with instructing the model to answer concisely, basic Caveman mode saves only about 3% additional tokens. Most of the savings come from Read less and Ultra Caveman mode.

Installation

Install all components:

npx @caveman-ai/cli@latest

The installer detects OpenCode on the machine and displays the changes it will make. OpenCode then runs with Caveman enabled.

For Auto mode, sign in with a free account:

caveman login

Auto mode then appears in the OpenCode model picker.

To install only the response-length skill:

npx skills add juliusbrussy/caveman-g

The CLI sends usage statistics by default. To disable telemetry:

caveman telemetry off

Recommendations

• Single installation: Begin with GitNexus or the grill-me skill from Matt Pocock's collection. Both produce measurable effects on the first day of use.
• Token cost reduction: Combine Caveman with Claude-Mem. Caveman reduces the content the agent reads, and Claude-Mem reduces the context the agent must reconstruct in each session.