v2.0.7

analyzing-projects

cloudai-x@cloudai-x⭐ 1.4k stars· last commit 1mo ago· 4 open issues

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?

Choose how to use this skill

You do not need every option. Choose the path your AI client supports. The stable page stays the same; versioned files are immutable.

1. Native installer

This listing has no registered native installer command. Use the complete package or source fallback below, depending on what your client supports.

Do not guess an installer command or replace an existing version without reviewing the diff.

2. Complete package recommended

Download the ZIP when available. It includes SKILL.md plus the references, security notes and version metadata.

No complete ProSkills package is published for this listing yet.

3. Prompt-only

Copy the prompt above when the agent can read the stable page or when you want to adopt the workflow without installing a skill.

Need only the instruction file?

Download SKILL.md only if your client requires a single file. The complete ZIP is safer for a full installation because it preserves the references and release context.

No path installs or executes anything by itself. Your agent still needs access to the project files. Before updating, compare the installed version and review the diff.

6.4/10
Verified
Oct 12, 2026

// RATINGS

⭐GitHub Stars
⭐⭐⭐⭐⭐ 1.4k on GitHubGitHub ↗

Very popular

🟢ProSkills ScoreAI Verified
6.4/10
📍

Not yet listed on ClawHub or SkillsMP

// README

project-starter

License: MIT Claude Code PRs Welcome

A universal Claude Code workflow plugin with specialized agents, skills, hooks, and mode commands for any software project. Compatible with skills.sh — works with Claude Code, Cursor, Codex, and 35+ AI agents.


Quick Start

Option 1: skills.sh (Recommended — Any Agent)

npx skills add CloudAI-X/claude-workflow-v2

Installs skills to Claude Code, Cursor, Codex, Windsurf, Cline, and 35+ other AI agents automatically.

Option 2: npx (Claude Code — Full Plugin)

npx install-claude-workflow-v2@latest

Copies agents, commands, skills and hook scripts into .claude/ and registers the hooks in .claude/settings.json (existing files and settings are kept). Two differences from a plugin install: commands are not namespaced (/commit instead of /project-starter:commit), and permissionMode: acceptEdits on the debugger, docs-writer, refactorer and test-architect agents takes effect (Claude Code ignores that field for plugin agents).

Option 3: CLI (Per-Session)

# Clone the plugin
git clone https://github.com/CloudAI-X/claude-workflow-v2.git

# Run Claude Code with the plugin
claude --plugin-dir ./claude-workflow-v2

Option 4: Agent SDK

import { query } from "@anthropic-ai/claude-agent-sdk";

for await (const message of query({
  prompt: "Hello",
  options: {
    plugins: [{ type: "local", path: "./claude-workflow-v2" }],
  },
})) {
  // Plugin commands, agents, and skills are now available
}

Option 5: Install Permanently

# Add this repository as a marketplace, then install the plugin from it
claude plugin marketplace add CloudAI-X/claude-workflow-v2
claude plugin install project-starter@claude-workflow

Verify Installation

After loading the plugin, verify it's working:

> /plugin

Tab to Installed - you should see project-starter listed. Tab to Errors - should be empty (no errors).

These commands become available:

/project-starter:architect    # Architecture-first mode
/project-starter:rapid        # Ship fast mode
/project-starter:commit       # Auto-generate commit message
/project-starter:verify-changes  # Multi-agent verification

What's Included

ComponentCountDescription
Agents7Specialized subagents for code review, debugging, security, etc.
Commands26Slash commands for workflows, output styles, planning, and onboarding
Skills14Knowledge domains with on-demand context loading
Hooks14Automation scripts for formatting, security, metrics, and notifications

Usage Examples

Commands in Action

Auto-commit your changes:

> /project-starter:commit

Looking at staged changes...
✓ Created commit: feat(auth): add JWT refresh token endpoint

Full git workflow:

> /project-starter:commit-push-pr

✓ Committed: feat: add user dashboard
✓ Pushed to origin/feature/dashboard
✓ Created PR #42: https://github.com/you/repo/pull/42

Verify before shipping:

> /project-starter:verify-changes

Spawning verification agents...
├─ build-validator: ✓ Build passes
├─ test-runner: ✓ 42 tests pass
├─ lint-checker: ⚠ 2 warnings (non-blocking)
└─ security-scanner: ✓ No vulnerabilities

Ready to ship!

Agents in Action

Agents spawn automatically based on your request:

You say: "The login is broken, users get 401 errors"

[debugger agent activated]
→ Checking auth middleware... found issue
→ Token validation uses wrong secret in production
→ Fix: Update AUTH_SECRET in .env.production

You say: "Review my changes"

[code-reviewer agent activated]
→ Analyzing 3 files changed...
✓ Logic is correct
⚠ Missing null check on line 42
⚠ Consider adding rate limiting to this endpoint

You say: "Add authentication to the API"

[orchestrator agent activated]
→ Breaking down into subtasks:
  1. Design auth schema (applying the designing-architecture skill)
  2. Implement JWT middleware
  3. Add login/register endpoints
  4. Write tests (spawning test-architect)
  5. Update API docs (spawning docs-writer)

Skills in Action

Skills provide domain knowledge automatically:

You ask: "How should I structure the payment service?"

[designing-architecture skill applied]
→ Recommending hexagonal architecture
→ Payment providers as adapters
→ Core domain isolated from infrastructure

You ask: "Make this endpoint faster"

[optimizing-performance skill applied]
→ Adding database indexes
→ Implementing response caching
→ Using pagination for large results

Hooks in Action

Hooks run automatically on events:

Security block (pre-edit):

🚫 BLOCKED - Security issue detected in src/config.ts:
  - Potential API key detected → Move to .env file and use environment variables (e.g., process.env.API_KEY)

Auto-format (post-edit):

The edited file is formatted silently with the project's own formatter; the hook prints nothing.

Desktop notifications:

🔔 "Claude needs input" - when waiting for your response
🔔 "Task complete" - when finished

Commands Reference

All commands use the format /project-starter:<command>.

Mode Commands (Output Styles)

CommandMode
/project-starter:architectSystem design mode - architecture before code
/project-starter:rapidFast development - ship quickly, iterate
/project-starter:mentorTeaching mode - explain the "why"
/project-starter:reviewCode review mode - strict quality

Git Workflow (Inner-Loop)

CommandPurpose
/project-starter:commitAuto-generate conventional commit message
/project-starter:commit-push-prCommit → Push → Create PR (full workflow)
/project-starter:quick-fixFast fix for lint/type errors
/project-starter:add-testsGenerate tests for recent changes
/project-starter:lint-fixAuto-fix all linting issues
/project-starter:sync-branchSync with main (rebase or merge)
/project-starter:summarize-changesGenerate standup/PR summaries

Verification

CommandPurpose
/project-starter:verify-changesMulti-subagent adversarial verification
/project-starter:validate-buildBuild process validation
/project-starter:run-testsTiered test execution
/project-starter:lint-checkCode quality checks
/project-starter:security-scanSecurity vulnerability detection
/project-starter:code-simplifierPost-implementation cleanup

Parallel

CommandPurpose
`/project-starter:parallel-rev

// HOW IT'S BUILT

// FILES

2 files shipped with this skill. Inline text is the catalog copy. The upstream link is the source repository.

  • skills/analyzing-projects/SKILL.md3.7 KBupstream ↗
    ---
    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.
    
  • README.mdupstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

Plain-text copy, no login: /skill-bundles/cloudai-x-claude-workflow-v2-skills-analyzing-projects.md

// REPO STATS

1.4k stars
4 open issues
Last commit: 1mo ago