A unified development plugin for Claude Code with essential commands, skills, and specialized agents, all accessible under the ce namespace.

Quick workflows for everyday development tasks, accessed with /ce: prefix:

Reusable development patterns, accessed with ce: prefix:

Testing & Quality:

Debugging & Problem Solving:

Code Quality:

Planning & Execution:

Documentation & Writing:

Data & Infrastructure:

Meta Skills:

Expert AI personas for complex work, accessed with @ce: prefix:

• Session start - Auto-detects project tooling (linters, formatters, type checkers) and injects available skills
• Notifications - Cross-platform alerts when Claude needs input, with git branch info (macOS + Linux)

You need Claude Code installed. If you don't have it yet, head to claude.com/product/claude-code.

1. Add this marketplace to Claude Code:

/plugin marketplace add https://github.com/rileyhilliard/claude-essentials

2. Install the ce plugin:

/plugin install ce

That's it! You now have access to all commands, skills, and agents under the ce namespace.

Start Claude Code and try these:

# Start Claude Code
claude

# Try a quick command
/ce:explain README.md

# Use a skill
ce:writing-tests

# Use a skill
ce:architecting-systems

The /ce:init command sets up your repository with Claude Code configuration that follows best practices. This is the recommended first step when starting work on any project.

Fresh repositories (no .claude/ directory):

1. Detects your project stack (Python, TypeScript, Rust, Go, etc.)
2. Generates a complete .claude/ configuration:

.claude/
├── CLAUDE.md           # Project overview, architecture, quick commands
├── settings.json       # Permissions tailored to your stack
└── rules/
    ├── testing.md          # References ce:writing-tests
    ├── error-handling.md   # References ce:handling-errors
    ├── debugging.md        # References ce:systematic-debugging
    ├── verification.md     # References ce:verification-before-completion
    └── {stack}/            # Stack-specific rules (python/, frontend/, etc.)

Existing configurations (.claude/ already exists):

1. Audits your current setup against best practices
2. Identifies missing skill references in rules
3. Suggests permission and rule improvements
4. Offers to apply fixes with your confirmation

# Initialize a new project
/ce:init

# Audit an existing configuration
/ce:init --audit

# Force regenerate (overwrites existing)
/ce:init --force

The generated configuration:

• Progressive disclosure - Rules stay concise (<100 lines), reference ce:* skills for depth, use references/ subdirectories for domain-specific details
• Rules reference ce:* skills - Don't duplicate content, point to proven patterns
• Permissions are stack-aware - Python projects get uv, pytest; Node gets npm, bun, etc.
• Safety defaults included - Blocks rm -rf, force pushes, hard resets
• Path-scoped rules - Activate only when working in relevant files

Progressive disclosure structure:

rules/
├── testing.md              # ~50 lines, points to ce:writing-tests
└── api/
    ├── conventions.md      # ~100 lines, overview
    └── references/         # Loaded on-demand
        ├── errors.md       # Detailed error patterns
        └── pagination.md   # Pagination strategies

This keeps context small while maintaining depth. Claude loads reference files only when needed.

Based on Claude platform best practices.

Bootstrap a new project:

cd my-project
/ce:init
# Review the generated config, confirm, done

Fix failing tests:

/ce:test
# If complex, escalate:
ce:systematic-debugging

Review before merge:

/ce:review
# Review findings are tracked as a checklist, fix issues, then:
/ce:commit

Plan and build a feature:

# Define the product spec first:
ce:planning-products
# Then create a technical plan:
ce:writing-plans
# Then execute:
/ce:execute

Clean up legacy code:

/ce:explain src/legacy/payment-processor.js
ce:refactoring-code

Commands vs Skills vs Agents:

• Commands (/ce:test, /ce:review) are quick keyboard shortcuts for routine tasks
• Skills (ce:writing-tests) are reusable workflows that guide specific development patterns
• Agents (@ce:code-reviewer) are expert personas for complex, multi-step work

Use commands for quick actions, skills for following proven patterns, and agents when you need specialized expertise.

All components are just markdown files organized in directories. Want to customize? Edit them directly in ~/.claude/plugins/ce/.

Add a markdown file to ~/.claude/plugins/ce/commands/:

---
description: Your command description
argument-hint: "[optional-arg]"
allowed-tools: Bash, Read
---

Your command instructions here.

This will be accessible as /ce:your-command.

Add a directory with SKILL.md to ~/.claude/plugins/ce/skills/:

---
name: my-skill
description: What this skill does and when to use it
---

# Skill Instructions

Your skill workflow here.

This will be accessible as ce:my-skill.

Add a markdown file to ~/.claude/plugins/ce/agents/:

---
name: my-agent
description: Expert at specific domain
tools: Read, Grep, Glob, Bash
color: blue
---

Your agent personality and workflow here.

This will be accessible as @ce:my-agent.

~/.claude/
├── CLAUDE.md              # Communication guidelines (copy here manually)
└── plugins/
    └── ce/
        ├── .claude-plugin/
        │   └── plugin.json       # Plugin metadata
        ├── commands/             # 9 commands (/ce:test, /ce:review, /ce:commit, etc.)
        ├── skills/               # 24 skills (ce:writing-tests, ce:planning-products, etc.)
        ├── agents/               # 4 agents (@ce:code-reviewer, @ce:haiku, etc.)
        └── hooks/                # Session automation

Commands accept arguments: Most commands work with optional parameters.

/ce:test pytest tests/unit
/ce:explain AuthController

Skills are for learning: Invoke a skill to understand a pattern, then apply it.

ce:writing-tests
# Follow the guidance to write tests

Agents need context: Give agents rich context for better results.

# Vague
ce:architecting-systems help with authentication

# Better
ce:architecting-systems We need OAuth2 + JWT authentication for a React SPA with Node backend. 50k users.

Run tests first: Use /ce:test before committing to catch issues early.

• Extending for Projects - How to wrap and extend ce for your specific codebase

Found a bug? Have an idea? Contributions welcome.

1. Fork this repo
2. Create a feature branch
3. Test your changes locally
4. Submit a PR with details

Ideas for contributions:

• New commands for common workflows
• Additional skills for specific patterns
• Specialized agents for other domains
• Documentation improvements

• Claude Code
• Claude API Docs
• Model Context Protocol

MIT - Use it, share it, make it better.