code-archaeology

Map unfamiliar codebases by analyzing structure, entry points, and architectural relationships.

Updated May 5, 2026
One-click install
npx skills add https://github.com/yanochka11/harness_bro --skill code-archaeology-yanochka11
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: code-archaeology
Source: https://github.com/yanochka11/harness_bro/tree/main/.claude/skills/curated/code-archaeology
Command: npx skills add https://github.com/yanochka11/harness_bro --skill code-archaeology-yanochka11

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

This Skill helps developers understand unfamiliar codebases quickly by building an architectural map before refactoring or modifying legacy systems.

Core Features & Use Cases

  • Codebase Mapping: Identifies project structure, entry points, dependencies, and important modules through systematic investigation.
  • Architecture Analysis: Traces data flow, discovers design patterns, and highlights frequently changed files using repository history.
  • Use Case: When joining a new engineering project, use this Skill to create a read-only overview of the system and identify where changes should be made safely.

Quick Start

Ask the code-archaeology skill to analyze this repository and explain its architecture, entry points, and key files.

Frequently Asked Questions about code-archaeology

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

FAQPage Schema
How do I map unfamiliar codebases before making changes?

To map unfamiliar codebases, systematically investigate project structure, entry points, and dependencies to build an architectural overview. This read-only analysis identifies frequently changed files using repository history and traces data flow to produce evidence-based architecture summaries.

What is the best way to analyze legacy code for refactoring preparation?

Analyzing legacy code for refactoring requires tracing architectural relationships and identifying frequently modified files via git history. This approach highlights safe modification zones and produces an evidence-based summary of the system's design patterns and data flow before development.

Can I trace data flow and identify hot files using repository exploration?

Yes, repository exploration allows you to trace data flow and identify hot files by analyzing git history and structural relationships. This read-only investigation workflow reveals frequently changed modules and core architectural patterns within the target codebase.

How do I get an architecture summary when onboarding to a new engineering project?

Getting an architecture summary during onboarding involves systematically mapping the project structure, entry points, and module dependencies. This read-only process highlights key files and design patterns, creating a safe overview of where changes should be made.

Does codebase analysis work for identifying entry points and module dependencies?

Codebase analysis works for identifying entry points and module dependencies by systematically investigating the project structure. It traces architectural relationships and data flow to map out how different components interact within the system.

When should I not use read-only codebase investigation workflows?

Read-only codebase investigation workflows should not be used when you need to modify code directly or execute runtime tests. This approach is strictly for mapping architectural relationships, tracing data flow, and producing evidence-based summaries before actual development changes.