serena-code-architecture

Analyze codebase architecture using Serena symbols and Forgetful memories.

Updated Jan 19, 2026

Search Tags:#architecture #codebase #analyze #Serena #knowledge-graph #Forgetful

Ready to run

npx skills add https://github.com/loriensleafs/brain --skill serena-code-architecture-loriensleafs

💬 Prompt for ChatGPT / Claude Chat▼

Please help me install this Agent Skill.
Skill: serena-code-architecture
Source: https://github.com/loriensleafs/brain/tree/main/apps/claude-plugin/skills/serena-code-architecture
Command: npx skills add https://github.com/loriensleafs/brain --skill serena-code-architecture-loriensleafs

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

Architects and engineers often need a repeatable method to understand a codebase's structure, dependencies, and component relationships. This skill guides a systematic architectural analysis using Serena's symbol-level understanding and Forgetful's memory graph to capture insights.

Core Features & Use Cases

Phase 1: Project Structure Discovery — identify entry points and organizational patterns by listing top-level and nested directories.
Phase 2: Entry Point Analysis — locate main modules and entry points to surface execution paths.
Phase 3: Core Component Mapping — map major components (services, controllers, models) and their relationships.
Phase 4: Dependency Tracing — trace how components depend on each other and how data flows.
Phase 5: Architectural Memories (Optional) — persist findings in Forgetful for future reference and graph queries.

Quick Start

Provide a repository URL or attach a sample project, then trigger the Serena-based architecture analysis workflow to begin.

Frequently Asked Questions about serena-code-architecture

High-intent search queries and answers about installing and using this skill.

FAQPage Schema

How do I analyze a codebase architecture systematically?▼

Codebase architecture analysis is automated using Serena symbols and Forgetful memories to map project structure, entry points, core components, and dependencies. This systematic approach applies symbol-level understanding to capture structural relationships and data flow.

What is the best way to map core components and dependencies in a repository?▼

Mapping core components and dependencies involves locating major services, controllers, and models, then tracing how they interact. This skill uses Serena's symbol-level understanding to extract architectural relationships and trace data flow paths.

How does knowledge-graph construction work for code architecture?▼

Knowledge-graph construction for code architecture works by extracting symbols from Serena and persisting structural findings as memories in Forgetful. This creates a queryable graph capturing component relationships, execution paths, and dependency mappings.

Do I need Serena tooling to perform project structure discovery?▼

Yes, Serena tooling is required to perform project structure discovery and entry-point analysis. The workflow relies on Serena's symbol-level understanding to identify organizational patterns and execution paths within the codebase.

Can I persist architectural analysis findings for future reference?▼

Architectural analysis findings can be optionally persisted in Forgetful memories for future reference and graph queries. This allows architectural insights to be stored and retrieved later without re-running the full component mapping workflow.

What are the limitations of using symbol-level analysis for codebase discovery?▼

Symbol-level analysis focuses on structural and dependency relationships rather than runtime behavior. It maps static code architecture using Serena symbols, meaning dynamic execution patterns or environmental dependencies may not be fully captured in the knowledge graph.