DEV Community: EliotShift

I Built a Code Archaeology Engine for AI — Here's Why Claude and Cursor Keep Forgetting Your Architecture

EliotShift — Fri, 17 Apr 2026 16:57:41 +0000

TL;DR: AI coding assistants have zero architectural memory. Every session starts from scratch. I built LORE — an open-source MCP server with 13 analyzers that gives your AI deep understanding of your codebase structure. Works with Claude Desktop, Cursor, and Windsurf.

The Problem: AI Has Amnesia

Every time you start a new AI coding session, the same ritual happens.

You explain: "We use PostgreSQL because..."

Then: "Auth uses JWT with 24h expiry..."

And: "Our API follows REST with /api/v1/..."

The AI nods, understands, writes some code. Session ends.

Next session? Complete amnesia. You repeat everything. Again. And again.

After the 50th time, I stopped explaining and started building.

What I Built: LORE MCP Server

LORE (Layout-Oriented Reverse Engineering) is a code archaeology engine that reads your TypeScript/JavaScript codebase and extracts deep architectural intelligence — automatically.

No manual documentation. No prompts to paste. No CLAUDE.md files to maintain.

npx lore-mcp init

That's the setup. One command. LORE scans your entire project, runs 13 parallel analyzers, and feeds structured results to your AI assistant through the Model Context Protocol.

What Does LORE Actually Analyze?

LORE isn't a simple dependency checker. It runs 13 deep analyzers in parallel:

#	Analyzer	What It Finds
1	AST Parser	Full TypeScript/TSX structure via ts-morph
2	Dependency Graph	Every import, export, re-export in your project
3	Circular Dependencies	Import cycles ranked by severity
4	Dependency Direction	Layer violations (controller importing DB code)
5	Shannon Entropy	Complexity scoring per file
6	Hotspot Analysis	Files that change too often (git churn)
7	Import Impact	Downstream blast radius of every import
8	Type Safety Scorer	`any` usage, explicit types, strictness grades
9	Hidden Coupling	Implicit dependencies through shared types
10	AI Recommendations	Prioritized fix suggestions (P0–P3)
11	Tooling Config	ESLint, Prettier, tsconfig validation
12	Breaking Changes	High-risk deprecation patterns
13	Gap Analysis	Missing error handling, testing gaps

Here's what lore status looks like on a real project:

$ lore status

  LORE MCP Server v0.1.6
  ────────────────────────────────────

  Architecture Analysis Complete

  ├─ Overall Score:      87/100
  ├─ Type Safety:        92/100
  ├─ Tooling Config:     78/100
  └─ Architecture:       91/100

  Circular Dependencies: 3 found (2 critical)
  Hotspot Modules:       5 detected
  Hidden Coupling:       8 links
  AI Recommendations:    12 suggestions

  Analysis complete — 0 errors, 0 crashes

How It Works: 3 Steps

Step 1: Scan Your Codebase

LORE recursively walks your project tree, parsing every .ts and .tsx file. It reads your AST, maps imports/exports, tracks types, and understands your configuration files.

Step 2: Run 13 Analyzers in Parallel

All 13 analyzers fire simultaneously through a plugin pipeline:

Coupling matrices are computed
Dependency graphs are mapped
Hotspot scoring runs against your git history
Type safety is evaluated across every file
Circular dependencies are detected and ranked

Step 3: Feed Results to Your AI

Via MCP, Claude Desktop, Cursor, or Windsurf queries LORE on-demand. Your AI now reasons about real structural data — not guesses.

Ask Claude:

"What are the hidden coupling risks in my codebase?"
"Which modules are the biggest hotspots?"
"Show me all circular dependencies and their severity."
"What are the P0 recommendations?"

LORE runs the analysis and returns structured data. Claude interprets it and gives you actionable answers.

MCP Integration (60-Second Setup)

Add LORE to your MCP client configuration:

Claude Desktop (~/Library/Application Support/Claude/claude_desktop_config.json):

{
  "mcpServers": {
    "lore": {
      "command": "npx",
      "args": ["-y", "lore-mcp"]
    }
  }
}

Cursor — Add to your MCP settings:

{
  "mcpServers": {
    "lore": {
      "command": "npx",
      "args": ["-y", "lore-mcp"]
    }
  }
}

Restart your AI tool. That's it. Your AI now has architectural memory.

Battle-Tested on Real Projects

LORE isn't a toy. I tested it on 16 major open-source TypeScript projects:

Project	Files Analyzed	Result
Express	42	100% Pass
Next.js	68	100% Pass
NestJS	38	100% Pass
Fastify	55	100% Pass
Prisma	45	100% Pass
Zod	35	100% Pass
TypeORM	60	100% Pass
React	73	100% Pass

16 projects. 100% pass rate. Zero crashes.

Cross-Platform: Runs Everywhere

LORE is built on Node.js with zero native dependencies. If Node.js runs on your system, LORE runs too.

macOS (Intel + Apple Silicon M1/M2/M3/M4)
All Linux distros (Ubuntu, Debian, Kali, Fedora, Arch, CentOS, Alpine)
Windows 10/11
CI/CD pipelines (GitHub Actions, GitLab CI, Jenkins)

Only requirement: Node.js 18+. No Docker, no VM, no Rosetta.

The Tech Stack

Language: TypeScript 5.5+
AST Parsing: ts-morph 21
Protocol: Model Context Protocol (MCP) SDK 1.0
Transport: Stdio (Claude Desktop / IDE compatible)
Validation: Zod schemas
Output: ANSI terminal, Markdown, SARIF

CLI Commands

lore [path]            # Analyze project (default: cwd)
lore init              # Extract architectural decisions
lore status            # View decisions by category
lore diff              # Diff against saved baseline
lore doctor            # Environment + tooling check
lore doctor --fix      # Auto-fix project setup
lore watch             # Watch + re-analyze on change
lore mcp inspect       # Inspect MCP server setup
lore mcp config        # Claude Desktop config snippet
lore version           # Show version

Open Source & Local-First

LORE is 100% open source under MIT license. No data leaves your machine. No cloud. No API keys. No telemetry.

Everything runs locally. Your code never gets sent anywhere.

What's Next

[ ] LORE INTEGRITY — verify decisions are actually implemented
[ ] VS Code Extension
[ ] LORE NETWORK — share anonymous architectural patterns
[ ] Plugin API — write your own analyzers

Try It Now

# No install needed
npx lore-mcp init

# Or install globally
npm install -g lore-mcp
lore status

GitHub: github.com/EliotShift/lore-mcp
npm: npmjs.com/package/lore-mcp
Docs: eliotshift.github.io/lore-mcp

Built with care from Morocco.

If you found this useful, give LORE a star on GitHub. It helps more than you think.

I Built a Code Archaeology Engine for AI — Here's Why Claude and Cursor Keep Forgetting Your Architecture

EliotShift — Fri, 17 Apr 2026 16:47:16 +0000

I Built a Code Archaeology Engine for AI — Here's Why Claude and Cursor Keep Forgetting Your Architecture

TL;DR: AI coding assistants have zero architectural memory.

Every session starts from scratch. I built LORE — an open-source MCP server with 13 analyzers that gives your AI deep understanding of your codebase structure. Works with Claude Desktop, Cursor, and Windsurf.

The Problem: AI Has Amnesia

Every time you start a new AI coding session, the same ritual happens.

You explain: "We use PostgreSQL because..."

Then: "Auth uses JWT with 24h expiry..."

And: "Our API follows REST with /api/v1/..."

The AI nods, understands, writes some code. Session ends.

Next session? Complete amnesia. You repeat everything. Again. And again.

After the 50th time, I stopped explaining and started building.

What I Built: LORE MCP Server

LORE (Layout-Oriented Reverse Engineering) is a code archaeology engine that reads your TypeScript/JavaScript codebase and extracts deep architectural intelligence — automatically.

No manual documentation. No prompts to paste. No CLAUDE.md files to maintain.

npx lore-mcp init

That's the setup. One command. LORE scans your entire project, runs 13 parallel analyzers, and feeds structured results to your AI assistant through the Model Context Protocol.

What Does LORE Actually Analyze?

LORE isn't a simple dependency checker. It runs 13 deep analyzers in parallel:

#	Analyzer	What It Finds
1	AST Parser	Full TypeScript/TSX structure via ts-morph
2	Dependency Graph	Every import, export, re-export in your project
3	Circular Dependencies	Import cycles ranked by severity
4	Dependency Direction	Layer violations (controller importing DB code)
5	Shannon Entropy	Complexity scoring per file
6	Hotspot Analysis	Files that change too often (git churn)
7	Import Impact	Downstream blast radius of every import
8	Type Safety Scorer	`any` usage, explicit types, strictness grades
9	Hidden Coupling	Implicit dependencies through shared types
10	AI Recommendations	Prioritized fix suggestions (P0–P3)
11	Tooling Config	ESLint, Prettier, tsconfig validation
12	Breaking Changes	High-risk deprecation patterns
13	Gap Analysis	Missing error handling, testing gaps

Here's what lore status looks like on a real project:

$ lore status

  LORE MCP Server v0.1.6
  ────────────────────────────────────

  Architecture Analysis Complete

  ├─ Overall Score:      87/100
  ├─ Type Safety:        92/100
  ├─ Tooling Config:     78/100
  └─ Architecture:       91/100

  Circular Dependencies: 3 found (2 critical)
  Hotspot Modules:       5 detected
  Hidden Coupling:       8 links
  AI Recommendations:    12 suggestions

  Analysis complete — 0 errors, 0 crashes

Real output from lore status on Express.js project

How It Works: 3 Steps

Step 1: Scan Your Codebase

LORE recursively walks your project tree, parsing every .ts and .tsx file. It reads your AST, maps imports/exports, tracks types, and understands your configuration files.

Step 2: Run 13 Analyzers in Parallel

All 13 analyzers fire simultaneously through a plugin pipeline:

Coupling matrices are computed
Dependency graphs are mapped
Hotspot scoring runs against your git history
Type safety is evaluated across every file
Circular dependencies are detected and ranked

Step 3: Feed Results to Your AI

Via MCP, Claude Desktop, Cursor, or Windsurf queries LORE on-demand. Your AI now reasons about real structural data — not guesses.

Ask Claude:

"What are the hidden coupling risks in my codebase?"
"Which modules are the biggest hotspots?"
"Show me all circular dependencies and their severity."
"What are the P0 recommendations?"

LORE runs the analysis and returns structured data. Claude interprets it and gives you actionable answers.

MCP Integration (60-Second Setup)

Add LORE to your MCP client configuration:

Claude Desktop (~/Library/Application Support/Claude/claude_desktop_config.json):

{
  "mcpServers": {
    "lore": {
      "command": "npx",
      "args": ["-y", "lore-mcp"]
    }
  }
}

Cursor — Add to your MCP settings:

{
  "mcpServers": {
    "lore": {
      "command": "npx",
      "args": ["-y", "lore-mcp"]
    }
  }
}

Restart your AI tool. That's it. Your AI now has architectural memory.

LORE generates dependency graphs showing module relationships

Battle-Tested on Real Projects

LORE isn't a toy. I tested it on 16 major open-source TypeScript projects:

Project	Files Analyzed	Result
Express	42	100% Pass
Next.js	68	100% Pass
NestJS	38	100% Pass
Fastify	55	100% Pass
Prisma	45	100% Pass
Zod	35	100% Pass
TypeORM	60	100% Pass
React	73	100% Pass

16 projects. 100% pass rate. Zero crashes.

Cross-Platform: Runs Everywhere

LORE is built on Node.js with zero native dependencies. If Node.js runs on your system, LORE runs too.

macOS (Intel + Apple Silicon M1/M2/M3/M4)
All Linux distros (Ubuntu, Debian, Kali, Fedora, Arch, CentOS, Alpine)
Windows 10/11
CI/CD pipelines (GitHub Actions, GitLab CI, Jenkins)

Only requirement: Node.js 18+. No Docker, no VM, no Rosetta.

The Tech Stack

Language: TypeScript 5.5+
AST Parsing: ts-morph 21
Protocol: Model Context Protocol (MCP) SDK 1.0
Transport: Stdio (Claude Desktop / IDE compatible)
Validation: Zod schemas
Output: ANSI terminal, Markdown, SARIF

CLI Commands

lore [path]            # Analyze project (default: cwd)
lore init              # Extract architectural decisions
lore status            # View decisions by category
lore diff              # Diff against saved baseline
lore doctor            # Environment + tooling check
lore doctor --fix      # Auto-fix project setup
lore watch             # Watch + re-analyze on change
lore mcp inspect       # Inspect MCP server setup
lore mcp config        # Claude Desktop config snippet
lore version           # Show version

Open Source & Local-First

LORE is 100% open source under MIT license. No data leaves your machine. No cloud. No API keys. No telemetry.

Everything runs locally. Your code never gets sent anywhere.

What's Next

[ ] LORE INTEGRITY — verify decisions are actually implemented
[ ] VS Code Extension
[ ] LORE NETWORK — share anonymous architectural patterns
[ ] Plugin API — write your own analyzers

Try It Now

# No install needed
npx lore-mcp init

# Or install globally
npm install -g lore-mcp
lore status

GitHub: github.com/EliotShift/lore-mcp
npm: npmjs.com/package/lore-mcp
Docs: eliotshift.github.io/lore-mcp

Built with care from Morocco.

If you found this useful, give LORE a star on GitHub. It helps more than you think.

How do you give your AI coding assistant context about your project architecture?

EliotShift — Wed, 18 Mar 2026 01:53:57 +0000

Every time I open a new Claude Code or Cursor session,
I spend the first 10 minutes explaining my project.

"We use PostgreSQL because..."
"Auth is JWT with 24h expiry..."
"Please follow REST conventions..."

How do YOU handle this?

Do you:

Write a CLAUDE.md manually?
Paste context every session?
Use a specific prompt template?
Something else entirely?

I got tired of repeating myself and built LORE —
an MCP server that reads your codebase and
extracts these decisions automatically.

But curious what the community does.
What's your approach?

github.com/EliotShift/lore-mcp

Why I built LORE: AI keeps forgetting why your code exists

EliotShift — Wed, 18 Mar 2026 01:34:04 +0000

Every time I start a new AI coding session, I have to explain everything from scratch.

"We use PostgreSQL because..."
"Our auth uses JWT with 24h expiry..."
"The API follows REST with /api/v1/..."

The AI forgets. Every. Single. Time.

After the 50th time explaining the same decisions, I built LORE.

What is LORE?

LORE is an MCP server that reads your existing codebase and automatically extracts architectural decisions — no manual work needed.

cd your-project
lore init

That's it. LORE generates a LORE.md with everything your AI needs to know:

## Database
### 🟢 PostgreSQL as primary database
**Why**: Found pg/postgres in dependencies
**Rules**: Use connection pooling always

## Authentication
### 🟢 JWT-based authentication
**Rules**: Never store secrets in code

The Problem It Solves

AI coding tools like Claude Code and Cursor are powerful. But they have zero memory between sessions.

Every new session = complete amnesia.

Your team spent months deciding:

Why PostgreSQL over MongoDB
Why JWT over sessions
Why Zod over Yup

The next AI session knows none of this.

LORE remembers so you don't have to repeat yourself.

How It Works

LORE reads your:

package.json → detects frameworks, libraries, databases
.env.example → detects security patterns
docker-compose.yml → detects deployment decisions

Then generates a structured LORE.md that plugs directly into your MCP settings.

Quick Start

npm install -g lore-mcp
cd your-project
lore init
lore status

MCP Integration (Claude Code / Cursor)

{
  "mcpServers": {
    "lore": {
      "command": "node",
      "args": ["/path/to/lore-mcp/dist/index.js"]
    }
  }
}

What's Next

lore doctor — diagnose setup issues ✅
lore status — view all decisions ✅
LORE INTEGRITY — verify decisions are actually implemented in code
VS Code Extension
LORE NETWORK — share anonymous architectural patterns

Open Source

LORE is fully open source and local-first. No data leaves your machine.

⭐ github.com/EliotShift/lore-mcp

Built in one day from Morocco 🇲🇦