DOCSEARCHbyAlgolia
Submit Docs

Claude Command Suite Documentation

repository·main·Indexed 23 days ago

https://github.com/qdhenry/claude-command-suite

A development toolkit for AI-assisted software engineering designed for Anthropic's Claude Code. It provides a library of user-invoked slash commands organized by namespaces (such as /dev, /security, and /performance) and model-invoked 'Skills' for automated workflows like linear-todo-sync and cloudflare-manager. The suite includes the WFGY semantic reasoning system for mathematical validation and memory management, as well as a Skills Builder Framework for creating custom AI capabilities.

Tokens
6.4K
Snippets
14
Records
29
Agent score
80%

What's inside Claude Command Suite

  1. Explore Claude Command Suite namespaces

    main

    The Claude Command Suite is organized into several functional namespaces, each containing specialized commands for different stages of the development lifecycle. Commands are invoked using a slash-prefixed syntax (e.g., /namespace:command-name).

    Available Namespaces:

    • /project:*: Project management, initialization, and configuration (e.g., /project:init-project).
    • /dev:*: Development utilities like code review, debugging, and refactoring (e.g., /dev:code-review).
    • /test:*: Testing suite including unit, integration, and E2E testing (e.g., /test:write-tests).
    • /security:*: Security auditing, dependency scanning, and hardening (e.g., /security:security-audit).
    • /performance:*: Optimization tools for build times, bundle sizes, and database queries (e.g., /performance:optimize-build).
    • /sync:*: Integration and synchronization between GitHub Issues and Linear (e.g., /sync:bidirectional-sync).
    • /deploy:*: Deployment, release preparation, and containerization (e.g., /deploy:prepare-release).
    • /docs:*: Automated documentation generation for APIs and architecture (e.g., /docs:generate-api-documentation).
    • /setup:*: Environment setup, linting, and database schema design (e.g., /setup:setup-development-environment).
    • /team:*: Team collaboration tools like standup reports and sprint planning (e.g., /team:standup-report).
    • /simulation:*: Scenario modeling and decision analysis (e.g., /simulation:business-scenario-explorer).
    • /rust:*: Rust and Tauri-specific development and auditing tools (e.g., /rust:tauri:launch).
    • /webmcp:*: WebMCP integration for browser-native AI tools (e.g., /webmcp:setup).
    • /media:*: Audio and video processing (e.g., /media:extract-video-frames).
    • /session:*: Context handoff and session continuity (e.g., /session:handoff).
    • /orchestration:*: Complex task decomposition and workflow management (e.g., /orchestration:start).
    • /wfgy:*: Semantic reasoning and mathematical validation (e.g., /wfgy:init).
    • /semantic:*: Semantic memory tree management (e.g., /semantic:tree-init).
    • /boundary:*: Knowledge boundary detection and risk assessment (e.g., /boundary:detect).
    • /reasoning:*: Reasoning operations like multi-path exploration (e.g., /reasoning:multi-path).
    • /memory:*: Semantic memory management (e.g., /memory:checkpoint).

  2. Planned slash commands for project management

    main

    The Claude Command Suite roadmap includes a wide range of planned /project: slash commands designed to automate various stages of the software development lifecycle. These commands are categorized by domain to help developers manage setup, testing, documentation, DevOps, security, and specific technology stacks.

    Key command categories include:

    • Project Setup & Initialization: Commands like /project:init-project, /project:setup-monorepo, and /project:migrate-to-typescript for scaffolding and restructuring.
    • Testing & QA: Automation for unit, integration, E2E, visual, and property-based testing (e.g., /project:generate-test-cases).
    • Documentation: Automated generation of API docs, architecture diagrams, and onboarding guides (e.g., /project:explain-codebase-to-ai).
    • DevOps & Infrastructure: Containerization, Kubernetes manifests, and Infrastructure as Code (e.g., /project:containerize-application).
    • Security & Compliance: Hardening, authentication implementation, and vulnerability scanning (e.g., /project:security-hardening).
    • Performance & Optimization: Bundle size analysis, caching strategies, and database query optimization.
    • Database & Data Management: Schema design, migrations, and data pipelines.
    • API & Integration: REST/GraphQL design, versioning, and SDK generation.
    • Technology Specific Stacks: Specialized commands for React, Node.js, Python (Flask/Django/FastAPI), Mobile (React Native), and Cloud platforms (AWS/Vercel/Netlify).
    • Developer Experience: Hot reloading, debugger configuration, and Git hooks.

  3. Quality standards for skills created with the Skill Builder

    main

    Skills generated through the Skill Builder system are designed to meet the following success metrics and quality standards:

    • YAML Frontmatter: 100% valid.
    • Code Integrity: 100% syntax-checked and 100% security-scanned.
    • Validation: Average 9/10 validation score.
    • Documentation: Comprehensive documentation included.
    • Readiness: Production-ready on the first build.

  4. How Claude Code recognizes slash commands

    main

    Claude Code automatically detects markdown files located in the .claude/commands/ directory as slash commands. These files are loaded into the environment upon startup and are available for immediate use. To create a custom command, ensure the markdown file follows the required structure: a top-level # Title for the command name, a brief description, and a ## Instructions section containing the workflow steps.

    # My Custom Command

Performs a specific task in my project.

## Instructions

1. **First Step**
   - Do this thing
   - Check that thing

2. **Second Step**
   - Execute this action
   - Verify the result

  5. Understand the difference between Skills and Commands

    main

    The suite provides two primary ways to interact with Claude, distinguished by how they are triggered and their intended use cases.

    FeatureSkills (Model-Invoked)Commands (User-Invoked)
    ActivationContextually triggeredExplicit invocation via /command
    Use CaseRecurring workflows, domain expertiseSpecific task execution
    ScopePersonal or project-wideProject-specific
    DistributionGit repositories, pluginsCommand file copying

  6. Use the WFGY semantic reasoning system

    main

    The WFGY system provides mathematical validation, persistent memory, and hallucination prevention through several specialized command groups:

    Core Formula Commands (/wfgy:*)

    Used to apply mathematical reasoning formulas to the current context:

    • /wfgy:init: Initialize the system.
    • /wfgy:bbmc: Apply semantic residue minimization.
    • /wfgy:bbpf: Execute multi-path progression.
    • /wfgy:bbcr: Trigger collapse-rebirth correction.
    • /wfgy:bbam: Apply attention modulation.
    • /wfgy:formula-all: Apply all formulas in sequence.

    Semantic Memory (/semantic:*)

    Used to manage the persistent memory tree:

    • /semantic:tree-init: Create a new memory tree.
    • /semantic:node-build: Record semantic nodes.
    • /semantic:tree-view: Display the tree structure.
    • /semantic:tree-export: Export memory to a file.
    • /semantic:tree-import: Import an existing tree.
    • /semantic:tree-switch: Switch between trees.

    Knowledge Boundaries (/boundary:*)

    Used to detect and manage reasoning risks:

    • /boundary:detect: Check knowledge limits.
    • /boundary:heatmap: Visualize risk zones.
    • /boundary:risk-assess: Evaluate current risk.
    • /boundary:bbcr-fallback: Execute recovery.
    • /boundary:safe-bridge: Find safe connections.

    Reasoning Operations (/reasoning:*)

    Used for active reasoning tasks:

    • /reasoning:multi-path: Parallel reasoning exploration.
    • /reasoning:tension-calc: Calculate semantic tension.
    • /reasoning:logic-vector: Analyze logic flow.
    • /reasoning:resonance: Measure stability.
    • /reasoning:chain-validate: Verify logic chains.

    Memory Management (/memory:*)

    Used to maintain the memory tree:

    • /memory:checkpoint: Create recovery points.
    • /memory:recall: Search and retrieve memories.
    • /memory:compress: Optimize tree size.
    • /memory:merge: Combine related nodes.
    • /memory:prune: Remove stale or irrelevant memories.

  7. How the Skill Builder agent collaboration works

    main

    The Skill Builder system follows a sequential, human-in-the-loop agent collaboration pattern to ensure high-quality output and efficient context management.

    Collaboration Flow:

    1. User Request $\rightarrow$ skill-elicitation-agent (Gathers requirements).
    2. Specification $\rightarrow$ [User Approval] (Crucial step to ensure the plan is correct).
    3. Approved Spec $\rightarrow$ skill-generator-agent (Produces files).
    4. Skill Files $\rightarrow$ skill-validator-agent (Runs QA checks).
    5. Validation Report $\rightarrow$ If Fail, fix and re-validate; if Pass, proceed to next agent.
    6. Validated Files $\rightarrow$ skill-documenter-agent (Finalizes documentation).
    7. Final Skill Delivery.

    Design Principles:

    • Progressive Disclosure: To manage the Claude context window, core instructions live in SKILL.md, while technical details are offloaded to reference.md and examples.md. Claude only reads these files when needed.
    • Single Responsibility: Each agent is specialized for one phase (Elicitation, Generation, Validation, or Documentation).

  8. Understand the Skill directory structure

    main

    A skill follows a specific directory structure to manage how files are loaded into the AI's context:

    • SKILL.md (required): The main definition file.
    • scripts/ (optional): Executable code that gets rewritten repeatedly by the agent.
    • references/ (optional): Documentation files loaded into the context as needed (e.g., API docs, schemas).
    • assets/ (optional): Output files like templates, images, or boilerplate that are used in generated output but are not loaded into the AI's context.
    skill-name/
├── SKILL.md (required)
├── scripts/          (optional - executable code)
│   ├── process.py
│   └── helper.sh
├── references/       (optional - documentation)
│   ├── api-docs.md
│   ├── schemas.md
│   └── examples.md
└── assets/          (optional - output files)
    ├── templates/
    ├── images/
    └── boilerplate/

  9. Follow the complete skill creation workflow

    main

    To create, develop, and distribute a professional skill, follow these steps:

    1. Initialize: python .claude/commands/skills/scripts/init_skill.py my-skill
    2. Develop: Edit SKILL.md and populate scripts/, references/, and assets/.
    3. Validate: python .claude/commands/skills/scripts/quick_validate.py my-skill
    4. Package: python .claude/commands/skills/scripts/package_skill.py my-skill
    5. Distribute: Share the resulting .zip file with installation instructions.

  10. Use Claude Code Skills via natural language

    main

    Skills are model-invoked capabilities that are automatically activated by Claude based on the context of your conversation. Unlike slash commands, you do not need to type a specific command; instead, you use natural language triggers related to the skill's domain.

    Examples of triggering skills:

    • "What do I need to work on today?" (Activates linear-todo-sync)
    • "Deploy a cloudflare worker" (Activates cloudflare-manager)
    • "Set up WebMCP in this project" (Activates webmcp)
    • "Transcribe this audio file" (Activates elevenlabs-transcribe)
    • "Find and remove dead code" (Activates remove-dead-code)
    "What do I need to work on today?"  # Activates linear-todo-sync
"Deploy a cloudflare worker"        # Activates cloudflare-manager
"Set up WebMCP in this project"     # Activates webmcp
"Transcribe this audio file"        # Activates elevenlabs-transcribe
"Find and remove dead code"         # Activates remove-dead-code

  12. Build a Claude Code Skill using `/skills:build-skill`

    main

    The build-skill command orchestrates a four-phase, elicitation-driven workflow to create production-ready Claude Code skills. It uses specialized agents to move from requirements to a fully documented, validated skill.

    Workflow Phases:

    1. Requirements Elicitation: The skill-elicitation-agent asks 3-5 targeted questions to understand your needs and creates a YAML specification for your approval.
    2. Skill Generation: The skill-generator-agent creates the skill directory, including SKILL.md (with valid frontmatter), supporting files (like reference.md or examples.md), and any necessary scripts.
    3. Validation & Testing: The skill-validator-agent performs a 10-phase quality assurance check (syntax, security, structure, etc.) and provides a report.
    4. Documentation Enhancement: The skill-documenter-agent adds professional documentation, including beginner-to-advanced examples and troubleshooting guides.

    Supported Skill Types:

    • Simple Skills: Single SKILL.md file for instruction-based workflows (e.g., commit message helpers).
    • Multi-File Skills: SKILL.md plus supporting docs for complex workflows (e.g., PDF processing).
    • Tool-Restricted Skills: Safety-critical skills with limited tool access (e.g., read-only security analysis).
    • Code-Execution Skills: Skills bundled with scripts for deterministic operations (e.g., data transformation).
    /skills:build-skill

User: "Create a skill for writing conventional commit messages"