analyzing-projects
Scannednpx machina-cli add skill CloudAI-X/claude-workflow-v2/analyzing-projects --openclawAnalyzing 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
# 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/TypeScriptrequirements.txt/pyproject.toml/setup.py→ Pythongo.mod→ GoCargo.toml→ Rustpom.xml/build.gradle→ JavaGemfile→ Ruby
Frameworks (from dependencies)
- React, Vue, Angular, Next.js, Nuxt
- Express, FastAPI, Django, Flask, Rails
- Spring Boot, Gin, Echo
Infrastructure
Dockerfile,docker-compose.yml→ Containerizedkubernetes/,k8s/→ Kubernetesterraform/,.tffiles → IaCserverless.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 hooksMakefile→ Build commandsscripts/in package.json → NPM scripts
Step 6: Output Format
Generate a summary using this template:
# 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.
Source
git clone https://github.com/CloudAI-X/claude-workflow-v2/blob/main/skills/analyzing-projects/SKILL.mdView on GitHub Overview
Analyzing-projects helps you onboard to a new codebase, explore unfamiliar code, and answer questions like 'how does this work?' or 'what's the architecture?'. It guides you through detecting the tech stack, mapping project structure, and identifying key patterns so you can generate a clear summary report.
How This Skill Works
It follows a six-step workflow: quick overview, tech stack detection, project structure analysis, patterns identification, development workflow review, and a final summary report. It uses file markers, dependency manifests, and config cues (e.g., package.json, go.mod, Dockerfiles) to infer language, frameworks, architecture, and conventions, then outputs a structured report.
When to Use It
- Onboarding to a new project
- Answering 'how does this work?' or 'what's the architecture?'
- Exploring unfamiliar codebases
- Auditing a project to map tech stack and structure
- Documenting conventions and development workflow
Quick Start
- Step 1: Quick Overview — run ls -la and inspect README.md
- Step 2: Tech Stack Detection — examine package manager files, requirements, go.mod, Dockerfiles, etc.
- Step 3: Generate Summary — produce the Markdown report per the Output Format
Best Practices
- Start with a quick README and root markers to establish context
- Detect tech stack using package managers, dependencies, and infrastructure cues
- Present the project as a tree with annotated directories
- Identify and report key patterns: architecture, API style, state management, database, auth, testing
- Follow the Output Format and run the Analysis Validation checklist
Example Use Cases
- Onboarding to a new React/Node project to map stack and structure
- Exploring a Python Django repo to understand modules and patterns
- Profiling a Go microservice suite to clarify architecture and workflows
- Analyzing a Java Spring Boot monolith to document conventions
- Reviewing a multi-repo codebase to identify deployment and API boundaries