Skip to content
/
Tier A A6 Multi-agent orchestrator

Claude Command Suite (qdhenry)

claude-command-suite-qdhenry · qdhenry/Claude-Command-Suite · ★ 1.3k · last commit 2026-03-01

216+ slash commands across 26 domain namespaces + 12 skills + 54 agents covering full-stack development, DevOps, security, media processing, browser AI, and business scenario modeling.

Best whenCommand namespace organization should mirror real development domains, including specialized verticals like Svelte-specific and Rust-specific commands.
vs seeds
spec-kit's flat 9-command structure. Unli…
Primitive shape 282 total
Commands 216 Skills 12 Subagents 54
00

Summary

Claude Command Suite (qdhenry) — Summary

Claude Command Suite is a comprehensive development toolkit from qdhenry featuring 216+ slash commands organized into 26 namespaced directories, 12 Claude Code skills, and 54 AI agents covering the full software development lifecycle. Commands are namespace-organized (/dev:code-review, /test:generate-test-cases, /deploy:prepare-release), covering deployment, security, performance, media processing, WebMCP browser integration, business scenario modeling, GitHub-Linear synchronization, Svelte-specific hooks, and Rust development. Twelve skills cover specialized domains including Linear task management, Cloudflare infrastructure, WebMCP, BigCommerce API, audio/video transcription (ElevenLabs), and multi-agent dead code removal. Notably, the .claude/hooks/ directory contains Svelte-specific hook documentation (not Claude Code lifecycle hooks) alongside an install-svelte-hooks.sh script, indicating toolchain hook integration rather than Claude Code event hooks. The suite includes a skill-builder agent capability for creating new skills. Compared to seeds, it occupies the "mirror commands + skills" archetype (like spec-kit and openspec) but at much larger scale (216 commands vs 9-11) and with more specialized vertical domains; unlike superpowers (skills-only), it invests heavily in explicit slash commands.

01

Overview

Claude Command Suite (qdhenry) — Overview

Origin

Created by qdhenry (1,258 stars, last push 2026-03-01). Built following Anthropic's Claude Code Best Practices. Version 3.2.0 per release notes.

Philosophy

From README:

"A comprehensive development toolkit designed following Anthropic's Claude Code Best Practices for AI-assisted software development."

The suite emphasizes command completeness: every development domain has dedicated namespace + commands. Skills complement commands by providing model-invoked capabilities for recurring workflows.

Scope

Unusually broad vertical coverage:

  • Standard software development (dev, test, security, performance, deploy)
  • Svelte-specific development (svelte, 16 commands)
  • Rust development (rust, 8 commands)
  • Media processing (audio/video via ElevenLabs API)
  • Business scenario simulation
  • WebMCP browser AI tool integration
  • Linear + GitHub synchronization
  • Cloudflare Workers deployment
  • WFGY (Why-Forget-Graph-Yourself) — knowledge graph reasoning

Versions

Release notes through v3.2.0 documented in RELEASE_NOTES_v3.2.0.md.

Notable Capabilities

  • /dev:prime — project context loading
  • /orchestration:* — multi-agent coordination commands
  • /simulation:* — business and architecture scenario modeling
  • /wfgy:* — knowledge graph-based reasoning commands
  • Svelte Advanced Hooks — documented Svelte lifecycle + compiler hooks (not Claude Code hooks)
  • Skill Builder — agent capability for creating new skills
02

Architecture

Claude Command Suite (qdhenry) — Architecture

Distribution

Standalone repo with install script.

git clone https://github.com/qdhenry/Claude-Command-Suite
cd Claude-Command-Suite
./install.sh

Directory Structure

.claude/
  commands/                    # 216+ slash commands in 26 namespaces
    boundary/  context/  deploy/  dev/  docs/
    media/  memory/  orchestration/  performance/
    project/  reasoning/  rust/  security/  semantic/
    session/  setup/  simulation/  skills/
    spec-workflow/  svelte/  sync/  team/
    test/  webmcp/  wfgy/
  agents/                      # 54 specialized agents
    README.md  TASK-STATUS-PROTOCOL.md  WORKFLOW_EXAMPLES.md
    agent-organizer.md  architecture-auditor.md
    azure-devops-specialist.md
    business/  code-auditor.md  data-ai/  dependency-analyzer.md
    development/  external/  infrastructure/  integration-manager.md
    performance-auditor.md  project-architect.md
    quality-testing/  release-manager.md
    security/  skill-builder/  specialization/
    strategic-analyst.md  svelte-development.md
    swift-macos-expert.md  task-commit-manager.md
    task-decomposer.md  task-orchestrator.md  test-engineer.md  wfgy/
  skills/                      # 12 Claude Code skills
    audit-env-variables/  bigcommerce-api/  cloudflare-manager/
    elevenlabs-transcribe/  extract-video-frames/  file-watcher/
    gsap-animation/  linear-todo-sync/  remove-dead-code/
    setup-agent-tail/  setup-portless/  webmcp/
  hooks/                       # Svelte hooks documentation (NOT Claude Code lifecycle hooks)
    scripts/  examples/  svelte-hooks.md
    svelte-advanced-hooks.md  svelte-performance-hooks.md
    install-svelte-hooks.sh
.feature-tracking/             # Feature tracking support files
scripts/                       # Utility scripts

Install

./install.sh    # copies to ~/.claude/

Required Runtime

  • Node.js/Bun (for Cloudflare Workers skills)
  • API keys: CLOUDFLARE_API_KEY (cloudflare-manager), ELEVENLABS_API_KEY (elevenlabs-transcribe)
  • Linear API token (linear-todo-sync)

Target AI Tools

Claude Code (primary). Install script targets Claude Code directories.

03

Components

Claude Command Suite (qdhenry) — Components

Totals

Type Count
Commands (namespaced) 216+
Skills 12
Agents 54
Claude Code hooks 0 (hooks/ dir = Svelte toolchain hooks)

Command Namespaces (26 directories, representative sample)

Namespace Count Domain
dev 25 Code review, refactoring, debugging, incremental build, prime, etc.
project 15 Project init, task management, git workflows
deploy 10 Deployment, CI/CD, Cloudflare, Docker
setup 15 Environment setup, toolchain configuration
orchestration 11 Multi-agent coordination
simulation 10 Business and architecture scenario modeling
test 11 Test generation, coverage, automation
sync 13 GitHub-Linear sync, cross-platform
team 13 Team collaboration, onboarding, standup
svelte 16 Svelte-specific development, components, hooks
rust 8 Rust-specific commands
security 5 Security scanning, compliance
performance 9 Performance profiling, optimization
docs 7 Documentation generation
memory 5 Context and memory management
semantic 6 Semantic analysis
wfgy 7 Why-Forget-Graph-Yourself knowledge reasoning
webmcp 5 WebMCP browser AI tool integration
media 2 Audio/video processing
reasoning 5 Extended reasoning commands
skills 6 Skill management commands
context 1 Context management
boundary 5 Boundary/scope enforcement
session 2 Session management
spec-workflow 6 Spec-driven development workflow

Notable Commands (verbatim names)

  • /dev:prime — load project context
  • /dev:all-tools — enable all tools
  • /dev:ultra-think — extended thinking mode
  • /dev:parallel-feature-build — parallel feature construction
  • /dev:incremental-feature-build — incremental feature construction
  • /dev:xml-prompt-formatter — XML prompt formatting
  • /orchestration:* — multi-agent coordination
  • /simulation:* — scenario modeling + decision analysis
  • /wfgy:* — knowledge graph reasoning
  • /svelte:* — Svelte-specific (16 commands)

Skills (12)

Skill Domain
linear-todo-sync Linear task management + GraphQL API
cloudflare-manager Cloudflare Workers, KV, R2, Pages, DNS
webmcp WebMCP browser-native AI tool integration
bigcommerce-api BigCommerce REST V2/V3, GraphQL Storefront
audit-env-variables .env file security audit + unused var detection
remove-dead-code Multi-agent parallel dead code removal
elevenlabs-transcribe Audio/video transcription (ElevenLabs Scribe v2)
extract-video-frames Video frame extraction via ffmpeg
file-watcher Chokidar-based file change watcher → claude -p
gsap-animation GSAP animation expertise
setup-agent-tail Agent log tailing setup
setup-portless Portless environment setup

Agents (54, representative sample)

  • task-orchestrator — complex workflow management + dependency mapping
  • task-decomposer — break projects into atomic tasks
  • task-commit-manager — git commit + task tracking integration
  • integration-manager — GitHub-Linear bidirectional sync
  • architecture-auditor — architecture review specialist
  • code-auditor — automated code review
  • strategic-analyst — business scenario modeling
  • svelte-development / svelte-storybook / svelte-testing — Svelte specialists
  • swift-macos-expert — Swift/macOS development
  • azure-devops-specialist — Azure DevOps integration
  • performance-auditor — performance analysis
  • test-engineer — test generation + coverage analysis
  • release-manager — release coordination
  • agent-organizer — multi-agent coordinator
  • skill-builder subfolder — skill creation agents

Hooks Note

The .claude/hooks/ directory contains Svelte framework hook documentation (Svelte lifecycle hooks, Svelte compiler hooks, performance hooks) and install-svelte-hooks.sh. These are NOT Claude Code lifecycle hooks (PreToolUse/PostToolUse/etc.) — they are toolchain integration docs. Claude Code hooks count: 0.

05

Prompts

Claude Command Suite (qdhenry) — Prompt Excerpts

Excerpt 1: task-orchestrator Agent

Technique: Capability matrix + orchestration strategy taxonomy (structured knowledge encoding)

---
name: task-orchestrator
description: Orchestrates complex multi-step tasks, coordinating dependencies and managing parallel execution for optimal workflow efficiency.
tools: Read, Write, Edit, Bash, Grep, Glob, TodoWrite
---

You are a task orchestrator specializing in complex workflow management and task coordination. Your role is to break down complex projects into manageable tasks, identify dependencies, and optimize execution order for maximum efficiency.

## Core Capabilities
### 1. Task Analysis
- Decompose complex projects into atomic tasks
- Identify task dependencies and prerequisites
- Estimate effort and complexity
- Determine parallelization opportunities

### 2. Dependency Management
- Create dependency graphs
- Identify critical paths
- Detect circular dependencies

## Orchestration Strategies

### Task Decomposition

Project Goal ├── Epic 1 │ ├── Feature A │ │ ├── Task 1 (2h, no deps) │ │ ├── Task 2 (4h, depends on Task 1) │ │ └── Task 3 (3h, parallel with Task 2) │ └── Feature B └── Epic 2


### Workflow Patterns
1. **Pipeline Pattern** — linear task progression, suitable for CI/CD
2. **Fork-Join Pattern** — parallel execution with synchronization

Analysis: Tree-ASCII dependency visualization technique — encodes task decomposition patterns as concrete examples rather than abstract rules. TodoWrite tool grant enables persistent todo list management.

Excerpt 2: code-review Command (dev/code-review.md)

Technique: Numbered checklist with 8 distinct review dimensions (systematic coverage pattern)

# Comprehensive Code Quality Review

## Instructions

1. **Repository Analysis** — Examine structure, identify primary language/framework
2. **Code Quality Assessment** — Scan for code smells, anti-patterns, naming consistency
3. **Security Review** — OWASP Top 10, hardcoded secrets, auth logic
4. **Performance Analysis** — Bottlenecks, inefficient algorithms, memory leaks
5. **Architecture & Design** — Separation of concerns, modularity, coupling
6. **Testing Coverage** — Existing coverage, untested areas, test quality
7. **Documentation Review** — Comments, API docs, README completeness
8. **Recommendations** — Prioritized action items

Analysis: Systematic coverage pattern — ensures no review dimension is skipped. No frontmatter model specification, so inherits user's current model context.

09

Uniqueness

Claude Command Suite (qdhenry) — Uniqueness & Positioning

Differs From Seeds

Closest archetype is spec-kit (mirror commands + skills), but at ~24x the command count and with a fundamentally different namespace organization model. Unlike openspec (11 cmd / 11 skill mirrored pairs), qdhenry uses 26 semantic namespaces where commands and skills address different activation patterns — skills are model-invoked, commands are user-invoked. The WFGY (Why-Forget-Graph-Yourself) knowledge graph commands have no parallel in any seed. The .claude/hooks/ directory containing Svelte framework hook documentation is the most confusing naming choice in any repo in this batch — it will mislead users expecting Claude Code lifecycle hooks. No seed has a media processing vertical (ElevenLabs transcription, ffmpeg frame extraction) or a browser-native WebMCP integration namespace.

Distinctive Position

Broadest command namespace diversity in this batch: 26 distinct domains including unusual verticals (Svelte-specific, Rust-specific, WFGY, WebMCP, media processing, business simulation). The skill-builder agent enables in-suite skill creation — a meta-capability.

Observable Failure Modes

  1. hooks/ naming confusion: Users expecting Claude Code lifecycle hooks find Svelte documentation — this is a documentation/naming problem that will cause real confusion.
  2. External API keys: Multiple skills require external API credentials (Linear, Cloudflare, ElevenLabs) — failures will be silent until the user attempts to use those skills.
  3. Command discovery: 216+ commands across 26 namespaces with no built-in discovery mechanism — users must know the namespace to find the command.
  4. Agent subdir nesting: 54 agents in nested subdirectories (business/, development/, etc.) — some agents may not be auto-discovered by all Claude Code versions.

Explicit Antipatterns

None explicitly stated. SKILL_BUILDER_ENHANCEMENTS.md and SKILL_BUILDER_SUMMARY.md in root suggest active skill quality improvement efforts.

04

Workflow

Claude Command Suite (qdhenry) — Workflow

Core Development Workflow

  1. Install suite (./install.sh)
  2. Prime project context: /dev:prime
  3. Use domain-specific commands by namespace
  4. Skills activate contextually for supported domains
  5. Agents handle complex multi-step tasks

Multi-Agent Workflow (via task agents)

  1. /orchestration:* commands initiate coordination
  2. task-orchestrator agent decomposes work into dependency graph
  3. task-decomposer creates atomic task list
  4. Domain agents (architecture-auditor, test-engineer, etc.) execute
  5. task-commit-manager handles git commit tracking

Skill Activation

Skills are model-invoked (contextual trigger phrases):

  • linear-todo-sync: triggered by "What do I need to work on?", "Show my work"
  • remove-dead-code: triggers when dead code removal is requested → spawns parallel scout agents
  • audit-env-variables: triggered by env variable security auditing requests

Remove-Dead-Code Multi-Agent Pattern

The remove-dead-code skill uses internal multi-agent pattern:

  1. Parallel scout agents analyze unused exports, orphaned files, dead imports
  2. Backup branch created automatically before any removal
  3. Post-removal validation: TypeScript check + build + test suite

Phase-to-Artifact Map

Phase Artifact
Project prime Context files loaded
Feature development Code + tests
Skill activation (linear-todo-sync) Markdown task list with Linear links
Skill activation (cloudflare-manager) Deployed Workers + KV/R2 config
Agent orchestration Multi-agent coordinated output

Approval Gates

None explicitly defined in commands. remove-dead-code skill creates backup branch as safety mechanism before destructive operations.

Spec-Workflow Namespace

spec-workflow/ (6 commands) covers spec-driven development, suggesting integration with spec workflows but details not fully documented.

06

Memory Context

Claude Command Suite (qdhenry) — Memory & Context

State Storage

File-based. The .feature-tracking/ directory suggests lightweight feature tracking persistence.

Memory Commands (5 in memory/ namespace)

Commands for context management — exact names not fetched but namespace exists for memory/context operations.

Session Management

/session:* (2 commands) and /context:* (1 command) provide session-level context operations.

Linear TODO Sync

The linear-todo-sync skill provides external persistence via Linear project management tool:

  • Reads Linear tasks via GraphQL API
  • Outputs prioritized markdown with actionable links
  • Requires LINEAR_API_TOKEN

Cross-Session Handoff

No built-in mechanism beyond file-based context. /dev:prime loads project context at session start.

Multi-Agent State in remove-dead-code

The remove-dead-code skill creates a backup branch before operations, providing rollback capability. Post-removal validation ensures state integrity before committing changes.

07

Orchestration

Claude Command Suite (qdhenry) — Orchestration

Multi-Agent Support

Yes — dedicated orchestration namespace (11 commands) + task-orchestrator/task-decomposer agents + remove-dead-code skill's parallel scout pattern.

Orchestration Pattern

Task-decomposition-tree: task-orchestrator creates dependency graphs, identifies parallel vs sequential tasks, optimizes execution order. Fork-join and Pipeline patterns explicitly documented in agent.

Isolation Mechanism

Process-level (Claude Code native). remove-dead-code skill creates a backup git branch as a safety isolation mechanism before destructive operations.

Multi-Model

No explicit model routing. Task agents don't specify model in frontmatter (inherit user context).

Execution Mode

Interactive-loop (commands invoked on demand).

Consensus

None.

Prompt Chaining

Implicit in orchestration agents — task-orchestrator passes decomposed work to domain agents. No formal protocol.

WFGY Knowledge Graph Reasoning

The wfgy namespace (7 commands) and wfgy/ agents implement Why-Forget-Graph-Yourself pattern — a knowledge graph-based reasoning system for avoiding repeated "forgetting" of context. This is an unusual pattern not present in other repos in this batch.

Svelte Hooks (Toolchain, Not Claude Code)

.claude/hooks/ contains Svelte lifecycle and compiler hook documentation. These are Svelte framework hooks (component lifecycle, reactive declarations, compiler directives) — distinct from Claude Code's PreToolUse/PostToolUse/etc. lifecycle hooks. Zero Claude Code lifecycle hooks in this repo.

08

Ui Cli Surface

Claude Command Suite (qdhenry) — UI / CLI Surface

Dedicated CLI

None. Install via ./install.sh script.

Local Dashboard

None.

IDE Integration

Claude Code only (native slash command + agent invocation).

Notable Integration Points

  • Linear (via linear-todo-sync skill + integration-manager agent): bidirectional task sync
  • Cloudflare (via cloudflare-manager skill): Workers deployment, KV, R2, DNS
  • ElevenLabs (via elevenlabs-transcribe skill): audio/video transcription API
  • WebMCP (via webmcp skill + commands): browser-native AI tool integration (Chrome 146+)
  • GitHub (via sync namespace + integration-manager): GitHub-Linear bidirectional sync
  • Azure DevOps (via azure-devops-specialist agent): ADO integration

Observability

None built-in. setup-agent-tail skill provides log tailing setup. No audit log.

Skill Invocation

Skills are invoked via natural language triggers, not explicit commands. Context triggers documented per skill (e.g., "What do I need to work on?" triggers linear-todo-sync).

Related frameworks

same archetype · same primary tool · same memory type

Claude-Flow / Ruflo ★ 55k
A6 Multi-agent orchestrator

Eliminates single-agent context limits and sequential bottlenecks by orchestrating fault-tolerant swarms of specialized AI agents…

Hermes Agent (NousResearch) ★ 168k
A6 Multi-agent orchestrator

Self-improving personal AI agent with closed learning loop, 7 terminal backends, and messaging gateway — not tied to any AI…

OpenCode ★ 165k
A6 Multi-agent orchestrator

Terminal-first AI coding agent with multi-model routing, native desktop app, and a typed .opencode/ configuration system for…

OpenHands ★ 75k
A6 Multi-agent orchestrator

Open-source AI software development platform (open-source Devin alternative) with Docker sandbox isolation, 77.6% SWE-bench…

DeerFlow ★ 70k
A6 Multi-agent orchestrator

Long-horizon superagent that researches, codes, and creates by orchestrating parallel sub-agents with isolated contexts in Docker…

oh-my-openagent (omo) ★ 60k
A6 Multi-agent orchestrator

Multi-provider AI agent orchestration for OpenCode: escape vendor lock-in by routing Sisyphus (Claude/Kimi/GLM) and Hephaestus…