JSPM

Overview · Quick Start · Skills · Agents · Commands · Development

Overview

Systematic is an OpenCode plugin that transforms your AI assistant into a disciplined engineering collaborator. It provides battle-tested workflows adapted from the Compound Engineering Plugin (CEP) for Claude Code.

Why Systematic?

Most AI coding assistants respond to requests without structure or methodology. This leads to inconsistent outputs, missed requirements, and wasted iterations.

Systematic solves this with structured workflows. The plugin injects proven engineering processes directly into your AI's system prompt, enabling it to:

• Brainstorm systematically before jumping to implementation
• Plan with rigor using multi-phase workflows
• Review code architecturally with specialized agents
• Follow consistent patterns across your entire team

Key Features

• 🧠 Structured Skills — Pre-built workflows for brainstorming, planning, and code review
• 🤖 Specialized Agents — Purpose-built subagents for architecture, security, and performance
• ⚡ Zero Configuration — Works immediately after installation via config hooks
• 🔧 Extensible — Add project-specific skills and commands alongside bundled ones
• 📦 Batteries Included — Skills, agents, and commands ship with the npm package

Quick Start

Prerequisites

• OpenCode installed and configured
• Node.js 18+ or Bun runtime

Installation

Install the plugin via npm:

npm install @fro.bot/systematic

Add it to your OpenCode configuration (~/.config/opencode/opencode.json):

{
  "plugins": ["@fro.bot/systematic"]
}

That's it. Restart OpenCode and the plugin's skills, agents, and commands are available immediately.

[!NOTE] Systematic uses OpenCode's config hook to automatically register all bundled content. No manual file copying required.

Verify Installation

In any OpenCode conversation, type:

/systematic:using-systematic

If the skill loads and displays usage instructions, the plugin is working correctly.

Skills

Skills are structured workflows that guide the AI through systematic engineering processes. They're loaded via the systematic_skill tool.

How Skills Work

Skills are Markdown files with YAML frontmatter. When loaded, their content is injected into the conversation, guiding the AI's behavior:

---
name: brainstorming
description: This skill should be used before implementing features...
---

# Brainstorming

This skill provides detailed process knowledge for effective brainstorming...

The AI is instructed to invoke skills before taking action — even with a 1% chance a skill might apply.

Agents

Agents are specialized subagents with pre-configured prompts and expertise. They're registered automatically via the config hook.

Review Agents

Research Agents

Using Agents

Agents are invoked via OpenCode's @mention syntax or delegate_task:

@architecture-strategist Review the authentication refactoring in this PR

Or programmatically in skills/commands:

delegate_task(subagent_type="architecture-strategist", prompt="Review...")

Commands

Commands are slash-invokable shortcuts that trigger workflows or actions.

Workflow Commands

Utility Commands

Configuration

Systematic works out of the box, but you can customize it via configuration files.

Plugin Configuration

Create ~/.config/opencode/systematic.json or .opencode/systematic.json to disable specific bundled content:

{
  "disabled_skills": ["git-worktree"],
  "disabled_agents": [],
  "disabled_commands": []
}

Project-Specific Content

Add your own skills, agents, and commands alongside bundled ones:

.opencode/
├── skills/
│   └── my-skill/
│       └── SKILL.md
├── agents/
│   └── my-agent.md
└── commands/
    └── my-command.md

Project-level content takes precedence over bundled content with the same name.

Tools

The plugin exposes one tool to OpenCode:

For non-Systematic skills (project or user-level), use OpenCode's native skill tool.

How It Works

Systematic uses three OpenCode plugin hooks:

flowchart TB
    A[Plugin Loaded] --> B[config hook]
    A --> C[tool hook]
    A --> D[system.transform hook]

    B --> E[Merge bundled agents/commands/skills into OpenCode config]
    C --> F[Register systematic_skill tool]
    D --> G[Inject bootstrap prompt into every conversation]

    style A fill:#e1f5fe
    style E fill:#f1f8e9
    style F fill:#fff3e0
    style G fill:#fce4ec

1. config hook — Merges bundled assets into your OpenCode configuration
2. tool hook — Registers the systematic_skill tool for loading skills
3. system.transform hook — Injects the "Using Systematic" guide into system prompts

This architecture ensures skills, agents, and commands are available immediately without manual setup.

Development

Prerequisites

• Bun runtime
• Node.js 18+ (for compatibility)

Setup

# Clone the repository
git clone https://github.com/marcusrbrown/systematic.git
cd systematic

# Install dependencies
bun install

# Build the plugin
bun run build

# Run type checking
bun run typecheck

# Run linter
bun run lint

# Run unit tests
bun test

Project Structure

├── src/
│   ├── index.ts              # Plugin entry point
│   ├── cli.ts                # CLI entry point
│   └── lib/
│       ├── bootstrap.ts      # System prompt injection
│       ├── config.ts         # JSONC config loading
│       ├── config-handler.ts # OpenCode config hook
│       ├── skill-tool.ts     # systematic_skill tool
│       ├── skills.ts         # Skill discovery
│       ├── agents.ts         # Agent discovery
│       └── commands.ts       # Command discovery
├── skills/                   # Bundled skills (SKILL.md files)
├── agents/                   # Bundled agents (Markdown)
├── commands/                 # Bundled commands (Markdown)
├── tests/
│   ├── unit/                 # Unit tests
│   └── integration/          # Integration tests
└── dist/                     # Build output

Testing

# Run all unit tests
bun test tests/unit

# Run a specific test file
bun test tests/unit/skills.test.ts

# Run integration tests
bun test tests/integration

Contributing

See AGENTS.md for detailed development guidelines, code style conventions, and architecture overview.

Converting from Claude Code

Migrating skills, agents, or commands from Claude Code (CEP) to Systematic? See the Conversion Guide for field mappings and examples.

References

• OpenCode Documentation — Official OpenCode platform docs
• Compound Engineering Plugin — Original Claude Code workflows
• Plugin Source Code — View the implementation

License

MIT © Marcus R. Brown