My ClaudeCode custom commands

brainstorm.md

description
Critical analysis of problems with root cause identification before proposing solutions

Brainstorm - Problem Analysis & Solution Design

Thoroughly analyze the current problem before proposing any solutions. Focus on identifying root causes and asking clarifying questions.

Phase 1: Critical Analysis

Before proposing solutions, systematically examine:

1. Root Cause Identification

   • What is the actual problem vs. symptoms?
   • Is this a bug, architecture issue, performance problem, or implementation challenge?
   • What are the contributing factors?

2. Codebase Context

   • Review relevant code sections
   • Identify existing patterns and conventions
   • Note any related issues or dependencies

3. Clarifying Questions Ask the user about:

   • Requirements: What must the solution accomplish?
   • Constraints: Technical limitations, deadlines, resources?
   • Priorities: Performance vs. maintainability vs. speed of implementation?
   • Scope: Does this need to solve related problems too?

STOP HERE - Wait for user's answers before proceeding to solutions.

Phase 2: Solution (After User Responds)

After receiving clarification, provide:

1. Recommended Solution

   • Specific, actionable approach
   • Clear implementation steps
   • Code examples if relevant

2. Reasoning

   • Why this solution is optimal
   • How it addresses root causes
   • Tradeoffs considered

3. Alternative Approaches

   • Briefly mention other viable options
   • Explain why the recommended solution is better

Output Style

• Be thorough but concise
• Focus on root causes, not just symptoms
• Always ask questions before jumping to solutions

delegate.md

description
Smart task execution using best-fit subagents

Delegate - Smart Task Execution

Execute the given task (or current ToDo list if none specified) using the most appropriate subagent(s).

Behavior

• If arguments provided: Execute that specific task
• If no arguments: Execute pending items from current ToDo list
• Always: Select best-fit subagent(s) and parallelize when possible

Agent Selection

• csharp-developer: C#/.NET code
• python-pro: Python code
• sql-pro: Database/SQL
• agent-organizer: Complex multi-step orchestration
• Explore: Codebase research, finding files
• general-purpose: Everything else

Rules

• Never test unless explicitly asked
• Only make requested changes
• Mark ToDo items complete as finished

$ARGUMENTS

discovery.md

description
Interactive project planning with comprehensive discovery questions

Project Planning & Discovery

Lead the user through thorough project discovery before any implementation. Ask questions ONE section at a time and wait for their response before proceeding.

Discovery Process

1. Business Requirements

• What problem does this solve and for whom?
• What are your success metrics?
• Timeline and resource constraints?

2. Technical Scale & Performance

• Expected users, traffic, data volume?
• Performance requirements?
• Must integrate with existing systems?

3. Security & Compliance

• What sensitive data will you handle?
• Regulatory requirements (GDPR, HIPAA, etc.)?
• Authentication/authorization approach?

4. Technology Stack

• Language/framework preferences?
• Hosting preferences (AWS, Azure, self-hosted)?
• Database requirements?

5. Development & Operations

• Team size and experience level?
• CI/CD and testing strategy?
• Monitoring requirements?

After Gathering Requirements

Provide:

1. Recommended Tech Stack - justified choices
2. Architecture Diagram - mermaid format
3. Security Checklist - specific to their needs
4. Project Structure - initial file/folder layout
5. Implementation Roadmap - phased milestones
6. Risk Assessment - potential issues and solutions

Challenge assumptions. Suggest best practices. Prioritize security from day one.

iterate.md

Iterate Command

Steps:

1. Write the code - Implement the requested changes
2. Test - Test the newly written code and analyze results
3. Report - Provide a clear summary of what was changed and test outcomes

Continue iterating (fix → deploy → test) until all tests pass, then report final results.

plan.md

description
Create detailed to-do list broken into smallest logical steps following best practices

Plan - Detailed Task Breakdown

Create a comprehensive to-do list using Claude Code's To Do feature. Break down the work into the smallest logical steps that follow coding best practices and preserve existing functionality.

Instructions

1. Analyze Current State

   • Review existing codebase and functionality
   • Identify what needs to be built/modified
   • Note any dependencies or constraints

2. Create Task List

   • Break down into smallest logical steps
   • Order tasks by best practices (e.g., data layer → business logic → UI)
   • Number tasks hierarchically (1.1, 1.2, 2.1, etc.)
   • Ensure each step is testable

3. Add to Claude Code To Do

   • Use proper task format
   • Include acceptance criteria for each task
   • Mark dependencies between tasks

Important Rules

• Testing: User handles all testing unless explicitly told otherwise - you only write code
• Git: Never push to GitHub until user explicitly approves
• Existing Functionality: Ensure no breaking changes
• Order: Tasks must be completed sequentially

Output Format

Present the plan clearly, then add it to the To Do feature for tracking.

pushy.md

description
Push recent changes to git with detailed documentation and suggest next steps

Pushy - Git Push with Documentation

Push recent changes to git repository with comprehensive documentation, then recommend what to work on next.

Instructions

1. Review Changes

   • Run git status to see modified files
   • Run git diff to review actual changes
   • Summarize what was accomplished

2. Commit with Documentation

   • Stage all changes: git add -A
   • Write detailed commit message following conventions:
     • Use conventional commit format (feat:, fix:, docs:, etc.)
     • Include clear description of changes
     • Note any breaking changes or important details

3. Push to Remote

   • Push to current branch: git push
   • Confirm push was successful

4. Suggest Next Steps

   • Based on project status and recent changes
   • Reference any to-do list or project scope
   • Prioritize logically

Output

After successful push, provide clear recommendations for what to tackle next.

scope.md

description
Create comprehensive project scope document that doubles as a development checklist

Scope - Project Scope & Checklist

Create a detailed project scope document in markdown format that serves as both comprehensive documentation and a step-by-step development checklist.

Instructions

1. Initial Planning

   • First run /plan to create detailed to-do list in Claude Code To Do feature
   • Use that as foundation for the scope document

2. Create Scope Document

   • Document every aspect of the program
   • Structure in logical, chronological order
   • Break down into smallest logical tasks
   • Number hierarchically (1.1, 1.2, 2.1, etc.)

3. Development Order

   • Organize by best practices (data → logic → UI)
   • Each task should be independently testable
   • Mark dependencies clearly
   • Include acceptance criteria for each task

Document Structure

The scope should include:

• Overview: Project goals and requirements
• Architecture: High-level design decisions
• Development Phases: Organized chronologically
  • Phase 1: Foundation (data models, core logic)
  • Phase 2: Business Logic (services, APIs)
  • Phase 3: User Interface (UI components)
  • Phase 4: Integration & Testing
  • Phase 5: Deployment & Documentation
• Task Checklist: Numbered, sequential tasks

Workflow

This scope enables a simple workflow:

1. Complete task 1.1
2. User tests (if applicable)
3. Mark 1.1 as complete
4. Move to 1.2
5. Repeat until production-ready

Output

Create a comprehensive markdown file that serves as both detailed scope and actionable checklist.

search.md

description
Search codebase using ripgrep (rg) - Saves tokens vs reading files

Search Execution

I will search the codebase for the pattern: "$ARGUMENTS" !rg --max-columns 150 --max-count 20 --line-number --smart-case "$ARGUMENTS" .

start.md

description
Quick guidance on where to begin, with concise responses

Start - Where to Begin

Provide clear, concise guidance on the best starting point for the current project or task.

Instructions

1. Assess Current State

   • Check for existing project scope, to-do list, or documentation
   • Review current codebase state
   • Identify what's been completed vs. what's pending

2. Recommend Starting Point

   • Suggest the most logical next task
   • Explain why this is the optimal starting point
   • Keep explanation brief but complete

3. Communication Style

   • Keep all responses in this conversation as short as possible
   • Do not sacrifice quality for brevity
   • Be direct and actionable

Output

Provide a clear, concise answer about where to start and why.