Claude Code Integration

This skill integrates Claude Code capabilities into OpenClaw, providing access to AI-assisted coding workflows, documentation, and best practices.

What You Can Do

📚 Documentation Queries

Query Claude Code documentation
Get best practices and workflows
Learn about settings and customization
Troubleshoot common issues

🤖 Subagent Management

Create coding subagents
Manage agent teams
Execute complex development tasks
Automate code reviews and PR workflows

🛠️ Development Workflows

Best practices for AI-assisted coding
Common workflows and patterns
Settings and configuration
Troubleshooting guidance

Usage Examples

Query Documentation

# Get documentation about a specific topic
claude-code query "subagents"
claude-code query "best practices"
claude-code query "settings"

Execute Coding Task

# Create a coding subagent for a complex task
claude-code task --description "Fix the login bug" --priority high
claude-code task --description "Refactor the database layer" --model claude-3-5-sonnet

List Available Commands

# Show all available commands
claude-code --help

Available Commands

query

Query Claude Code documentation for a specific topic.

Usage:

claude-code query <topic>

Examples:

claude-code query "subagents"
claude-code query "agent-teams"
claude-code query "best practices"
claude-code query "common workflows"
claude-code query "settings"
claude-code query "troubleshooting"

Topics include:

Subagents and agent teams
Best practices and workflows
Settings and customization
Troubleshooting guide
Plugins and extensions
MCP (Model Context Protocol)
Headless/Programmatic usage

task

Create and execute a coding subagent task.

Usage:

claude-code task --description "<task description>" [--priority <level>] [--model <model-name>]

Options:

--description, -d: Task description (required)
--priority, -p: Task priority (low/medium/high, default: medium)
--model, -m: Model to use (optional, uses default if not specified)

Examples:

claude-code task --description "Implement user authentication module"
claude-code task --description "Refactor database queries" --priority high
claude-code task --description "Write unit tests for the API" --model claude-3-5-sonnet

docs

Get overview of Claude Code documentation sections.

Usage:

claude-code docs [section]

Sections:

quickstart - Getting started guide
best-practices - AI coding best practices
common-workflows - Typical development workflows
settings - Customization options
troubleshooting - Common issues and solutions
all - Full documentation overview (default)

Examples:

claude-code docs
claude-code docs quickstart
claude-code docs best-practices
claude-code docs troubleshooting

info

Display Claude Code configuration and status.

Usage:

claude-code info

Output includes:

Version information
Available subagents
Configured models
MCP servers status

Integration with OpenClaw

This skill works seamlessly with OpenClaw's native capabilities:

Subagents: Claude Code subagents complement OpenClaw's subagent system
Code Execution: Use with OpenClaw's exec tool for complete development workflow
File Management: Combine with OpenClaw's read/write tools for full codebase management
Sessions: Claude Code tasks integrate with OpenClaw's session management

Example Workflows

Complex Bug Fix

# 1. Query best practices for debugging
claude-code query "debugging best practices"

# 2. Create a subagent to investigate and fix
claude-code task --description "Find and fix the null pointer exception in userService.js" --priority high

# 3. Review the changes
claude-code query "code review best practices"

New Feature Development

# 1. Get best practices for the feature type
claude-code query "API design best practices"

# 2. Create development task
claude-code task --description "Implement REST API for user management" --priority medium

# 3. Check settings for code style
claude-code query "code style settings"

Code Review Automation

# 1. Query PR review best practices
claude-code query "PR review workflows"

# 2. Set up automated review task
claude-code task --description "Review all PRs in the last week" --priority low

Configuration

Environment Variables

Not required for basic usage. Claude Code integration uses OpenClaw's native capabilities.

Models

Uses OpenClaw's configured default models. Override per task with --model option.

Subagent Limits

Managed by OpenClaw's subagent configuration (default: 8 concurrent subagents).

Notes

This skill provides a wrapper around Claude Code documentation and workflows
Complex coding tasks are executed through OpenClaw's native subagent system
For direct Claude Code CLI usage, install Claude Code separately from https://claude.com/code
All task execution happens through OpenClaw's secure agent infrastructure

🚀 Spec-Driven Development with Spec-Kit

What is Spec-Driven Development?

Spec-Driven Development flips the script on traditional software development. Instead of coding first and treating specs as scaffolding, specifications become executable - directly generating working implementations rather than just guiding them.

Spec-Kit Core Philosophy

Intent-driven: Specifications define the "what" before the "how"
Rich specifications: Guardrails and organizational principles
Multi-step refinement: No one-shot code generation
AI-native: Leverages advanced AI model capabilities

Spec-Kit Workflow (7 Steps)

Step 1: Install Spec-Kit CLI

# Install via uv (recommended)
uv tool install specify-cli --from git+https://github.com/github/spec-kit.git

# Verify installation
specify check

# Initialize project with Claude Code
specify init <PROJECT_NAME> --ai claude

Step 2: Establish Project Principles

Use /speckit.constitution command to create governing principles:

/speckit.constitution Create principles focused on:
- Code quality standards
- Testing requirements
- User experience consistency
- Performance requirements
- Design system guidelines

Creates .specify/memory/constitution.md - your project's foundational guidelines.

Step 3: Create the Specification

Use /speckit.specify to describe what to build:

/speckit.specify Build an application that [describe your product vision]
Focus on:
- What the application does
- User stories and scenarios
- Core features and functionality
- User experience goals
NOT the tech stack!

Step 4: Clarify Requirements (Optional but Recommended)

Use /speckit.clarify for structured questioning:

/speckit.clarify

Sequential, coverage-based questioning that records answers in Clarifications section.

Step 5: Create Technical Plan

Use /speckit.plan to define your tech stack:

/speckit.plan The application uses:
- Frontend: [React/Vue/Vanilla HTML+CSS+JS]
- Backend: [Node.js/Python/Go]
- Database: [PostgreSQL/MongoDB/LocalStorage]
- Key libraries: [list dependencies]

Step 6: Generate Tasks

Use /speckit.tasks to break down implementation:

/speckit.tasks

Creates tasks.md with:

Task breakdown by user story
Dependency management
Parallel execution markers ([P])
File path specifications
TDD structure

Step 7: Execute Implementation

Use /speckit.implement to build:

/speckit.implement

Executes tasks in correct order, follows TDD approach, provides progress updates.

Available Slash Commands

Core Commands (Essential)

Command	Description
`/speckit.constitution`	Create/update project principles
`/speckit.specify`	Define what to build (requirements)
`/speckit.plan`	Create technical implementation plan
`/speckit.tasks`	Generate actionable task list
`/speckit.implement`	Execute all tasks

Optional Commands (Enhanced Quality)

Command	Description
`/speckit.clarify`	Structured requirements clarification
`/speckit.analyze`	Cross-artifact consistency analysis
`/speckit.checklist`	Quality validation checklists

Project Structure (After `specify init`)

PROJECT_NAME/
├── .specify/
│   ├── memory/
│   │   └── constitution.md      # Project principles
│   ├── scripts/
│   │   ├── check-prerequisites.sh
│   │   ├── common.sh
│   │   ├── create-new-feature.sh
│   │   ├── setup-plan.sh
│   │   └── update-claude-md.sh
│   └── specs/
│       └── 001-feature-name/
│           ├── spec.md           # Functional specs
│           ├── plan.md          # Technical plan
│           ├── tasks.md         # Implementation tasks
│           └── quickstart.md    # Run instructions
├── CLAUDE.md                     # AI assistant guidance
└── templates/
    ├── CLAUDE-template.md
    ├── plan-template.md
    ├── spec-template.md
    └── tasks-template.md

Real-World Example: Skeuomorphic Todo App

Step 1: Initialize Project

specify init todo-app-spec-kit --ai claude
cd todo-app-spec-kit

Step 2: Create Constitution

/speckit.constitution Create principles:
- Design Excellence: Skeuomorphic first, tactile feedback
- Code Quality: Clean architecture, progressive enhancement
- Testing: Visual testing, interaction testing
- User Experience: Intuitive, rewarding, calm design

Step 3: Specify Requirements

/speckit.specify Build a beautiful todo list app with:
- Tasks as index cards on a corkboard or notebook
- Add/edit/delete task functionality
- Mark complete with stamp animation
- Drag-and-drop reordering
- LocalStorage persistence
- Warm paper-like aesthetic with handwriting fonts
- Satisfying tactile interactions (crumpling, writing sounds)

Step 4: Create Plan

/speckit.plan Use:
- Pure HTML5/CSS3/JavaScript (no frameworks)
- LocalStorage for data persistence
- Google Fonts (Caveat handwriting)
- CSS animations for tactile effects
- Mobile-responsive design
- Fully offline-capable

Step 5: Generate & Execute Tasks

/speckit.tasks    # Creates task breakdown
/speckit.implement  # Executes all tasks

Benefits of Spec-Kit

✅ Structured Process: No more vague prompts ✅ Quality Assurance: Built-in checklists and validation ✅ Parallel Exploration: Multiple implementation paths ✅ Documentation: Automatic spec generation ✅ Reproducible: Same workflow for every project ✅ AI-Optimized: Commands designed for Claude Code

Tips for Success

Be Specific: The more detailed your spec, the better the output
Iterate: Don't expect perfection on first try
Use Clarify: Address ambiguities before planning
Follow Order: constitution → specify → plan → tasks → implement
Validate: Use /speckit.checklist before declaring done

Spec-Kit Documentation

Main Repo: https://github.com/github/spec-kit
Detailed Guide: https://github.com/github/spec-kit/blob/main/spec-driven.md
Video Overview: https://www.youtube.com/watch?v=a9eR1xsfvHg

Integration with This Skill

This Claude Code skill includes Spec-Kit knowledge! You can:

# Query Spec-Kit documentation
claude-code query "spec-kit"
claude-code query "spec-driven development"
claude-code query "specify CLI"

# Get workflow guidance
claude-code docs spec-workflow

Example: Starting a New Project

# 1. Install spec-kit (one-time)
uv tool install specify-cli --from git+https://github.com/github/spec-kit.git

# 2. Initialize project
specify init my-new-app --ai claude

# 3. In Claude Code, use the commands:
/speckit.constitution  # Set design principles
/speckit.specify      # Define your app
/speckit.plan         # Choose tech stack
/speckit.tasks        # Get task list
/speckit.implement     # Build it!

Resources:

Spec-Kit GitHub: https://github.com/github/spec-kit
This Skill's Repo: https://github.com/hw10181913/openclaw-skill-claude-code
Documentation: https://code.claude.com/docs

claude-code

Claude Code Integration

What You Can Do

📚 Documentation Queries

🤖 Subagent Management

🛠️ Development Workflows

Usage Examples

Query Documentation

Execute Coding Task

List Available Commands

Available Commands

query

task

docs

info

Integration with OpenClaw

Example Workflows

Complex Bug Fix

New Feature Development

Code Review Automation

Configuration

Environment Variables

Models

Subagent Limits

Notes

See Also

🚀 Spec-Driven Development with Spec-Kit

What is Spec-Driven Development?

Spec-Kit Core Philosophy

Spec-Kit Workflow (7 Steps)

Step 1: Install Spec-Kit CLI

Step 2: Establish Project Principles

Step 3: Create the Specification

Step 4: Clarify Requirements (Optional but Recommended)

Step 5: Create Technical Plan

Step 6: Generate Tasks

Step 7: Execute Implementation

Available Slash Commands

Core Commands (Essential)

Optional Commands (Enhanced Quality)

Project Structure (After specify init)

Real-World Example: Skeuomorphic Todo App

Step 1: Initialize Project

Step 2: Create Constitution

Step 3: Specify Requirements

Step 4: Create Plan

Step 5: Generate & Execute Tasks

Benefits of Spec-Kit

Tips for Success

Spec-Kit Documentation

Integration with This Skill

Example: Starting a New Project

Project Structure (After `specify init`)