Our review

Deep code investigation to debug issues, analyze patterns, and trace data flow across the codebase.

Strengths

Systematic multi-step investigation (hypothesis, evidence, synthesis) for complex bugs.
Generates structured reports with evidence and actionable recommendations.
Leverages command-line tools (grep, git, logging) for thorough analysis.

Limitations

Requires Bash/Grep access, limiting use in non-CLI environments.
Output quality depends on user-provided arguments—vague input leads to vague analysis.
May be slow on very large projects without indexing.

When to use it

When you need to systematically debug a non-trivial issue, understand code patterns, or map out architecture.

When not to use it

For trivial questions or one-line fixes that don't warrant an in-depth investigation.

Examples

Debug login failure

/analyse The login form fails silently with no error message. Check the authentication flow and recent changes.

Analyze API call pattern

/analyse Identify all places where we make external API calls and trace the data flow from request to response.

Investigate performance regression

/analyse The home page loads 2x slower than last week. Investigate recent commits and find the bottleneck.

name: analyse description: Investigate codebase, debug issues, or analyze patterns argument-hint: <issue or area to investigate> user-invocable: true allowed-tools:

Read
Grep
Glob
Bash
WebSearch

/analyse - Code Investigation

Investigate codebase issues, debug problems, or analyze patterns.

Purpose

Provide deep analysis by:

Investigating bugs and issues
Analyzing code patterns
Tracing data flow
Identifying root causes

Inputs

$ARGUMENTS: Issue description or area to investigate
${PROJECT_NAME}: Current project context
Error messages or symptoms if debugging

Outputs

Analysis report at reports/analysis/YYYY-MM-DD-topic.md

Workflow

1. Understand the Question

From $ARGUMENTS:

Is this debugging an issue?
Is this understanding a pattern?
Is this exploring code structure?

2. Gather Context

Read relevant code
Search for patterns
Check logs if available
Review recent changes

3. Form Hypotheses

Based on initial investigation:

What might cause this?
What patterns are involved?
What dependencies matter?

4. Investigate

For each hypothesis:

Search for evidence
Trace code paths
Check data flow
Test assumptions

5. Analyze Findings

Synthesize discoveries:

What is the root cause?
What patterns were found?
What are the implications?

6. Document

Create analysis report:

# Analysis: [Topic]

**Date**: YYYY-MM-DD
**Scope**: [What was investigated]
**Conclusion**: [Key finding]

---

## Context
[What prompted this investigation]

## Investigation

### Approach
[How the investigation was conducted]

### Findings

#### Finding 1: [Title]
[Description of finding]

**Evidence**:
- [File:line - what was found]
- [Pattern observed]

#### Finding 2: [Title]
[Description]

## Root Cause
[If applicable, the underlying issue]

## Impact
[What this affects]

## Recommendations
1. [Recommendation 1]
2. [Recommendation 2]

## Related
- [Links to related code]
- [Links to docs]

Investigation Patterns

Bug Investigation

Reproduce the issue
Identify symptoms
Trace to source
Identify root cause
Propose fix

Pattern Analysis

Identify pattern instances
Analyze commonalities
Note variations
Document implications

Code Structure Analysis

Map components
Trace dependencies
Identify boundaries
Document architecture

Performance Analysis

Identify slow operations
Profile if possible
Analyze bottlenecks
Propose optimizations

Tools for Investigation

# Search for patterns
grep -r "pattern" src/

# Find file types
find . -name "*.ts" -type f

# Git history
git log --oneline --all -- file.ts
git blame file.ts

# Test in isolation
npm test -- --grep "specific test"

Code Analysis

Recommended for