show-architecture

Generate annotated ASCII file trees from a project root path.

20|3|Updated Aug 16, 2016
One-click install
npx skills add https://github.com/heyJordanParker/dotfiles --skill show-architecture
Or copy as Structured Prompt for Agent▼
Please help me install this Agent Skill.
Skill: show-architecture
Source: https://github.com/heyJordanParker/dotfiles/tree/main/claude/.claude/skills/show-architecture
Command: npx skills add https://github.com/heyJordanParker/dotfiles --skill show-architecture

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

This skill helps developers understand codebases by generating annotated ASCII file trees that illustrate the project structure and relationships.

Core Features & Use Cases

  • Generate annotated directory trees for unfamiliar code to reveal module boundaries and dependencies.
  • Visualize feature architectures and system relationships to aid design reviews and onboarding.
  • Use in documentation to provide a live, readable map of the codebase during architecture discussions.

Quick Start

Use the skill to visualize the architecture of a codebase by supplying the root directory path. Example: show-architecture /path/to/project

Frequently Asked Questions about show-architecture

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

FAQPage Schema
How do I visualize code architecture for an unfamiliar project?▼

To visualize code architecture, you can generate an annotated ASCII file tree by providing the project's root directory path. This outputs a read-only structural map illustrating module boundaries and dependencies to help you understand unfamiliar code.

What is the best way to generate a directory tree for code onboarding?▼

Generating an annotated ASCII directory tree is an effective way to support code onboarding. It provides a live, readable map of the codebase that reveals system relationships and feature structures during onboarding sessions.

Can I use ASCII file trees for architecture documentation?▼

Yes, you can use ASCII file trees for architecture documentation. They provide a live, readable map of the codebase that illustrates project structure and relationships, which is useful for updating architecture diagrams and design reviews.

Does visualizing code structure require specific dependencies or components?▼

Visualizing code structure with this approach requires no specific dependencies or components. You simply supply the root directory path of the project, and it generates a read-only ASCII tree with inline annotations.

When should I use an annotated file tree instead of a manual architecture diagram?▼

You should use an annotated file tree when exploring unfamiliar code, explaining feature structure, or updating architecture diagrams. It provides a live, readable map of the codebase structure rather than a static manual diagram.