Skip to main content
skill CX Codex

analyzing-projects — Claude Code skill: what it does, how to install

analyzing-projects walks through an unfamiliar codebase step by step: stack, structure, patterns, dev commands — useful when onboarding onto a project.

MIT ★ 1,424 updated 2026-10-06

Install into Claude Code · Plugin marketplace All methods and platforms ↓
/plugin marketplace add CloudAI-X/claude-workflow-v2
/plugin install project-starter@claude-workflow
Open on GitHub

What analyzing-projects does

The skill runs a staged review inside Claude Code. It starts with the README and root files, then detects the stack from markers like package.json, requirements.txt, go.mod or Cargo.toml, maps the directory tree with short notes, and flags architectural patterns such as monolith, microservices or serverless, along with API style, database choice, auth method and test setup.

After that it checks the dev workflow: linting configs (.eslintrc, .prettierrc), git hooks under .husky/, a Makefile, or npm scripts. Everything lands in a fixed report template covering overview, a stack table, entry points, conventions and commands like npm install or npm test.

A validation checklist closes the process: anything that can't be confirmed from the code gets flagged as needing clarification rather than guessed.

What it helps with

  • map out an unfamiliar project's architecture
  • detect the stack from config files
  • build an annotated directory tree
  • locate install, run and test commands
  • surface naming and code-style conventions

Example prompts for the agent

  • Analyze this project and summarize its architecture
  • What's the tech stack behind this repo?
  • Give me a report on the project structure and entry points

How to install analyzing-projects

1Plugin marketplace

/plugin marketplace add CloudAI-X/claude-workflow-v2
/plugin install project-starter@claude-workflow

This installs the whole project-starter plugin with all its skills

2Skills CLI (Vercel)

npx skills add CloudAI-X/claude-workflow-v2 --skill analyzing-projects -a claude-code

3Manually: put the files in place

~/.claude/skills/analyzing-projects/SKILL.md

Copy the whole skill folder; for one project use .claude/skills/analyzing-projects/

Step by step, with commands for each platform: How to install skills in Claude Code: five ways

Questions about analyzing-projects

How do I install analyzing-projects in Claude Code?

Run /plugin marketplace add CloudAI-X/claude-workflow-v2, then /plugin install project-starter@claude-workflow.

What does analyzing-projects do?

It reviews a codebase to work out the tech stack, directory structure, architectural patterns and dev commands, then writes up a report.

When should this skill load?

It's meant for onboarding onto a new project or answering architecture questions; skip it once you already know the project's layout.

Source text

SKILL.md · MIT
---
name: analyzing-projects
description: Analyzes codebases to understand structure, tech stack, patterns, and conventions. Use when onboarding to a new project, exploring unfamiliar code, or when asked "how does this work?" or "what's the architecture?"
---

# Analyzing Projects

### When to Load

- **Trigger**: Onboarding to a new project, "how does this work" questions, codebase exploration, understanding unfamiliar code
- **Skip**: Already familiar with the project structure and patterns

## Project Analysis Workflow

Copy this checklist and track progress:

```
Project Analysis Progress:
- [ ] Step 1: Quick overview (README, root files)
- [ ] Step 2: Detect tech stack
- [ ] Step 3: Map project structure
- [ ] Step 4: Identify key patterns
- [ ] Step 5: Find development workflow
- [ ] Step 6: Generate summary report
```

## Step 1: Quick Overview

```bash
# Check for common project markers
ls -la
cat README.md 2>/dev/null | head -50
```

## Step 2: Tech Stack Detection

### Package Managers & Dependencies

- `package.json` → Node.js/JavaScript/TypeScript
- `requirements.txt` / `pyproject.toml` / `setup.py` → Python
- `go.mod` → Go
- `Cargo.toml` → Rust
- `pom.xml` / `build.gradle` → Java
- `Gemfile` → Ruby

### Frameworks (from dependencies)

- React, Vue, Angular, Next.js, Nuxt
- Express, FastAPI, Django, Flask, Rails
- Spring Boot, Gin, Echo

### Infrastructure

- `Dockerfile`, `docker-compose.yml` → Containerized
- `kubernetes/`, `k8s/` → Kubernetes
- `terraform/`, `.tf` files → IaC
- `serverless.yml` → Serverless Framework
- `.github/workflows/` → GitHub Actions

## Step 3: Project Structure Analysis

Present as a tree with annotations:

```
project/
├── src/              # Source code
│   ├── components/   # UI components (React/Vue)
│   ├── services/     # Business logic
│   ├── models/       # Data models
│   └── utils/        # Shared utilities
├── tests/            # Test files
├── docs/             # Documentation
└── config/           # Configuration
```

## Step 4: Key Patterns Identification

Look for and report:

- **Architecture**: Monolith, Microservices, Serverless, Monorepo
- **API Style**: REST, GraphQL, gRPC, tRPC
- **State Management**: Redux, Zustand, MobX, Context
- **Database**: SQL, NoSQL, ORM used
- **Authentication**: JWT, OAuth, Sessions
- **Testing**: Jest, Pytest, Go test, etc.

## Step 5: Development Workflow

Check for:

- `.eslintrc`, `.prettierrc` → Linting/Formatting
- `.husky/` → Git hooks
- `Makefile` → Build commands
- `scripts/` in package.json → NPM scripts

## Step 6: Output Format

Generate a summary using this template:

```markdown
# Project: [Name]

## Overview

[1-2 sentence description]

## Tech Stack

| Category  | Technology |
| --------- | ---------- |
| Language  | TypeScript |
| Framework | Next.js 14 |
| Database  | PostgreSQL |
| ...       | ...        |

## Architecture

[Description with simple ASCII diagram if helpful]

## Key Directories

- `src/` - [purpose]
- `lib/` - [purpose]

## Entry Points

- Main: `src/index.ts`
- API: `src/api/`
- Tests: `npm test`

## Conventions

- [Naming conventions]
- [File organization patterns]
- [Code style preferences]

## Quick Commands

| Action  | Command         |
| ------- | --------------- |
| Install | `npm install`   |
| Dev     | `npm run dev`   |
| Test    | `npm test`      |
| Build   | `npm run build` |
```

## Analysis Validation

After completing analysis, verify:

```
Analysis Validation:
- [ ] All major directories explained
- [ ] Tech stack accurately identified
- [ ] Entry points documented
- [ ] Development commands verified working
- [ ] No assumptions made without evidence
```

If any items cannot be verified, note them as "needs clarification" in the report.

© CloudAI-X · MIT · CloudAI-X/claude-workflow-v2

Similar skills

All skills for Agent setup: memory, context, orchestration →

From the same set46

The whole set →
code-simplifier The code-simplifier command reviews recent changes and proposes cleaner code without changing behavior. Use it after implementing a feature or refactoring. CX Codex +1 ★ 1,424repo stars security-scan security-scan is a command for Claude Code that checks a repository for hardcoded secrets, vulnerable dependencies, injection, XSS and weak config before a commit or PR. CX Codex +1 ★ 1,424repo stars verify-changes verify-changes executes adversarial multi-subagent verification across recent code diffs to weed out bugs and false alarms. CX Codex +1 ★ 1,424repo stars save-session-learnings The save-session-learnings command for Claude Code saves useful findings from a coding session to CLAUDE.md and AGENTS.md after debugging or a substantial task. CX Codex +1 ★ 1,424repo stars plan Creates and maintains a structured PLAN.md file in your project root to track phases, task dependencies, and progress logs. CX Codex +1 ★ 1,424repo stars refactor-guided refactor-guided guides structural refactoring in small steps and runs tests after each change. It keeps feature work separate from code restructuring. CX Codex +1 ★ 1,424repo stars convex-backend convex-backend is a Claude Code skill that loads Convex guidelines for TypeScript functions, schemas, validators, queries, mutations, actions, subscriptions, and file storage. It supports type-safe backend development. CX Codex +1 ★ 1,424repo stars dependency-upgrade The dependency-upgrade command for Claude Code updates packages one by one, runs tests after each upgrade, and rolls back changes on failures. CX Codex +1 ★ 1,424repo stars

Project sponsors

Companies that keep this analytics open