Installation

This page gets you from zero to your first Systematic workflow in under five minutes. Add one line to your OpenCode config, restart, and you are ready.

Prerequisites

You need OpenCode installed and running, plus Node.js 18+ or the Bun runtime. That is it. No API keys, no accounts, no extra tooling.

Install the OpenCode plugin

The OpenCode plugin is the recommended installation path. It provides the full experience: slash commands, the systematic_skill tool, agent registration, and automatic bootstrap.

Add the plugin to your OpenCode config

Open your global OpenCode config (typically ~/.config/opencode/opencode.json) and add Systematic to the plugins array:
```
{
  "plugins": ["@fro.bot/systematic@latest"]
}
```
If you already have other plugins, add it to the existing array.
Restart OpenCode

Close and reopen your OpenCode session. Systematic uses OpenCode’s config hook to register all bundled skills and agents automatically on startup. No manual wiring, no scaffolding commands.
Verify it’s working

In any conversation, check that systematic_skill appears in the available tool list. You can also run the bootstrap skill:
```
/systematic:using-systematic
```
If the skill loads and displays usage instructions, the installation succeeded.

Or install skill content with `npx skills`

Use npx skills to install the skill Markdown files directly. This path works in any AI harness (OpenCode, Claude Code, Cursor, Copilot) but installs the content only. It does not include slash-command registration, the systematic_skill tool, or automatic bootstrap.

Whole collection

Current project

Install all Systematic skills into the current working directory.

npx skills add marcusrbrown/systematic

Global install

All projects

Make skills available across all projects.

npx skills add marcusrbrown/systematic -g

Specific AI Harness

OpenCode / Claude Code

Target a specific AI coding assistant.

npx skills add marcusrbrown/systematic -a opencode

npx skills add marcusrbrown/systematic -a claude-code

Specific skill

Single workflow

Install just one skill instead of the entire collection.

npx skills add marcusrbrown/systematic --skill [name]

List skills

Discovery

See what skills are available in the collection before installing.

npx skills add marcusrbrown/systematic --list

Automatic asset discovery

Systematic requires zero manual file copying. When the plugin loads, it automatically:

Discovers all bundled skills and makes them available via the systematic_skill tool.
Registers bundled agents so you can @mention them immediately.
Exposes bundled skills as slash-invokable workflows (for example, /ce:plan).

Recommended: enable background subagents

Set OPENCODE_EXPERIMENTAL_BACKGROUND_SUBAGENTS=true before starting OpenCode. This allows Systematic workflows to dispatch subagents in the background. The orchestrator continues working while subagents run, and results are pushed into the parent session automatically upon completion.

export OPENCODE_EXPERIMENTAL_BACKGROUND_SUBAGENTS=true

Add this to your shell profile (.zshrc, .bashrc, or equivalent) to persist the setting.

This flag is experimental but stable in recent OpenCode versions. It is optional but recommended for parallel and long-running workflow steps. Without it, Systematic falls back to foreground dispatch, which is serial but correct.

Your first workflow

Systematic is built around a four-step loop. Here is what it looks like in practice, using a concrete task: adding a dark mode toggle.

Brainstorm — explore the problem before writing code
```
/ce:brainstorm "add dark mode toggle"
```
The brainstorm skill asks clarifying questions, surfaces edge cases, and produces a requirements document. You end up with a clear scope before a single line of code is written.
Plan — break the work into a structured implementation plan
```
/ce:plan
```
Takes the requirements document from the brainstorm and produces a sequenced implementation plan. For high-stakes work, run /systematic:deepen-plan afterward to stress-test the plan’s assumptions.
Work — execute the plan
```
/ce:work
```
The agent follows the plan, tracks progress, and surfaces blockers instead of silently guessing. You stay in the loop without micromanaging every step.
Review — check the work before opening a PR
```
/ce:review
```
Tiered persona agents check for correctness, security, performance, and style, in parallel. You get a structured report, not a wall of unranked comments.

After shipping, use /ce:compound to capture what you learned. That knowledge becomes part of the system and speeds up the next similar task.

Next steps

The Systematic Philosophy — understand why the loop is structured this way and what “compounding” actually means in practice.
Configuration — disable bundled content you don’t want, add project-specific skills, or configure agent overlays.
Skills Reference — browse all bundled skills and when to reach for each one.
Agents Reference — explore the specialized subagents available for review, research, and architecture work.