---

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.

$3

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

$3

- 🧠 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

$3

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

$3

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

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

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.

$3

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.

| Skill | Description |
|-------|-------------|
| using-systematic | Bootstrap skill — teaches the AI how to discover and use other skills |
| brainstorming | Collaborative design workflow for exploring ideas before planning |
| agent-browser | Browser automation using Vercel's agent-browser CLI |
| agent-native-architecture | Design systems where AI agents are first-class citizens |
| compound-docs | Capture solved problems as categorized documentation |
| creating-agent-skills | Expert guidance for writing and refining skills |
| file-todos | File-based todo tracking with status and dependency management |
| git-worktree | Manage git worktrees for isolated parallel development |

$3

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

`markdown
---
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.

$3

| Agent | Purpose |
|-------|---------|
| design-implementation-reviewer | Verify UI implementations match Figma design specifications |
| design-iterator | Systematic UI/UX refinement through iterative screenshots and improvements |

$3

| Agent | Purpose |
|-------|---------|
| best-practices-researcher | Research external best practices, documentation, and examples for any technology |
| framework-docs-researcher | Gather framework documentation and best practices |

$3

| Agent | Purpose |
|-------|---------|
| architecture-strategist | Analyze code changes from an architectural perspective |
| code-simplicity-reviewer | Final review pass for simplicity and YAGNI principles |
| pattern-recognition-specialist | Detect design patterns, anti-patterns, and code smells |
| performance-oracle | Performance analysis, bottleneck identification, scalability |
| security-sentinel | Security audits, vulnerability assessment, OWASP compliance |

$3

| Agent | Purpose |
|-------|---------|
| bug-reproduction-validator | Systematically verify and reproduce reported bugs |
| spec-flow-analyzer | Analyze specifications for user flow gaps and missing requirements |

$3

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.

$3

| Command | Description |
|---------|-------------|
| /workflows:brainstorm | Explore requirements through collaborative dialogue |
| /workflows:plan | Create detailed implementation plans |
| /workflows:review | Run code review with specialized agents |
| /workflows:work | Execute planned work systematically |
| /workflows:compound | Build compound documentation |

$3

| Command | Description |
|---------|-------------|
| /systematic:lfg | "Let's go" — start working immediately |
| /systematic:create-agent-skill | Create a new skill with guidance |
| /systematic:deepen-plan | Add detail to existing plans |
| /systematic:agent-native-audit | Audit code for agent-native patterns |

Configuration

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

$3

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

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

$3

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:

| Tool | Description |
|------|-------------|
| systematic_skill | Load Systematic bundled skills by name |

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

How It Works

Systematic uses three OpenCode plugin hooks:

`mermaid
%%{init: {'theme': 'base', 'themeVariables': { 'primaryColor': '#1a1a2e', 'primaryTextColor': '#fff', 'primaryBorderColor': '#4FD1C5', 'lineColor': '#4FD1C5', 'secondaryColor': '#16213e', 'tertiaryColor': '#0f0f23'}}}%%
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:#1a1a2e,stroke:#4FD1C5,color:#fff
style B fill:#16213e,stroke:#4FD1C5,color:#4FD1C5
style C fill:#16213e,stroke:#E91E8C,color:#E91E8C
style D fill:#16213e,stroke:#F5A623,color:#F5A623
style E fill:#0f0f23,stroke:#4FD1C5,color:#B2F5EA
style F fill:#0f0f23,stroke:#E91E8C,color:#B2F5EA
style G fill:#0f0f23,stroke:#F5A623,color:#B2F5EA
`

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

$3

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

$3

`bash


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
`

$3

`
├── 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
`

$3

`bash


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
`

$3

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