Claude commands guide

Claude Commands Usage Guide

Overview

This guide provides comprehensive information about using Claude Code commands in the Remind Tools project, with special focus on memory systems integration and sequential-thinking patterns.

Command Categories

Universal Memory Commands

/memory [information]

Purpose: Store information with intelligent server selection
Usage: /memory "MapBox integration requires API key configuration in environment variables"
Features:

• Automatic memory server selection based content analysis
• Business information → memory server
• Technical information → memory-arch server
• Team processes → memory-team server
• Sequential-thinking for complex information categorization

/remind [topic]

Purpose: Retrieve information from all memory systems
Usage: /remind "MapBox integration" or /remind "team Git Flow process"
Features:

• Multi-server parallel search
• Synthesized results from all memory systems
• Context-aware information retrieval
• Related information suggestions

Product Owner Commands

/create-prd

Purpose: Create comprehensive Product Requirements Document
Memory Integration:

• Queries general memory for similar features and business requirements
• Queries architectural memory for technical feasibility
• Saves PRD insights to general memory Sequential-thinking: Mandatory for business analysis and market assessment Usage: /create-prd "AI-powered trip planning with real-time suggestions"

Tech Lead Commands

/create-tasks

Purpose: Break down PRDs into actionable GitHub Issues
Memory Integration: Team workflows and task management patterns Usage: /create-tasks [GitHub Issue number]

/melos-bootstrap

Purpose: Initialize workspace with memory-enhanced optimization
Memory Integration:

• Team memory for previous bootstrap issues
• Architecture memory for workspace patterns
• Saves performance insights and optimization tips Usage: /melos-bootstrap

Senior Developer Commands

/implement-task

Purpose: Implement GitHub Issues with intelligent analysis
Memory Integration:

• Architectural memory for implementation patterns
• General memory for business context
• Saves implementation decisions and patterns Sequential-thinking: Mandatory for complex implementations (>3 files, cross-package) Usage: /implement-task [GitHub Issue number]

/debug-issue

Purpose: Systematic debugging with root cause analysis
Memory Integration:

• Architectural memory for similar debugging cases
• Team memory for debugging workflows
• Saves debugging patterns and solutions Sequential-thinking: Mandatory for complex or system-wide issues Usage: /debug-issue "Performance issue in MapBox rendering"

/quick-commit

Purpose: Fast commits with memory-enhanced patterns
Memory Integration:

• Team memory for commit preferences and patterns
• Learns from successful commit strategies
• Saves effective commit patterns Sequential-thinking: Optional for complex change sets (>10 files) Usage: /quick-commit or /quick-commit "Custom commit message"

DevOps Commands

/build-all-platforms

Purpose: Multi-platform builds with intelligent analysis
Memory Integration:

• Architectural memory for build optimizations
• Team memory for build processes
• Saves build performance metrics Sequential-thinking: Mandatory for comprehensive build analysis Usage: /build-all-platforms

Workflow Commands

/melos-clean, /melos-version

Purpose: Workspace management with memory integration
Memory Integration: Team workflow patterns and optimization insights Usage: /melos-clean, /melos-version

/smart-commit, /commit-grouped

Purpose: Advanced commit strategies with team learning
Memory Integration: Team commit patterns and preferences Usage: /smart-commit, /commit-grouped

Memory System Usage Patterns

Memory Server Selection Rules

1. General Memory (memory)

   • Business features and requirements
   • User stories and acceptance criteria
   • API integrations and data models
   • General project workflows and processes
   • Trigger words: feature, requirement, user story, business, API, integration

2. Architecture Memory (memory-arch)

   • Technical architecture and design patterns
   • Code organization and implementation decisions
   • Performance optimizations and security considerations
   • Testing strategies and build configurations
   • Trigger words: architecture, pattern, implementation, performance, testing

3. Team Memory (memory-team)

   • Team workflows and collaboration processes
   • Git Flow strategies and deployment procedures
   • Team member expertise and responsibilities
   • Meeting decisions and process improvements
   • Trigger words: team, workflow, process, Git Flow, deployment, collaboration

Daily Workflow Integration

1. Before Starting Tasks:

   /remind "relevant topic"  # Load context
   

2. During Implementation:

   • Commands automatically load relevant memory context
   • Sequential-thinking provides structured analysis for complex tasks
   • Cross-reference related information from different memory systems

3. After Completing Tasks:

   /memory "key insights and decisions made"  # Save learnings
   

Sequential-Thinking Integration

Automatic Triggers

• Complexity Detection: >3 files, cross-package operations, external API integrations
• Performance Issues: System performance problems requiring systematic analysis
• Architecture Changes: Major architectural decisions and refactoring

Role-Based Thinking Patterns

• Product Owner: Business analysis for market assessment and user impact
• Tech Lead: Architectural analysis for system design and technical feasibility
• Senior Developer: Implementation thinking for code organization and optimization
• DevOps: Build and deployment optimization with systematic analysis

Best Practices

Memory Management

1. Context Loading: Always query relevant memory before complex tasks
2. Knowledge Persistence: Save important decisions and insights after task completion
3. Cross-Reference: Use information from multiple memory systems for comprehensive context
4. Continuous Learning: Build on previous experiences for consistency and improvement

Command Usage

1. Simple Tasks: Use basic commands for quick operations
2. Complex Tasks: Leverage commands with sequential-thinking integration
3. Team Collaboration: Share memory insights and thinking traces with team members
4. Pattern Recognition: Learn from successful command executions and adapt workflows

Sequential-Thinking Usage

1. Mandatory Usage: Complex features, cross-service integrations, system-wide issues
2. Documentation: Treat thinking traces as living documentation for team reference
3. Role Alignment: Match thinking style to current responsibility and project phase
4. Iterative Improvement: Reference past thinking sessions for consistency

Command Reference Quick Guide

Command	Memory Integration	Sequential-Thinking	Use Case
/memory	Auto-selection	Optional	Store information intelligently
/remind	Multi-server query	Optional	Retrieve project context
/create-prd	General + Arch	Mandatory	Product planning
/implement-task	Arch + General	Mandatory (complex)	Feature implementation
/debug-issue	Arch + Team	Mandatory (complex)	Systematic debugging
/quick-commit	Team	Optional	Fast daily commits
/build-all-platforms	Arch + Team	Mandatory	Multi-platform builds
/melos-bootstrap	Team + Arch	No	Workspace initialization

Getting Started

1. Initialize Memory Context:

   /remind "project overview"
   /remind "current architecture"
   /remind "team processes"
   

2. Use Role-Appropriate Commands:

   • Product Owner: /create-prd, /remind "business requirements"
   • Tech Lead: /create-tasks, /architect-solution-smart
   • Senior Developer: /implement-task, /debug-issue
   • DevOps: /build-all-platforms, /setup-codemagic

3. Save Insights After Work:

   /memory "key decisions and learnings from today's work"
   

4. Build Team Knowledge:

   • Share thinking traces with team members
   • Reference previous solutions and patterns
   • Contribute to project memory systems regularly

This enhanced command system creates a learning, memory-enhanced development environment that continuously improves team productivity and decision-making quality.