> ## Documentation Index
> Fetch the complete documentation index at: https://docs.remind.tools/llms.txt
> Use this file to discover all available pages before exploring further.

# 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:**
   ```bash theme={null}
   /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:**
   ```bash theme={null}
   /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:**
   ```bash theme={null}
   /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:**
   ```bash theme={null}
   /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.