Introducing GraphOps: A Easy-to-Use Graph Engineering Plugin for Claude Code

erin — Tue, 15 Sep 2026 14:38:01 +0000

In my day-to-day engineering work, I've been driving development by combining ticket-driven development (using Jira) with Graph Engineering (AI-driven development powered by execution graphs). While introducing graph engineering has significantly elevated the quality of our AI outputs, Jira itself can feel a bit heavy and over-engineered for solo developers or small, agile teams.

I wished there were an easier, more lightweight way to reap the benefits of graph engineering.

That's why I created and open-sourced GraphOps, a Claude Code plugin that combines lightweight ticket management with execution graphs (DAGs / parallel execution / loopbacks)! It requires no local build setup—you can control everything directly via Claude Code slash commands and an intuitive Web UI.

Far from being just another ticket-tracking tool, GraphOps' standout feature is how it structures a ticket's workflow into a dynamic execution graph made of "nodes" and "edges." It orchestrates autonomous, parallel execution to maximize the performance of AI agents.

In this article, I'll walk through the development experience GraphOps unlocks, the mechanics of how graph engineering elevates output quality, and how you can get started right away.

Why "Graph Engineering"?

When handing off a task to an AI coding assistant (like Claude Code) with a single, open-ended prompt like "Please implement feature X," developers commonly run into several pain points:

Misaligned Assumptions & Premise Drift: The agent jumps straight into writing code without validating plans or architecture, only for fundamental design flaws to surface later.
Overlooked Review Perspectives: Beyond basic code syntax and cleanliness, critical multidimensional checks—such as security, QA edge cases, non-functional requirements (performance, logging, availability), and accessibility—are rarely handled thoroughly in one pass.
Ambiguous Rework & Context Pollution: When a test fails, the agent often attempts haphazard in-place fixes, leading to messy regressions, infinite loops, and token-heavy context pollution.
Black-Box Execution: It’s difficult for humans to see which stage the AI is currently in and why it made specific design decisions along the way.

Graph Engineering is a proven paradigm designed to tackle these exact problems, and it served as the core motivation behind building GraphOps.

Solving Challenges with Execution Graphs (DAG + Loops + Parallelism)

In GraphOps, every ticket's tasks are dynamically assembled into an execution graph:

Independent & Parallel Review Gates (review_gate): Multiple distinct perspectives—Code Quality, QA, Security (OWASP Top 10, etc.), Non-Functional Requirements (scalability/logging), and Accessibility (WCAG, etc. for UI changes)—are audited concurrently by independent subagents.
Loopback Structures for Automated Rework (loop_back_to): If a review gate fails or raises issues, the graph automatically loops back to the preceding implementation node. To prevent runaway infinite loops, built-in convergence controls relax criteria as iteration counts increase.
Human-in-the-Loop Approval Gates (approval_gate): By default, human approval gates are placed after the planning phase (plan_approval) and just before release (release_approval). Even if automated plan reviews pass, implementation will not start until a human signs off. Approvals can be granted with a single click from the Web UI, and rejections require a reason (free text), allowing the AI to re-triage context and automatically redo only the necessary nodes.

💡 Token Consumption vs. Output Quality
By formalizing a graph structure with explicit stages (Planning → Review → Approval → Implementation → Multi-perspective Parallel Reviews → Testing → Reporting) executed by dedicated subagents, the context processed by the AI naturally increases. Token consumption and execution time will undoubtedly rise (higher cost).

However, costly rework stemming from premise drift and missed requirements drops dramatically. Because plans are scrutinized before code is touched and implementations are vetted from specialized review angles, hallucinations and omissions are curtailed, yielding high-precision deliverables on the first pass. Because deliverables and artifacts from every node are cleanly persisted in the database and visible in the Web UI, the overall boost to development efficiency and peace of mind is substantial!

3 Core Components of GraphOps

GraphOps is architected around Claude Code in a minimal yet robust manner:

Go Core Binary (graph-engine):
- A single, CGO-free Go binary (utilizing a pure-Go SQLite driver) acting as both a CLI tool and a REST API server. Cross-compiles across macOS, Linux, and Windows.
- Manages persistence for tickets, nodes, edges, and deliverables (artifacts). Uses SQLite by default with zero config, but supports switching to MySQL for team collaboration.
- The engine handles graph expansion, DAG validation, convergence control, and artifact validation (such as HTML structural checks for reports).
Claude Code Plugin (@graph-ops/plugin):
- Exposes slash commands and skills (/onboarding, /create-ticket, /refine-ticket, /process-ticket, /ui).
- Dispatches dedicated graph-node-agent subagents to perform work node-by-node, running parallelizable nodes concurrently in the background.
Web UI Application (@graph-ops/web):
- A modern, responsive dashboard built with React, Tailwind CSS, and @xyflow/react.
- Features paginated/searchable ticket management with priority indicators, real-time interactive execution graph visualization, formatted artifact previews (Gherkin, Markdown, HTML), one-click approval/rejection for approval gates, and configuration editing.

Development Flow (The Practical Workflow)

A typical workflow with GraphOps proceeds as follows:

Initial Setup: `/onboarding` (Language Configuration)

After installing the plugin, run /onboarding once. It guides you through setting your preferred language (e.g., English or Japanese) for AI-generated deliverables (plans, Gherkin specs, review findings, reports) and review gate names, persisting it to your user configuration (~/.graph-ops/). Skeleton node names are bilingual (English / Japanese) by default.

Launching the Dashboard: `/ui` (Web UI Visualization)

Simply run /ui in your project's working directory. It automatically spins up the background backend server if not already running, and opens your browser directly to the ticket list and execution graph for that project (or prompts a "New Project" modal if unregistered).

Subsequent actions like creating tickets, refining them, or running them can be driven directly from Claude Code or with a single click from the Web UI.

1. `/create-ticket` (Interactive Ticket Drafting)

When you submit a request, Claude Code doesn't just create a ticket blindly. It engages in a brief dialogue to clarify scope, edge cases, and impacted files before registering the ticket in the DB.

2. `/refine-ticket` (Articulating Acceptance Criteria & "Why")

Collaborate with the AI to crystallize concrete acceptance criteria (Definition of Done) and the underlying "Why" (background and motivation), updating the ticket's description with sharp, actionable requirements.

3. `/process-ticket` (Graph-Driven Execution)

Now, autonomous graph execution takes over:

Seed Execution: The "Plan Creation (plan)" and "Plan Review (plan_review)" seed nodes run first.
Dynamic Graph Assembly: Once the plan passes review, the AI analyzes the nature of the ticket (investigation-only, standard feature, UI changes, etc.) and dynamically builds an execution graph patch tailored to the task (wiring up code, QA, security, accessibility review gates, and documentation steps).
Approval Gates & Parallel Execution: A human approves the plan (plan_approval). Then implementation kicks off, followed immediately by parallel review subagents auditing different facets simultaneously.
Testing & Fixed HTML Reporting: Gherkin behavioral tests run, results are reviewed, and a structured HTML test report (with summary, checks, and captures) is generated and saved as an artifact.
Release Approval: Finally, a human signs off on the release approval gate (release_approval) to wrap up.

Key Highlights

Here are some of the most compelling aspects of GraphOps:

1. Dynamic Graph Generation Tailored to Ticket Content

Workflows aren't confined to a rigid, one-size-fits-all pipeline. For example, for a documentation-only ticket, heavy Gherkin tests are omitted; for tickets involving UI changes, an accessibility review gate is automatically injected. The AI constructs an optimal execution graph based on the approved plan.

2. Multi-Tiered Customization for Team Guidelines

Configuration files merge hierarchically: Plugin Defaults → User Config (~/.graph-ops/) → Project Config (.graph-ops/).

Add or override team-specific review criteria (e.g., custom naming conventions, architectural rules).
Define custom node types and prompt instructions in Markdown inside your repo.
Customize skill behavior or swap the HTML report template for your organization's theme. All of this is achievable without touching plugin source code—just add YAML or Markdown files, or edit them straight from the Web UI's Settings modal.

3. Launching Interactive Claude Code Terminals from the Web UI

Clicking "Create", "Launch Claude", "Run", or "Refine" buttons in the Web UI immediately opens an external, interactive terminal (Terminal.app on macOS, tmux, iTerm2, etc.) running Claude Code. You can press Cmd+Enter (Mac) or Ctrl+Enter (Windows) to submit prompts without taking your hands off the keyboard, keeping full human control while enjoying the convenience of a browser dashboard.

Installation & Getting Started

No local build or compilation is required. You can install GraphOps directly inside Claude Code using the marketplace commands:

1. Add the Marketplace

Run the following command inside Claude Code to register the GraphOps marketplace:

/plugin marketplace add imahiro-t/graph-ops

2. Install the Plugin

Next, install and enable the plugin:

/plugin install graph-ops@graph-ops

Automated Platform Binary Resolution
During the initial install, the precompiled Go binary (graph-engine) matching your OS and architecture (macOS Apple Silicon / Intel, Linux, Windows) is automatically downloaded from GitHub Releases, verified via SHA256 checksums, and stored in a local cache. You don't even need a Go development environment installed on your machine.

To update to future releases, simply run claude plugin update graph-ops@graph-ops.

Once installed, navigate to your target project folder and run /ui to launch the dashboard and experience graph-engineered development firsthand!

Repository

GitHub: https://github.com/imahiro-t/graph-ops

Feedback and issues are warmly welcome!

Summary

Lightweight Ticket Management + Graph Engineering: Empowers solo developers and agile teams to execute high-caliber AI-driven development without heavy corporate tools.
Execution Graphs (DAG + Loopbacks + Parallelism): Formalizing plan, review, approval, implementation, parallel auditing, testing, and reporting eliminates misalignment and overlooked edge cases.
Zero-Build Onboarding: Get started immediately with just two commands (/plugin marketplace add and /plugin install).
Seamless Synergy: The blend of Claude Code skills, a standalone Go binary, and a React-powered Web UI offers a fast, fluid developer experience.
Maximized ROI: While token usage increases, the reduction in manual rework and the consistency of high-quality outputs deliver immense returns.

If you've ever felt that prompting alone yields unpredictable AI code or that missed reviews cause frustrating regressions, give GraphOps a spin and experience graph-engineered development!

DEV Community: erin