/discover-context - Intelligent Code Analysis & Pattern Discovery

Purpose

The /discover-context prompt performs deep analysis of existing codebases to understand patterns, extract knowledge, and document discoveries. It's essential for working with unfamiliar code, documenting legacy systems, or understanding project architecture.

Use Cases

Legacy Code Understanding: Analyze and document existing systems
Onboarding Acceleration: Help new team members understand codebases
Pattern Extraction: Identify recurring patterns and conventions
Architecture Documentation: Map system structure and relationships
Technical Debt Assessment: Find improvement opportunities

Argument Structure

/discover-context [path] [focus-area] [--options]

Arguments

path (optional)
- Directory or file to analyze
- Defaults to current directory
- Can be specific: "./src/auth"
focus-area (optional)
- Specific aspect to analyze
- Examples: "patterns", "architecture", "dependencies"
- Defaults to comprehensive analysis
options (optional)
- --depth: Analysis depth (quick, standard, comprehensive)
- --output: Output location for findings
- --ignore: Patterns to exclude

Examples

bash

# Analyze entire project
/discover-context

# Focus on specific module
/discover-context ./src/billing

# Pattern-focused analysis
/discover-context ./src "patterns" --depth=comprehensive

# Quick architecture overview
/discover-context . "architecture" --depth=quick

Adaptation Strategies

Multi-Layer Analysis

The prompt examines:

Code Structure
- Directory organization
- Module boundaries
- Naming conventions
- File patterns
Architecture Patterns
- Design patterns used
- Service communication
- Data flow
- Dependency structure
Code Patterns
- Common idioms
- Error handling
- State management
- API patterns
Quality Indicators
- Test coverage
- Documentation
- Code complexity
- Technical debt

Intelligent Recognition

Identifies:

Framework conventions
Custom patterns
Anti-patterns
Improvement opportunities
Hidden dependencies

Knowledge Extraction

Captures:

Business logic
Domain concepts
Integration points
Configuration patterns
Deployment context

Memory Usage

Discovery Documentation

.orchestre/
├── discovery/
│   ├── context/
│   │   ├── overview.md           # Project overview
│   │   ├── architecture.md       # System architecture
│   │   ├── patterns.md           # Identified patterns
│   │   └── conventions.md        # Coding conventions
│   ├── modules/
│   │   ├── auth/                 # Module-specific findings
│   │   │   ├── analysis.md
│   │   │   └── patterns.md
│   │   └── billing/
│   │       ├── analysis.md
│   │       └── flows.md
│   └── insights/
│       ├── improvements.md       # Suggested improvements
│       ├── risks.md             # Identified risks
│       └── opportunities.md     # Enhancement opportunities

Discovery Report Example

markdown

# Project Discovery: E-Commerce Platform

## Executive Summary
- **Type**: Monolithic Node.js application
- **Age**: ~3 years (based on git history)
- **Size**: 45,000 LOC
- **Tech Stack**: Express, PostgreSQL, React, Redis
- **Architecture**: MVC with service layer

## Architecture Overview

### High-Level Structure

src/ ├── controllers/ # HTTP request handlers ├── services/ # Business logic layer ├── models/ # Database models (Sequelize) ├── utils/ # Shared utilities ├── middleware/ # Express middleware └── config/ # Configuration management


### Key Patterns Identified

#### 1. Service Layer Pattern
All business logic isolated in service classes:
```javascript
// Pattern found in 23 files
class UserService {
  async createUser(data) {
    // Validation
    const validated = await this.validate(data);
    
    // Business logic
    const user = await User.create(validated);
    
    // Side effects
    await EmailService.sendWelcome(user);
    
    return user;
  }
}

2. Error Handling Pattern

Consistent error handling across services:

javascript

// Found in all service methods
try {
  // Operation
} catch (error) {
  logger.error('Operation failed', { error, context });
  throw new AppError(error.message, error.code);
}

3. Repository Pattern (Partial)

Some modules use repository pattern:

javascript

// Found in newer modules (billing, subscriptions)
class OrderRepository {
  async findByUser(userId, options = {}) {
    return Order.findAll({
      where: { userId },
      ...options
    });
  }
}

Domain Understanding

Core Business Entities

Users: Multi-role system (customer, vendor, admin)
Products: Complex categorization, variants
Orders: State machine for order lifecycle
Payments: Stripe integration with webhooks

Business Flows

Order Flow: Cart → Checkout → Payment → Fulfillment → Delivery
Vendor Flow: Registration → Verification → Product Management → Order Processing

Technical Insights

Strengths

Consistent service layer architecture
Good separation of concerns
Comprehensive error handling
Well-structured API routes

Improvement Opportunities

Inconsistent Patterns: Mix of repository and direct model access
Test Coverage: Only 42% coverage, mainly happy paths
Type Safety: No TypeScript, prone to runtime errors
Performance: N+1 queries in product listings

Technical Debt

Outdated dependencies (Express 4.16)
Mixed async patterns (callbacks and promises)
Hardcoded configuration values
Incomplete migration to repositories

Recommendations

Immediate Actions

Update critical dependencies
Add TypeScript for type safety
Complete repository pattern migration
Implement query optimization

Long-term Improvements

Consider microservices for scaling
Implement event-driven architecture
Add comprehensive monitoring
Improve test coverage to 80%+

Hidden Gems

Sophisticated caching strategy in product service
Well-designed plugin system in checkout flow
Elegant state machine for order management


## Workflow Examples

### Legacy System Analysis
```bash
# 1. Deep discovery
/discover-context . --depth=comprehensive

# 2. Focus on problem areas
/discover-context ./src/legacy "technical-debt"

# 3. Document findings
/document-feature "Legacy System Architecture"

# 4. Plan modernization
/orchestrate "Modernize legacy components based on discovery"

New Team Member Onboarding

bash

# 1. Project overview
/discover-context . "architecture" --depth=quick

# 2. Key modules
/discover-context ./src/core "patterns"

# 3. Create guide
/document-feature "Developer Onboarding Guide"

# 4. Identify starter tasks
/discover-context . "good-first-issues"

Pre-Refactoring Analysis

bash

# 1. Understand current state
/discover-context ./src/auth

# 2. Identify patterns
/discover-context ./src/auth "patterns" --depth=comprehensive

# 3. Find dependencies
/discover-context . "dependencies:auth"

# 4. Plan refactoring
/execute-task "Refactor auth module based on discovery"

Analysis Categories

1. Architecture Discovery

bash

/discover-context . "architecture"

Reveals:

System boundaries
Service relationships
Data flow patterns
Integration points
Deployment structure

2. Pattern Recognition

bash

/discover-context . "patterns"

Identifies:

Design patterns
Coding conventions
Common utilities
Shared components
Recurring solutions

3. Dependency Analysis

bash

/discover-context . "dependencies"

Maps:

Module dependencies
External libraries
Service connections
Database relationships
API integrations

4. Quality Assessment

bash

/discover-context . "quality"

Evaluates:

Code complexity
Test coverage
Documentation quality
Performance patterns
Security practices

Intelligent Features

Pattern Learning

Recognizes framework patterns
Identifies custom conventions
Learns naming schemes
Understands file organization
Detects architectural styles

Relationship Mapping

Service dependencies
Database relationships
API call patterns
Event flows
State management

Knowledge Synthesis

Combines findings
Identifies contradictions
Suggests improvements
Highlights risks
Documents insights

Contextual Understanding

Business domain extraction
Use case identification
User flow mapping
Integration discovery
Configuration analysis

Discovery Depth Levels

Quick (15-30 minutes)

File structure overview
Main technology identification
Basic pattern recognition
High-level architecture
Key module listing

Standard (1-2 hours)

Detailed architecture analysis
Pattern documentation
Dependency mapping
Quality indicators
Improvement suggestions

Comprehensive (4+ hours)

Deep pattern analysis
Full dependency graph
Performance analysis
Security review
Complete documentation

Integration Points

With Other Prompts

→ /orchestrate: Use findings for planning
→ /execute-task: Implement improvements
→ /document-feature: Create documentation
→ /security-audit: Focus security review

With Development Flow

Before major changes
New developer onboarding
Architecture reviews
Technical debt planning
Documentation updates

Best Practices

Start Broad

bash

# Get overview first
/discover-context . --depth=quick

# Then dive deep
/discover-context ./src/critical-module --depth=comprehensive

Focus Analysis

bash

# Specific concerns
/discover-context ./src/api "security-patterns"

# Problem areas
/discover-context ./src/legacy "technical-debt"

Document Findings

bash

# After discovery
/discover-context ./src/billing

# Document insights
/document-feature "Billing System Architecture"

Advanced Discovery

Cross-Repository Analysis

bash

/discover-context "../{service1,service2,service3}" "integration-patterns"
# Analyzes patterns across multiple services

Historical Analysis

bash

/discover-context . "evolution" --git-history
# Understands how code evolved over time

Performance Profiling

bash

/discover-context ./src "performance-patterns" --profile
# Identifies performance bottlenecks and patterns

Tips

Regular Discovery: Run periodically to track changes
Before Big Changes: Always discover before refactoring
Share Findings: Discovery benefits whole team
Act on Insights: Use findings to improve code
Update Documentation: Keep discoveries current

/discover-context - Intelligent Code Analysis & Pattern Discovery ​

Purpose ​

Use Cases ​

Argument Structure ​

Arguments ​

Examples ​

Adaptation Strategies ​

Multi-Layer Analysis ​

Intelligent Recognition ​

Knowledge Extraction ​

Memory Usage ​

Discovery Documentation ​

Discovery Report Example ​

2. Error Handling Pattern ​

3. Repository Pattern (Partial) ​

Domain Understanding ​

Core Business Entities ​

Business Flows ​

Technical Insights ​

Strengths ​

Improvement Opportunities ​

Technical Debt ​

Recommendations ​

Immediate Actions ​

Long-term Improvements ​

Hidden Gems ​

New Team Member Onboarding ​

Pre-Refactoring Analysis ​

Analysis Categories ​

1. Architecture Discovery ​

2. Pattern Recognition ​

3. Dependency Analysis ​

4. Quality Assessment ​

Intelligent Features ​

Pattern Learning ​

Relationship Mapping ​

Knowledge Synthesis ​

Contextual Understanding ​

Discovery Depth Levels ​

Quick (15-30 minutes) ​

Standard (1-2 hours) ​

Comprehensive (4+ hours) ​

Integration Points ​

With Other Prompts ​

With Development Flow ​

Best Practices ​

Advanced Discovery ​

Cross-Repository Analysis ​

Historical Analysis ​

Performance Profiling ​

Tips ​

/discover-context - Intelligent Code Analysis & Pattern Discovery

Purpose

Use Cases

Argument Structure

Arguments

Examples

Adaptation Strategies

Multi-Layer Analysis

Intelligent Recognition

Knowledge Extraction

Memory Usage

Discovery Documentation

Discovery Report Example

2. Error Handling Pattern

3. Repository Pattern (Partial)

Domain Understanding

Core Business Entities

Business Flows

Technical Insights

Strengths

Improvement Opportunities

Technical Debt

Recommendations

Immediate Actions

Long-term Improvements

Hidden Gems

New Team Member Onboarding

Pre-Refactoring Analysis

Analysis Categories

1. Architecture Discovery

2. Pattern Recognition

3. Dependency Analysis

4. Quality Assessment

Intelligent Features

Pattern Learning

Relationship Mapping

Knowledge Synthesis

Contextual Understanding

Discovery Depth Levels

Quick (15-30 minutes)

Standard (1-2 hours)

Comprehensive (4+ hours)

Integration Points

With Other Prompts

With Development Flow

Best Practices

Advanced Discovery

Cross-Repository Analysis

Historical Analysis

Performance Profiling

Tips