From Commands to Plugins: How Gopher AI Changed My Go Workflow

Overview

I wrote about Claude Commands a few weeks ago. Clone this, symlink that, update manually. It worked, but managing individual command repos felt like the early days of GOPATH. Then Claude Code introduced plugins, and everything clicked. Now I have opinionated dev workflows, auto-invoked best practices, and Go training materials baked right in—no symlinking required.

The Command Management Problem

Don't get me wrong—commands were a revelation. Encoding my workflows as reusable prompts changed how I worked with AI. But the installation story was rough.

Every command was its own repo. Want ten commands? Clone ten repos. Symlink ten files. When a command got updated, I had to remember to git pull in the right directory. I'd forget which commands I even had installed. And sharing my setup with teammates? Good luck explaining a twelve-step installation process.

The friction wasn't in using commands—it was in managing them.

Plugins Are Just Commands That Work Together

A plugin isn't magic. It's a bundle of related commands, skills, and configurations that install as a unit. One marketplace add. A few plugin installs. Done.

But it's more than just convenience. Plugins can include *skills*—instructions that Claude applies automatically without you invoking a command. And they can connect to external services via MCP, giving Claude access to tools and data that live outside your codebase.

Commands were prompts you only write once. Plugins are workflows you only install once.

What Gopher AI Is

Gopher AI is a plugin suite built by Gopher Guides. It's available through Claude Code's plugin marketplace and includes six integrated plugins.

Most of the plugins are general dev workflows—issue tracking, commits, standups, changelogs—that work with any language. They're just more opinionated than what Claude ships with. Three plugins are Go-specific: idiomatic code patterns, our training materials, and our recommended web stack.

What Becomes Possible

Once you install Gopher AI, Claude works the way I work. The workflows are what I'd do manually—encoded as prompts so I don't have to repeat myself.

Issue-to-PR Workflow

I work on multiple issues in parallel. One command handles everything:

/start-issue 456

That's it. The command walks through a complete workflow:

1. Fetches full context — Issue details, labels, body, and all comments
2. Asks about worktree — "Create isolated worktree for this issue?" (optional)
3. Auto-detects type — Analyzes labels first, then title/body patterns
4. Routes intelligently — Bug vs feature workflow based on detection
5. Asks if uncertain — Falls back to user choice when detection is ambiguous

Git worktrees let you work on multiple issues simultaneously without stashing or switching branches. By integrating worktree creation into /start-issue:

• One command handles the entire setup
• Automatically copies LLM configs (.claude, .codex, .cursor)
• Prompts about .env files (security-conscious)
• Switches to the new directory and continues with the issue workflow

Comments often contain critical context like reproduction steps, clarifications from maintainers, and updated acceptance criteria—and /start-issue fetches all of them.

Auto-Invoked Best Practices

This is where plugins get interesting. The go-dev plugin includes a skill called "Go Best Practices" that Claude invokes automatically when you're writing or reviewing Go code.

You don't run a command. Claude just applies idiomatic patterns: proper error wrapping, small interfaces, table-driven tests, avoiding global state. It's like pair programming with someone who's read every Go style guide.

Standup Generation

Monday morning. I need to write up what I did last week. Instead of digging through git logs:

/standup

It scans my commits, groups them by type (features, fixes, refactors), identifies in-progress work, and generates a copy-paste ready standup. On Mondays, it automatically looks back to Friday.

Training Materials at Your Fingertips

The gopher-guides plugin connects Claude to our official training materials via MCP. When you ask "what's the right way to handle context cancellation?" Claude doesn't just guess—it consults the same curriculum we use to train teams at companies like Coinbase and Uber.

The Six Plugins Worth Knowing

go-workflow (language-agnostic)

Issue-to-PR automation with git worktree management. Works with any language:

• /start-issue <number> — Complete workflow: fetches context (including comments), optionally creates worktree, auto-detects bug vs feature, routes to appropriate workflow
• /create-worktree <number> — Creates isolated worktree only (when you want isolation without starting a workflow)
• /remove-worktree — Interactive worktree selection and removal
• /prune-worktree — Batch cleanup of completed issue worktrees
• /commit — Auto-generates commit message from staged changes

go-dev (Go-specific)

Go-specific development tools emphasizing idiomatic patterns:

• /test-gen <target> — Generates comprehensive tests with table-driven patterns
• /lint-fix [path] — Auto-fixes linting issues with golangci-lint
• /explain <target> — Deep-dive code explanations with diagrams
• Go Best Practices skill — Auto-invoked when writing Go code

productivity (language-agnostic)

Git-based productivity helpers. Works with any project:

• /standup [timeframe] — Generates standup notes from recent commits
• /weekly-summary [weeks] — Creates weekly work summaries with metrics
• /changelog [since] — Generates changelog from commits since last release

gopher-guides (Go-specific)

Go training material integration via MCP:

• Gopher Guides skill — Auto-invoked for authoritative answers on Go patterns
• MCP tools: audit_code, best_practices, get_example, review_pr

llm-tools (language-agnostic)

Multi-LLM integration for second opinions and format conversion. Works with any language:

• /codex <prompt> — Delegate tasks to OpenAI Codex CLI (supports review and exec modes)
• /gemini <prompt> — Query Google Gemini for analysis
• /ollama <prompt> — Use local models via Ollama (your code never leaves your machine)
• /llm-compare <prompt> — Compare responses from multiple LLMs side-by-side
• /convert <from> <to> — Convert between formats (JSON→TypeScript, SQL→Prisma, CSV→JSON)
• Second Opinion skill — Auto-suggests getting another LLM's perspective for complex decisions

Different models have different strengths. Sometimes you want a sanity check on an architectural decision, or a second set of eyes on security-critical code. The /ollama command is particularly useful for sensitive codebases—your code stays on your machine.

go-web (Go-specific)

Opinionated Go web app scaffolding with our recommended stack:

• /create-go-project <name> — Interactive project setup with database, auth, and deployment choices
• /convert-to-go-project — Migrate existing Express.js, Django, Laravel, or Next.js projects to Go

• Go + Echo v4 — Fast, minimalist web framework
• Templ — Type-safe HTML templates that compile to Go
• HTMX — Server-driven interactivity without heavy JavaScript
• Alpine.js — Lightweight client-side interactivity
• Tailwind CSS v4 — Utility-first styling with dark mode
• sqlc — Type-safe SQL queries (no ORM)
• goose — Database migrations
• Air — Hot reload for development

Default deployment: Vercel + Neon PostgreSQL (free tier friendly).

Getting Started

Add the Gopher AI marketplace—this one command installs all six plugins:

/plugin marketplace add gopherguides/gopher-ai

That's it. No cloning, no symlinking, no manual updates.

Configuration

GOPHER_GUIDES_API_KEY

Required for the gopher-guides plugin to access training materials.

To get your API key:

1. Visit gopherguides.com
2. Sign up for an account or log in
3. Navigate to your account settings
4. Generate an API key for Claude Code integration

Then add it to your shell configuration:

echo 'export GOPHER_GUIDES_API_KEY="your-key-here"' >> ~/.zshrc && source ~/.zshrc

Team Setup

For teams, you can add the marketplace to your project's .claude/settings.json so everyone gets the same setup:

{
  "extraKnownMarketplaces": {
    "gopher-ai": {
      "source": {
        "source": "github",
        "repo": "gopherguides/gopher-ai"
      }
    }
  }
}

Commit this file, and teammates can install the plugins without adding the marketplace manually.

Managing Plugins

To uninstall plugins or see what you have installed, use the plugin manager:

/plugin uninstall @plugins/gopher-guides/.claude-plugin/

This brings up an interactive interface showing all installed plugins:

From here you can:

• Space — Toggle plugin on/off
• Enter — View plugin details
• Delete — Uninstall the selected plugin
• Esc — Go back

Known Issues

There's a bug in Claude Code where /plugin marketplace update refreshes the marketplace manifest but doesn't invalidate the plugin cache. This means updated command files won't take effect until you clear the cache manually.

Run the refresh script from anywhere:

curl -fsSL https://raw.githubusercontent.com/gopherguides/gopher-ai/main/scripts/refresh-plugins.sh | bash

This clears the plugin cache, marketplace files, installed_plugins.json, and known_marketplaces.json (the last one was the missing piece that caused stale data). Then restart Claude Code.

I'll update this section once the bug is resolved.

I Want Your Feedback

Gopher AI is open source and actively developed. I want to know what's working and what isn't.

For bugs, feature requests, or ideas for new plugins, open an issue on GitHub.

For general thoughts or just to say hi, find me on Twitter/X (@corylanou) or LinkedIn. You can also reach Gopher Guides (@gopherguides) on Twitter or LinkedIn.

What commands would make your Go workflow better? Build one and submit it.