analyzing-projects
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.
// RATINGS
Not yet listed on ClawHub or SkillsMP
// README
project-starter
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
| Component | Count | Description |
|---|---|---|
| Agents | 7 | Specialized subagents for code review, debugging, security, etc. |
| Commands | 26 | Slash commands for workflows, output styles, planning, and onboarding |
| Skills | 14 | Knowledge domains with on-demand context loading |
| Hooks | 14 | Automation 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)
| Command | Mode |
|---|---|
/project-starter:architect | System design mode - architecture before code |
/project-starter:rapid | Fast development - ship quickly, iterate |
/project-starter:mentor | Teaching mode - explain the "why" |
/project-starter:review | Code review mode - strict quality |
Git Workflow (Inner-Loop)
| Command | Purpose |
|---|---|
/project-starter:commit | Auto-generate conventional commit message |
/project-starter:commit-push-pr | Commit → Push → Create PR (full workflow) |
/project-starter:quick-fix | Fast fix for lint/type errors |
/project-starter:add-tests | Generate tests for recent changes |
/project-starter:lint-fix | Auto-fix all linting issues |
/project-starter:sync-branch | Sync with main (rebase or merge) |
/project-starter:summarize-changes | Generate standup/PR summaries |
Verification
| Command | Purpose |
|---|---|
/project-starter:verify-changes | Multi-subagent adversarial verification |
/project-starter:validate-build | Build process validation |
/project-starter:run-tests | Tiered test execution |
/project-starter:lint-check | Code quality checks |
/project-starter:security-scan | Security vulnerability detection |
/project-starter:code-simplifier | Post-implementation cleanup |
Parallel
| Command | Purpose |
|---|---|
| `/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