SuperClaude/.claude/commands/load.md

/load - Load and analyze project context

Legend

Symbol	Meaning		Abbrev	Meaning
→	leads to		cfg	configuration
&	and/with		impl	implementation
w/	with		perf	performance
@	at/located		ops	operations
>	greater than		val	validation
∀	for all/every		req	requirements
∃	exists/there is		deps	dependencies
∴	therefore		env	environment
∵	because		db	database
≡	equivalent		api	interface
≈	approximately		docs	documentation
📁	directory/path		std	standard
🔢	number/count		def	default
📝	text/string		ctx	context
⚙	setting/config		err	error
🎛	control/flags		exec	execution
🔧	configuration		qual	quality
📋	group/category		rec	recovery
🚨	critical/urgent		sev	severity
⚠	warning/caution		resp	response
🔄	retry/recovery		esc	escalation
✅	success/fixed		tok	token
❌	failure/error		opt	optimization
ℹ	information		UX	user experience
⚡	fast/quick		UI	user interface
🐌	slow/delayed		C	critical
✨	complete/done		H	high
📖	read operation		M	medium
✏	edit operation		L	low
🗑	delete operation

Purpose

Load and analyze project context in $ARGUMENTS to build comprehensive understanding of codebase structure, architecture, and patterns.

Syntax

/load [flags] [path]

Universal Flags

--plan: "Show execution plan before running" --uc: "UltraCompressed mode (~70% token reduction)" --ultracompressed: "Alias for --uc" --think: "Multi-file analysis w/ context (4K tokens)" --think-hard: "Deep architectural analysis (10K tokens)" --ultrathink: "Critical system redesign (32K tokens)" --c7: "Enable Context7→library documentation lookup" --seq: "Enable Sequential→complex analysis & thinking" --magic: "Enable Magic→UI component generation" --pup: "Enable Puppeteer→browser automation & testing" --all-mcp: "Enable all MCP servers" --no-mcp: "Disable all MCP servers (native tools only)" --no-c7: "Disable Context7 specifically" --no-seq: "Disable Sequential thinking specifically" --no-magic: "Disable Magic UI builder specifically" --no-pup: "Disable Puppeteer specifically"

Command-Specific Flags

Analysis Depth:

• --depth shallow: Quick overview of project structure and purpose
• --depth normal: Standard analysis of main files and architecture (default)
• --depth deep: Comprehensive analysis of entire codebase

Analysis Focus:

• --architecture: Focus on system design and component relationships
• --dependencies: Analyze dependency graph and package relationships
• --security: Include security considerations and potential issues
• --performance: Identify performance patterns and potential bottlenecks
• --testing: Analyze testing approach and coverage patterns

Output Control:

• --summary: Generate concise project overview
• --detailed: Include comprehensive analysis details
• --recommendations: Provide actionable next steps and improvements

Examples

• /load --depth shallow → Quick project overview
• /load --depth deep --architecture → Comprehensive architectural analysis
• /load --dependencies --security → Focus on deps and security
• /load --performance --testing --detailed → Performance and testing analysis
• /load --summary --recommendations → Overview with actionable insights

Loading Process

1. Project Structure Scan:

• Directory layout and organization
• File types and distribution
• Module boundaries and hierarchies
• Entry points and main components

2. Configuration Analysis:

• Package manifests (package.json, requirements.txt, go.mod)
• Build configurations (webpack, vite, rollup)
• Environment and deployment configs
• CI/CD pipeline definitions

3. Code Architecture Review:

• Design patterns and architectural style
• Component relationships and dependencies
• Data flow and state management
• API structure and endpoints

4. Development Environment:

• Git repository status and history
• Development workflow patterns
• Testing framework and approach
• Documentation quality and coverage

5. Technology Stack Identification:

• Frontend and backend technologies
• Database and data storage solutions
• Third-party integrations and services
• Development and deployment tools

Analysis Depth Levels

Shallow Depth:

• Project purpose and business goals
• Primary technologies and frameworks
• High-level architecture overview
• Key dependencies and integrations
• Quick start and setup information
• Development team structure clues

Normal Depth:

• Detailed file and directory structure
• Main components and their responsibilities
• API endpoints, routes, and data models
• Database schema and relationships
• Testing strategy and coverage areas
• Development workflow and best practices

Deep Depth:

• Complete codebase analysis and mapping
• Detailed component interaction diagrams
• Comprehensive dependency relationships
• Performance characteristics and bottlenecks
• Security considerations and vulnerabilities
• Technical debt assessment
• Optimization opportunities and recommendations

Essential Files Analysis

Documentation:

• README.md (project overview and setup)
• CONTRIBUTING.md (development guidelines)
• API documentation and specs
• Architecture decision records (ADRs)

Configuration:

• Package managers (package.json, yarn.lock, requirements.txt)
• Build tools (webpack.config.js, vite.config.ts)
• Environment configs (.env files, docker-compose.yml)
• CI/CD pipelines (.github/workflows, .gitlab-ci.yml)

Source Code:

• Entry points (main.js, app.py, index.html)
• Core modules and components
• Shared utilities and libraries
• Test files and test configurations

Version Control:

• Git history and commit patterns
• Branch strategy and naming conventions
• Recent changes and active development areas
• Contributor patterns and team structure

Mental Model Construction

System Understanding:

• Component interaction patterns
• Data flow through the application
• External service integrations
• Deployment and infrastructure architecture
• User journey and experience flows

Development Insights:

• Code quality and consistency patterns
• Testing maturity and coverage
• Documentation completeness
• Development velocity indicators
• Technical debt and maintenance needs

Deliverables

• Project Overview: Comprehensive understanding summary
• Architecture Map: System design and component relationships
• Technology Inventory: Complete stack and dependency analysis
• Development Guide: Quick reference for project navigation
• Recommendations: Next steps and improvement opportunities
• Risk Assessment: Potential issues and technical debt areas

Output Locations

• Analysis Reports: .claudedocs/summaries/project-analysis-{timestamp}.md
• Architecture Docs: .claudedocs/summaries/architecture-overview-{timestamp}.md
• Quick Reference: .claudedocs/summaries/project-guide-{timestamp}.md

Research Requirements

External_Library_Research:

• Identify library/framework mentioned
• Context7 lookup for official documentation
• Verify API patterns and examples
• Check version compatibility
• Document findings in implementation Pattern_Research:
• Search existing codebase for similar patterns
• Magic component search if UI-related
• WebSearch for official documentation
• Validate approach with Sequential thinking
• Document pattern choice rationale API_Integration_Research:
• Official documentation lookup
• Authentication requirements
• Rate limiting and error handling
• SDK availability and examples
• Integration testing approach

Report Notifications

📄 Analysis report saved to: {path} 📊 Metrics updated: {path} 📋 Summary saved to: {path} 💾 Checkpoint created: {path} 📚 Documentation created: {path} 📁 Created directory: {path} ✅ {operation} completed successfully ❌ {operation} failed: {reason} ⚠ {operation} completed w/ warnings

Integration Patterns

Workflow Integration:

• Load project context before major development work
• Refresh understanding after significant changes
• Share context with team members and new contributors
• Use as foundation for architecture decisions

Command Chaining:

• load → analyze --architecture for design review
• load → scan --security for security assessment
• load → improve --quality for refactoring planning
• load → document --architecture for documentation

Troubleshooting

• Large Codebases: Use --depth shallow for initial overview
• Complex Architecture: Combine --architecture --detailed for comprehensive analysis
• Performance Issues: Include --performance flag for optimization insights
• Security Concerns: Add --security flag for vulnerability assessment

Success Messages

✅ {operation} completed successfully 📝 Created: {file_path} ✏ Updated: {file_path} ✨ Task completed: {task_title}