Skip to content
Skills Library
Programming · Analysis

code-analysis

/code-analysis

Use when analyzing unfamiliar code modules, understanding system architecture, or preparing for refactoring

Repository
skill-lib ↗
Licence
MIT
Last repository change
29.05.2026

Assessment and security

100/ 100Class: good
Format25 / 25
Frontmatter with name and description, valid name, description up to 1,024 characters, name matching the folder.
Discoverability25 / 25
Description explains when to use the skill, has a reasonable length and uses third person.
Content35 / 35
At least 150 words and at most 500 lines, headings, step lists, examples or code.
Hygiene15 / 15
No placeholders such as TODO, no Windows paths, with a licence.
Riskno signals detected in the scan
Files in this package
2
Scripts
1
HTML comments
0
URLs in SKILL.md
0
Deprecation

No signals detected. Repository changed on 29.05.2026, without references to retired models or APIs.

Licence

MIT, open: use and modify while retaining author attribution.

What to check before installing
  • 1 scripts in this package. Review them before installing, as Claude may execute them.

Scripts: attention_focus.py

What it does and when to use it

Use when analyzing unfamiliar code modules, understanding system architecture, or preparing for refactoring

Original author description

Use when analyzing unfamiliar code modules, understanding system architecture, or preparing for refactoring

How it works

  1. Overview
  2. When to Use
  3. Attention-Driven Code Analysis (NEW in v1.2)
  4. Workflow Template
  5. Execution Flow
  6. Usage Examples
  7. Important Rules
  8. Best Practices
  9. Integration with Other Skills
  10. Template Quick Reference
Original SKILL.md headings · 363 lines, 1,362 words
SKILL.md preview
---
name: code-analysis
description: Use when analyzing unfamiliar code modules, understanding system architecture, or preparing for refactoring
version: 1.2
---

# Code Analysis Skill

## Overview

Standardized workflow for reading, analyzing, and documenting codebases with attention-driven focus.

## When to Use

Use this skill when you need to:
- Understand a new code module or system
- Analyze architecture and design patterns
- Document technical implementation details
- Prepare for code refactoring or integration
- Create technical documentation for teams
- **Focus on core components** (high-attention code analysis)

---

## Attention-Driven Code Analysis (NEW in v1.2)

Identify core components in code using heuristic rules, optimizing analysis focus.

### Attention Scoring System

```python
# Use the attention_focus.py module
from attention_focus import CodeAttentionScorer

scorer = CodeAttentionScorer()
components = scorer.analyze_code_structure(file_content, file_name)
focus = scorer.get_analysis_focus(components)
```

### Scoring Criteria

| Factor | Weight | Description |
|--------|--------|-------------|
| **Core Keywords** | +3 | Manager, Controller, Handler, System, Core |
| **Important Keywords** | +2 | Helper, Util, Factory, Provider |
| **Lines of Code** | +2 (>100 lines) / +1 (50-100 lines) | Scale metric |
| **Reference Count** | +2 (>5 refs) / +1 (2-5 refs) | Dependency metric |
| **Complexity** | +1 | Methods>10 or Conditional statements>5 |

### Attention Levels

| Level | Score | Analysis Depth |
|-------|-------|----------------|
| **High** | 8-10 | Detailed analysis + Full code + Design principles |
| **Medium** | 5-7 | Focused analysis + Key code snippets |
| **Low** | 0-4 | Brief mention + Function description |

### Workflow with Attention Focus

```
1. Read code file
       ↓
2. Run attention_focus.py analysis
       ↓
3. Get prioritized component list
       ↓
4. Analyze HIGH attention components in detail
5. Analyze MEDIUM attention components briefly
6. Reference LOW attention components as needed
       ↓
7. Generate focused documentation
```

### Benefits

- **Reduce token consumption**: Focus on 20% core code that provides 80% value
- **Faster analysis**: Skip boilerplate and utility code
- **Better documentation**: Highlight architectural decisions and critical paths
- **Estimated improvement**: 20-30% token reduction, 30% faster analysis

## Workflow Template

Every code analysis task MUST follow this 4-step structure:

### 1. Objective

**Definition**: Clear statement of what needs to be understood

**Format**:
```
Objective: [What specifically needs to be understood]
Scope: [Boundaries of the analysis]
Depth: [Overview/Core logic/Detailed implementation]
```

**Examples**:
- Understand how the Tinker serialization library works
- Analyze the architecture design of PlayerSubsystem
- Master the SharedTable data table loading mechanism

### 2. Deliverables

**Definition**: Concrete outputs that will be produced

**Format**:
```
Documentation:
- [Doc name 1] - [Path] - [Content description]
- [Doc name 2] - [Path] - [Content description]

Additional outputs:
- [Code examples/Flowcharts/Architecture diagrams]
```

**Documentation Standards**:
- Place in `repository/projects/[Project]/docs/` or `docs/`
- Use descriptive filenames: `[Topic]-[Type].md`
- Include code snippets and diagrams

### 3. Content

**Definition**: What will be covered in the analysis

**Format**:
```
Analysis content:
1. [Module A] - [Point 1, Point 2, Point 3]
2. [Module B] - [Point 1, Point 2, Point 3]
3. [Inter-module relationships] - [Interaction flow]

Include elements:
□ Core class/interface design
□ Data flow/Control flow
□ Key algorithms/Logic
□ Design patterns
□ Dependencies
```

### 4. Token Estimation

**Definition**: Estimated token consumption for the analysis

**Format**:
```
Token estimation:
- Code reading: ~[X,000] tokens
- Documentation: ~[X,000] tokens
- Total: ~[X,000]-[Y,000] tokens
- Estimated time: [X]-[Y] minutes
```

**Estimation Guidelines**:
| Complexity | Code reading | Documentation | Total | Time |
|--------|----------|----------|------|------|
| Simple (1-2 files) | 3K-5K | 2K-3K | 5K-8K | 15-20min |
| Medium (module-level) | 10K-20K | 5K-10K | 15K-30K | 30-50min |
| Complex (system-level) | 30K-50K | 15K-25K | 45K-75K | 60-90min |

## Execution Flow

```
1. User Request
       │
       ▼
2. Clarify Requirements (if needed)
       │
       ├── Confirm analysis scope boundaries
       ├── Confirm key class definition locations (file paths)
       └── ⚠️ If definition locations are unclear, must ask the requester to explicitly specify
       │
       ▼
3. Output Analysis Plan (4-step structure)
       │
       ├── 1. Objective
       ├── 2. Deliverables  
       ├── 3. Content
       └── 4. Token Estimation
       │
       ▼
4. Wait for "Plan Approval" Confirmation
       │
       ▼
5. Execute Analysis
       │
       ├── Read relevant code
       ├── Understand logic
       └── Extract key points
       │
       ▼
6. Produce Documentation
       │
       ├── Write technical doc
       ├── Include code examples
       └── Create diagrams if needed
       │
       ▼
7. Report Completion
       └── Summary of findings
```

## Usage Examples

### Example 1: Simple Module Analysis

**User**: "Analyze PlayerQuest's progress update mechanism"

**Plan Output**:
```
## Code Analysis Plan

### 1. Objective
Understand PlayerQuest's progress update mechanism, including:
- How progress is stored and updated
- Task completion determination logic
- Interaction with the medal system

### 2. Deliverables
- `PlayerQuest-Progress-Analysis.md` 
  - Path: `repository/projects/BattleCore/docs/`
  - Contains: Flowchart + Core code + Data flow

### 3. Content
1. PlayerQuest class structure
2. updateProgress() / accumulateProgress() implementation
3. Task completion determination logic
4. Coupling relationship with PlayerMedal

### 4. Token Estimation
- Code reading: ~5,000 tokens
- Documentation: ~3,000 tokens
- Total: ~8,000 tokens
- Estimated time: 15-20 minutes
```

### Example 2: Complex System Analysis

**User**: "Understand the overall skill system architecture"

**Plan Output**:
```
## Code Analysis Plan

### 1. Objective
Fully understand the FAbility skill system architecture:
- Core class hierarchy
- State machine implementation
- Skill lifecycle
- Integration with the battle core

### 2. Deliverables
- `FAbility-Architecture.md`
  - Path: `repository/projects/BattleCore/docs/`
  - Contains: Architecture diagram + Class diagram + Real-world examples
- `Skill-Lifecycle-Flow.md`
  - Complete skill lifecycle flow

### 3. Content
1. FAbility base class design
2. State machine (EAbilityState)
3. Concrete skill implementation examples
4. CD/Cost system
5. Event system

### 4. Token Estimation
- Code reading: ~30,000 tokens
- Documentation: ~15,000 tokens
- Total: ~45,000 tokens
- Estimated time: 60-80 minutes
```

## Important Rules

### Definition Location Confirmation Rule (Critical)

**Rule**: When definition locations are unclear during code analysis, must ask the requester to explicitly specify the location in advance

**Execution Steps**:
1. After receiving an analysis request, first attempt to locate the definition files of key classes/functions
2. If the location cannot be determined through file name or class name search, **immediately stop analysis**
3. Ask the requester: **"Please provide the definition file path for [ClassName]"**
4. After receiving a clear path, continue analysis

**Example**:
```
❌ Incorrect approach:
User: "Analyze NetMessage implementation"
AI: (Blindly search, can't find correct location, analyze based on assumptions)

✅ Correct approach:
User: "Analyze NetMessage implementation"
AI: "Please provide the definition file path for NetMessage,
       Search found possible locations:
       - Server/Network/NetMessage.h
       - Server/Common/NetMessage.h
       Please confirm which file?"
User: "In Server/Network/NetMessage.h"
AI: (Start analysis based on explicit path)
```

---

## Best Practices

### Do's
✅ Define clear scope boundaries, avoid over-analysis
✅ Provide specific file paths and line numbers
✅ Include actual code snippets
✅ Use diagrams to aid understanding (text descriptions)
✅ Estimates should be conservative, leave buffer

### Don'ts
❌ Don't use vague scopes ("analyze the entire project")
❌ Don't omit key deliverable information
❌ Don't underestimate token consumption for complex systems
❌ Don't mix multiple unrelated objectives
❌ Don't blindly guess when definition locations are unclear (**must ask the requester to explicitly specify file paths**)

## Integration with Other Skills

- **knowledge-base-cache**: Store analysis results in knowledge base
- **git-workflow**: Commit analysis documents
- **skill-creator**: Create specialized analysis skills from patterns

## Template Quick Reference

```markdown
## Code Analysis Plan

### 1. Objective
[Specific objective description]
Scope: [Scope boundaries]
Depth: [Overview/Core/Detailed]

### 2. Deliverables
- [Doc name] - [Path] - [Description]

### 3. Content
1. [Module A] - [Key points]
2. [Module B] - [Key points]
3. [Relationships] - [Flow]

### 4. Token Estimation
- Code reading: ~[X,000] tokens
- Documentation: ~[X,000] tokens
- Total: ~[X,000]-[Y,000] tokens
- Estimated time: [X]-[Y] minutes
```

## Version History

- **v1.2** (2026-02-12) - Added Attention-Driven Analysis
  - Added: attention_focus.py module
  - Added: Heuristic code attention scoring
  - Added: Three-level analysis depth (High/Medium/Low)
  - Optimized: 20-30% token reduction
  - Optimized: 30% faster analysis speed

- v1.1 (2026-02-10) - Added critical rule
  - Added: Definition location confirmation rule
  - Added: Important Rules section
  - Updated: Execution Flow added path confirmation step
  - Updated: Best Practices added Don'ts rules

- v1.0 (2026-02-10) - Initial release
  - 4-step workflow structure
  - Token estimation guidelines
  - Usage examples and templates
Files in this package (2)
  • SKILL.md 10 KB
  • attention_focus.py 10 KB

Versions

RepositoryScoreLicence
This page · Dqz00116/skill-lib100MIT
OKHP3/skillz100MIT
managedcode/dotnet-skills100MIT
alexandrbasis/claudops100MIT
alexandrbasis/claudops100MIT
abbaye/wpfhexeditoride85AGPL-3.0

Database snapshot: 13.11.2026 · package version 38f2433117ec (SHA-256 digest of the entire package)

Downloads in the last 30 days: 0 · ranking

Report a problem with this skill: harmful content, incorrect descriptions or an author’s removal request.

Similar skills

  • 100codebase-analysis
    Patterns and techniques for analyzing brownfield codebases. Use when onboarding to unfamiliar code, preparing for refactoring, conducting architecture reviews, or identifying technical debt.
  • 100fusecore
    Use when creating modules, understanding FuseCore structure, or implementing features in a FuseCore modular-monolith Laravel project.
  • 100lsp-enable
    Use when navigating code, understanding unfamiliar functions, finding definitions or references, tracing call hierarchies, preparing for refactoring, or analyzing code impact. Enforces LSP-first semantic code intelligence with mandatory pre-edit checks, impact analysis before…
  • 86codebase-understanding
    Map an unfamiliar repository into source-linked components, symbols, dependencies and an onboarding tour, or update an existing architecture map after changes. Use for understanding code structure; runtime validation and implementation belong to their own workflows.
  • 90codebase-recon
    Understand an unfamiliar repository before making changes. Use when the task touches code whose architecture, conventions, or test setup are not already clear.
  • 100explore
    Multi-angle codebase exploration by parallel agents: structure, data flow, architecture, health. Use to map an unfamiliar repo. NOT for task research files (use create-research).

Feedback and reports

Your message goes to Bartosz Sokoliński. An email address is needed only for a reply. See the privacy policy.