Przejdź do treści
Biblioteka skilli
Programowanie · Analiza

code-analyzer

/code-analyzer

Analizuje bazę kodu, aby zbudować model mentalny struktury projektu, zależności i kontekstu implementacji: architektura, moduły współdzielone, ścieżki wykonania i znaczniki AICODE-*.

Repozytorium
mvp-builder ↗
Licencja
MIT
Ostatnia zmiana repozytorium
06.09.2026

Ocena i bezpieczeństwo

100/ 100Klasa: dobry
Format25 / 25
Frontmatter z nazwą i opisem, poprawna nazwa, opis do 1024 znaków, nazwa zgodna z folderem.
Odkrywalność25 / 25
Opis mówi, kiedy użyć skilla, ma sensowną długość i jest w 3. osobie.
Treść35 / 35
Co najmniej 150 słów i do 500 linii, nagłówki, listy kroków, przykłady albo kod.
Higiena15 / 15
Bez zaślepek typu TODO, bez ścieżek Windows, z licencją.
Ryzykobrak sygnałów w skanie
Pliki w paczce
2
Skrypty
1
Komentarze HTML
0
Adresy URL w SKILL.md
0
Przestarzałość

Brak sygnałów. Repozytorium zmienione 06.09.2026, bez odwołań do wycofanych modeli i API.

Licencja

MIT, otwarta: można używać i zmieniać, z zachowaniem informacji o autorze.

Co sprawdzić przed instalacją
  • 1 skrypt w paczce. Przejrzyj je przed instalacją, bo Claude może je uruchomić.

Skrypty: scripts/scan-codebase.sh

Co robi i kiedy

Analizuje bazę kodu, aby zbudować model mentalny struktury projektu, zależności i kontekstu implementacji: architektura, moduły współdzielone, ścieżki wykonania i znaczniki AICODE-*.

Oryginalny opis (EN)

Comprehensive codebase analysis for building mental model of project structure, dependencies, and implementation context. Use when needing to: (1) Understand project architecture before review or documentation, (2) Find dependencies and shared modules, (3) Trace execution paths and abstraction layers for similar features, (4) Locate implementation markers (AICODE-*), (5) Prepare context for review, memory generation, or agent creation. Triggers on: analyze code, load code context, scan codebase, understand project structure, trace feature.

Jak działa

  1. Workflow Overview
  2. Step 1: Scan Project
  3. Step 2: Understand Structure
  4. Step 3: Trace Patterns
  5. Step 4: Build Mental Model
  6. Step 5: Confirm Readiness
  7. Error Handling
  8. Usage Notes
Sekcje z nagłówków SKILL.md, w oryginale · 133 linii, 666 słów
Podgląd SKILL.md
---
name: code-analyzer
description: "Comprehensive codebase analysis for building mental model of project structure, dependencies, and implementation context. Use when needing to: (1) Understand project architecture before review or documentation, (2) Find dependencies and shared modules, (3) Trace execution paths and abstraction layers for similar features, (4) Locate implementation markers (AICODE-*), (5) Prepare context for review, memory generation, or agent creation. Triggers on: analyze code, load code context, scan codebase, understand project structure, trace feature."
---

# Code Analyzer

Analyze codebase to build comprehensive mental model for downstream operations.

## Workflow Overview

1. **Scan** — Collect facts via bash script (deterministic)
2. **Understand** — Interpret structure and stack
3. **Trace** — Follow execution paths through abstraction layers (skip if greenfield)
4. **Build** — Construct dependency graph and mental model
5. **Confirm** — Output summary with key files list

## Step 1: Scan Project

Run the codebase scanner to collect facts — `scripts/scan-codebase.sh` from this skill's
directory:

```bash
bash "<this skill's directory>/scripts/scan-codebase.sh"
```

Scanner auto-detects project root (git root or pwd) and collects:
- Structure: file count, extensions, configs, directories, src modules
- Markers: AICODE-NOTE, AICODE-TODO, AICODE-FIX with locations
- Git: branch, modified/added/deleted files

Outputs JSON. No external dependencies required.

### Exclusions (automatic)
- node_modules, .git, dist, build
- __pycache__, .venv, venv
- ai-docs, .next, .nuxt, coverage, .cache

## Step 2: Understand Structure

Interpret scan results to determine:
- **Stack**: Language(s) from extensions, framework from configs
- **Entry points**: Main/index/app files in directories
- **Modules**: Domain boundaries from src_modules or directories
- **Conventions**: Naming patterns, structure style

## Step 3: Trace Patterns

**Skip if greenfield project (no src files found in Step 1).**

For existing codebases, trace how code actually works — not just what files exist:

**3.1 Find similar features**
- Grep for features with similar domain (e.g., if building "payments", find existing "orders" or "billing")
- Identify entry points: API routes, UI components, CLI commands

**3.2 Trace execution paths**
- Follow call chain from entry point through business logic to data layer
- Note data transformations at each hop with file:line references
- Document side effects and state changes encountered

**3.3 Map abstraction layers**
- Identify boundaries: presentation → business logic → data access
- Note which patterns are in use (repository, service layer, controller, middleware, etc.)
- Document cross-cutting concerns encountered (auth, logging, caching, error handling)

**3.4 Identify reuse opportunities**
- Shared utilities and helpers with 3+ consumers
- Existing patterns that new code should follow
- Modules that new feature should integrate with (not duplicate)

## Step 4: Build Mental Model

Extract and internalize from scan results + tracing:

**From structure:**
- Stack: `[language] | [framework] | [build-tool]`
- Entry points with types
- Module list with inferred domains
- Directory organization

**From tracing (if performed):**
- Abstraction layers: `[presentation] → [business] → [data]`
- Design patterns in use with file:line examples
- Cross-cutting concerns and how they're implemented
- Reusable modules for new feature integration

**From markers:**
- AICODE-NOTE → Implementation context (why decisions were made)
- AICODE-TODO → Planned work (incomplete areas)
- AICODE-FIX → Known issues (from previous reviews)

**From git:**
- Current branch → feature context
- Changed files → review/focus scope

**From reading key files:**
- Import patterns → dependency relationships
- Shared modules → components with 3+ incoming connections
- Circular dependencies → architectural issues

## Step 5: Confirm Readiness

Output minimal confirmation with key files list:
```
✅ Code context loaded: [project-name]
   Stack: [language] | [framework]
   Modules: [count] ([list])
   Patterns: [list of design patterns found, if traced]
   Markers: [N] NOTE, [N] TODO, [N] FIX

   Key files (read these for deep context):
   - [path] — [why this file matters]
   - [path] — [why this file matters]
   - ... (5-10 files max)

   Ready for: review | planning | documentation | agent-generation
```

**Key files list** — the 5-10 most important files for understanding the area being worked on. Calling agents/commands should read these files after Code Analyzer completes rather than re-scanning independently.

## Error Handling

- **Empty project**: Report "No source files found"
- **No git repo**: Continue without git section (is_repo: false)
- **Permission denied**: Report file, continue with available
- **No similar features found**: Skip tracing, note "greenfield area — no existing patterns to follow"

## Usage Notes

This skill prepares context for:
- Code review (scope, markers, dependencies)
- Implementation planning (patterns, reuse, architecture)
- Documentation generation (structure, stack)
- Agent creation (domains, boundaries)

Context remains in memory for entire conversation.
Pliki w paczce (2)
  • SKILL.md 5 KB
  • scripts/scan-codebase.sh 8 KB

Wersje

W bazie nie ma innych skilli o nazwie code-analyzer.

Identyczna treść występuje jeszcze w 1 innych folderach na GitHubie. Tu pokazujemy jedną, najlepiej ocenioną kopię.

Migawka bazy z 13.11.2026 · wersja paczki 4e2be2802672 (skrót SHA-256 całej paczki)

Pobrania w ostatnich 30 dniach: 0 · ranking

Zgłoś problem z tym skillem: szkodliwa treść, błędny opis albo prośba autora o usunięcie.

Podobne skille

  • 100feature-analyzer
    Wczytuje pełny kontekst funkcji z dokumentacji i artefaktów, buduje model wymagań i architektury oraz sprawdza kompletność artefaktów przed implementacją, generowaniem checklist lub wykonaniem zadań.
  • 100project-analyze
    Analizuje lokalną bazę kodu w ProjectMind: pokazuje strukturę projektu, zależności i architekturę, wskazuje pliki wysokiego ryzyka oraz ocenia skutki refaktoryzacji.
  • 100analyze-codebase
    Pomaga zrozumieć i zaudytować bazę kodu przed refaktoryzacją: przegląd działania, mapa struktury plików, audyt zależności, zapachy kodu, ocena jakości i lista tego, co wymaga refaktoryzacji.
  • 100self-commenting
    Zostawia w kodzie wyszukiwalne znaczniki AICODE dla pamięci między sesjami: notatki, nieoczywistą logikę i poprawki błędów.
  • 100biz-app-analyzer
    Analizuje kod aplikacji biznesowej i tworzy bazę wiedzy dla AI w czterech dokumentach Markdown: kontekst projektu, architektura, wzorce programowania i glosariusz domeny.
  • 95repository-analyzer
    Analizuje bazy kodu i generuje dokumentację: struktura, języki, frameworki, zależności, wzorce projektowe i dług techniczny, przy poznawaniu nieznanego kodu.

Uwagi i zgłoszenia

Wiadomość trafi do Bartosza Sokolińskiego. Adres e-mail jest potrzebny tylko do odpowiedzi. Szczegóły w polityce prywatności.