Core Commands for Claude Code

A comprehensive collection of slash commands for Claude Code that streamline the software development lifecycle from project setup through documentation.

Installation

To install these commands, copy the entire core folder to your Claude commands directory:

# Clone this repository
git clone https://github.com/yourusername/core-commands.git

# Copy the core folder to your Claude commands directory
cp -r core-commands/commands/core ~/.claude/commands/

After installation, all commands will be available with the core: prefix (e.g., /core:help).

Overview

These core commands provide a structured workflow for software development, covering every phase from initial project setup through implementation, testing, and documentation. Each command generates specific artifacts in predictable locations, making it easy to track progress and maintain consistency across projects.

Command Reference

📋 /core:help

Purpose: Display a comprehensive overview of all available core commands and example workflows.

Usage: /core:help

Output: Command index with descriptions and example end-to-end workflows.

---

🏗️ /core:project-setup

Purpose: Initialize a new project with proper directory structure and baseline configuration files.

Usage: /core:project-setup [project-name] [project-type]

Arguments:

• project-name: Name of the new project (directory-safe)
• project-type: Type of project (node, python, dotnet, or defaults to generic)

Example: /core:project-setup acme-saas node

Creates:

• Complete directory structure (src, tests, docs, etc.)
• Type-specific configuration files
• Git repository initialization
• Basic CI/CD scaffolding

---

📝 /core:requirements

Purpose: Generate detailed requirements specification for a feature.

Usage: /core:requirements [feature-name] "[feature-description]"

Example: /core:requirements user-authentication "Users need to authenticate using OAuth2"

Output:

• ./specs/{feature-name}.spec.md - Comprehensive requirements document
• ./specs/{feature-name}.checklist.md - Requirements checklist

---

📚 /core:stories

Purpose: Break down requirements into user stories with acceptance criteria.

Usage: /core:stories [feature-name] [--jira | --github | --linear]

Example: /core:stories user-authentication --github

Output:

• ./stories/{feature-name}/ - Individual story files
• ./stories/{feature-name}/index.md - Story index with dependencies
• Optional: Integration with project management systems

---

📐 /core:plan

Purpose: Create a detailed technical implementation plan with actionable steps.

Usage: /core:plan [feature-name] "[description]"

Example: /core:plan user-authentication "Focus on Google and GitHub providers first"

Output: ./plans/{feature-name}.plan.md - Step-by-step implementation plan

---

🏛️ /core:design

Purpose: Generate architecture and design documentation based on requirements and plan.

Usage: /core:design [feature-name] [plan-file-path]

Example: /core:design user-authentication

Output: ./designs/{feature-name}.design.md - Comprehensive architecture document

---

💻 /core:implement

Purpose: Implement feature code according to specifications, plan, and design.

Usage: /core:implement [feature-name] [--dry-run]

Example: /core:implement user-authentication

Features:

• Follows existing code conventions
• Validates with linting and type checking
• Supports dry-run mode for previewing changes

Output: ./implementations/{feature-name}.report.md - Implementation report

---

🧪 /core:test

Purpose: Generate and run comprehensive test suites (unit, integration, E2E).

Usage: /core:test [feature-name] [--type unit|integration|e2e|all] [--run]

Example: /core:test user-authentication --type all --run

Output: ./tests/reports/{feature-name}.test-report.md - Test coverage report

---

🔍 /core:review

Purpose: Perform comprehensive code review with automated checks.

Usage: /core:review [feature-name] [--fix] [--strict]

Example: /core:review user-authentication --strict

Checks:

• Build and compilation
• Type checking
• Linting
• Security analysis
• Code quality metrics

Output: ./reviews/{feature-name}.review.md - Detailed review findings

---

🔧 /core:refactor

Purpose: Analyze code for improvements and apply refactoring suggestions.

Usage: /core:refactor [feature-name] [--apply] [--conservative]

Example: /core:refactor user-authentication --apply

Output: ./refactorings/{feature-name}.refactor.md - Refactoring analysis and results

---

📖 /core:document

Purpose: Update all project documentation including inline code docs, READMEs, and API documentation.

Usage: /core:document [feature-name] [--generate-missing] [--update-only]

Example: /core:document user-authentication --generate-missing

Updates:

• Inline code documentation (JSDoc, TSDoc, etc.)
• README files
• API documentation
• Architecture diagrams

Output: ./docs/features/{feature-name}.md - Feature documentation

---

🛠️ /core:create-command

Purpose: Create new custom slash commands with proper structure.

Usage: /core:create-command [command-name] "[description]" [global | project]

Example: /core:create-command plan-migration "Generate a plan to migrate Postgres tables to a new schema"

Output: New command file in .claude/commands/ or ~/.claude/commands/

Workflow Example

Here's a typical workflow for implementing a new feature:

# 1. Start with requirements
/core:requirements user-auth "Implement OAuth2 authentication"

# 2. Break down into stories
/core:stories user-auth --github

# 3. Create implementation plan
/core:plan user-auth "Support Google and GitHub providers"

# 4. Design the architecture
/core:design user-auth

# 5. Implement the feature
/core:implement user-auth

# 6. Write and run tests
/core:test user-auth --type all --run

# 7. Perform code review
/core:review user-auth --strict

# 8. Refactor if needed
/core:refactor user-auth --apply

# 9. Update documentation
/core:document user-auth --generate-missing

Directory Structure

These commands create and maintain a consistent directory structure:

project/
├── .claude/commands/     # Custom project commands
├── specs/               # Requirements specifications
├── stories/             # User stories
├── plans/               # Implementation plans
├── designs/             # Architecture designs
├── implementations/     # Implementation reports
├── tests/reports/       # Test reports
├── reviews/             # Code review findings
├── refactorings/        # Refactoring reports
└── docs/               # Documentation
    └── features/       # Feature-specific docs

Best Practices

1. Follow the workflow: Start with requirements and work through each phase
2. Review artifacts: Each command generates reports for team review
3. Use flags wisely:
   • --dry-run for previewing changes
   • --strict for enforcing quality gates
   • --conservative for safer refactoring
4. Track progress: Commands integrate with TodoWrite for task management
5. Maintain consistency: Commands respect existing project conventions

Contributing

To contribute new commands or improvements:

1. Follow the existing command structure
2. Include comprehensive documentation
3. Test thoroughly with different project types
4. Submit pull requests with clear descriptions

License

This project is licensed under the MIT License - see the LICENSE file for details.