# Introducing GraphOps: A Easy-to-Use Graph Engineering Plugin for Claude Code > Source: > Published: 2026-09-15 14:38:01+00:00 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. 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: **Graph Engineering** is a proven paradigm designed to tackle these exact problems, and it served as the core motivation behind building GraphOps. In GraphOps, every ticket's tasks are dynamically assembled into an **execution graph**: `review_gate`)` loop_back_to`)` approval_gate`)` 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! GraphOps is architected around Claude Code in a minimal yet robust manner: `graph-engine`)`@graph-ops/plugin`)`/onboarding`, `/create-ticket`, `/refine-ticket`, `/process-ticket`, `/ui`).` graph-node-agent` subagents to perform work node-by-node, running parallelizable nodes concurrently in the background.`@graph-ops/web`)`@xyflow/react`. A typical workflow with GraphOps proceeds as follows: 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. 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**. 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. 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. Now, autonomous graph execution takes over: `plan`)" and "Plan Review (` plan_review`)" seed nodes run first. Here are some of the most compelling aspects of GraphOps: 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. Configuration files merge hierarchically: **Plugin Defaults → User Config (`~/.graph-ops/`) → Project Config (`.graph-ops/`)**. 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. No local build or compilation is required. You can install GraphOps directly inside Claude Code using the marketplace commands: Run the following command inside Claude Code to register the GraphOps marketplace: ``` /plugin marketplace add imahiro-t/graph-ops ``` 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! Feedback and issues are warmly welcome! `/plugin marketplace add` and `/plugin install`). 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!