Skip to content
Skillpedia
General coding40k · #5149

folder-structure-blueprint-generator

Has your agent analyze and document project folder structures. It detects the project type and generates a detailed blueprint. Useful for keeping code organization consistent.

What it does

This agent analyzes your programming project's folder organization. It creates a detailed guide showing how folders and files are arranged, helping to keep everything tidy and consistent.

When to use it

  • ✓When starting a new project to define a good structure.
  • ✓When reviewing an existing project to document its organization.
  • ✓When onboarding new team members to explain the structure.

Example of what to ask your AI

“Create a folder structure guide for my Node.js project, showing up to 3 levels deep and using nested lists.”

Want more? Open the sections below.

How to use

The easiest way: copy the message below and paste it into Claude, ChatGPT, Cursor or any AI. It reads the skill and follows the instructions.

Skill link

https://github.com/github/awesome-copilot/blob/main/skills/folder-structure-blueprint-generator/SKILL.md

Ready-to-paste message

Use this skill to help me: https://github.com/github/awesome-copilot/blob/main/skills/folder-structure-blueprint-generator/SKILL.md Read the SKILL.md file at that link and follow its instructions for my task.
How it works

It examines your project's folders and files, identifies the technology type used (like .NET, Java, React, etc.), and generates a document visualizing this structure.

Installation

Easiest way: copy the skill link and paste it into Claude, ChatGPT or Cursor asking it to follow the instructions.

In the terminal (Claude Code, Codex, Cursor), in your project folder:

npx skills add github/awesome-copilot --skill folder-structure-blueprint-generator

Or download just the file:

curl -L https://raw.githubusercontent.com/github/awesome-copilot/main/skills/folder-structure-blueprint-generator/SKILL.md -o SKILL.md
Technical content (original SKILL.md)

Original text by the author, straight from GitHub.

Project Folder Structure Blueprint Generator

Configuration Variables

${PROJECT_TYPE="Auto-detect|.NET|Java|React|Angular|Python|Node.js|Flutter|Other"}

<!-- Select primary technology -->

${INCLUDES_MICROSERVICES="Auto-detect|true|false"}

<!-- Is this a microservices architecture? -->

${INCLUDES_FRONTEND="Auto-detect|true|false"}

<!-- Does project include frontend components? -->

${IS_MONOREPO="Auto-detect|true|false"}

<!-- Is this a monorepo with multiple projects? -->

${VISUALIZATION_STYLE="ASCII|Markdown List|Table"}

<!-- How to visualize the structure -->

${DEPTH_LEVEL=1-5}

<!-- How many levels of folders to document in detail -->

${INCLUDE_FILE_COUNTS=true|false}

<!-- Include file count statistics -->

${INCLUDE_GENERATED_FOLDERS=true|false}

<!-- Include auto-generated folders -->

${INCLUDE_FILE_PATTERNS=true|false}

<!-- Document file naming/location patterns -->

${INCLUDE_TEMPLATES=true|false}

<!-- Include file/folder templates for new features -->

Generated Prompt

"Analyze the project's folder structure and create a comprehensive 'Project_Folders_Structure_Blueprint.md' document that serves as a definitive guide for maintaining consistent code organization. Use the following approach:

Initial Auto-detection Phase

${PROJECT_TYPE == "Auto-detect" ? "Begin by scanning the folder structure for key files that identify the project type:

  • Look for solution/project files (.sln, .csproj, .fsproj, .vbproj) to identify .NET projects
  • Check for build files (pom.xml, build.gradle, settings.gradle) for Java projects
  • Identify package.json with dependencies for JavaScript/TypeScript projects
  • Look for specific framework files (angular.json, react-scripts entries, next.config.js)
  • Check for Python project identifiers (requirements.txt, setup.py, pyproject.toml)
  • Examine mobile app identifiers (pubspec.yaml, android/ios folders)
  • Note all technology signatures found and their versions" : "Focus analysis on ${PROJECT_TYPE} project structure"}

${IS_MONOREPO == "Auto-detect" ? "Determine if this is a monorepo by looking for:

  • Multiple distinct projects with their own configuration files
  • Workspace configuration files (lerna.json, nx.json, turborepo.json, etc.)
  • Cross-project references and shared dependency patterns
  • Root-level orchestration scripts and configuration" : ""}

${INCLUDES_MICROSERVICES == "Auto-detect" ? "Check for microservices architecture indicators:

  • Multiple service directories with similar/repeated structures
  • Service-specific Dockerfiles or deployment configurations
  • Inter-service communication patterns (APIs, message brokers)
  • Service registry or discovery configuration
  • API gateway configuration files
  • Shared libraries or utilities across services" : ""}

${INCLUDES_FRONTEND == "Auto-detect" ? "Identify frontend components by looking for:

  • Web asset directories (wwwroot, public, dist, static)
  • UI framework files (components, modules, pages)
  • Frontend build configuration (webpack, vite, rollup, etc.)
  • Style sheet organization (CSS, SCSS, styled-components)
  • Static asset organization (images, fonts, icons)" : ""}

1. Structural Overview

Provide a high-level overview of the ${PROJECT_TYPE == "Auto-detect" ? "detected project type(s)" : PROJECT_TYPE} project's organization principles and folder structure:

  • Document the overall architectural approach reflected in the folder structure
  • Identify the main organizational principles (by feature, by layer, by domain, etc.)
  • Note any structural patterns that repeat throughout the codebase
  • Document the rationale behind the structure where it can be inferred

${IS_MONOREPO == "Auto-detect" ? "If detected as a monorepo, explain how the monorepo is organized and the relationship between projects." : IS_MONOREPO ? "Explain how the monorepo is organized and the relationship between projects." : ""}

${INCLUDES_MICROSERVICES == "Auto-detect" ? "If microservices are detected, describe how they are structured and organized." : INCLUDES_MICROSERVICES ? "Describe how the microservices are structured and organized." : ""}

2. Directory Visualization

${VISUALIZATION_STYLE == "ASCII" ? "Create an ASCII tree representation of the folder hierarchy to depth level ${DEPTH_LEVEL}." : ""}

${VISUALIZATION_STYLE == "Markdown List" ? "Use nested markdown lists to represent the folder hierarchy to depth level ${DEPTH_LEVEL}." : ""}

${VISUALIZATION_STYLE == "Table" ?

…

FAQ

What is a folder structure 'blueprint'?

It's a document that describes and visualizes how a project's folders and files are organized, serving as a map.

Does it work for any project type?

Yes, it tries to auto-detect the project type (.NET, Java, React, Python, etc.), or you can specify it.

Can I choose how the structure is displayed?

Yes, you can choose between visualizations like an ASCII tree, Markdown list, or table.

Details

Original description by the author

Comprehensive technology-agnostic prompt for analyzing and documenting project folder structures. Auto-detects project types (.NET, Java, React, Angular, Python, Node.js, Flutter), generates detailed blueprints with visualization options, naming conventions, file placement patterns, and extension templates for maintaining consistent code organization across diverse technology stacks.

repo: github/awesome-copilot

Popularity

GitHub stars
40k
Ranking position
#5149
License
MIT
Updated
10/15/2026

Is this skill useful?

0

Sign in to vote.

Comments

  • …

More skills from this repository

Similar skills