How to Create Claude Code Plugins

If you work with AI assistants — especially Claude Code — you probably already know their potential for accelerating your workflow. But did you know you can multiply that potential by creating your own plugins? In this article I’ll explain how, and why you should consider it.

What Is a Plugin for an AI Assistant?

Imagine you have a very capable assistant, but one that doesn’t know the specifics of your company, your tech stack, or your particular workflows. A plugin is like a personalized instruction manual you hand to that assistant so it knows exactly how to help you in specific contexts.

Technically speaking, a plugin is a set of:

Skills: Specialized commands the assistant can execute
Agents: Specialized processes with specific tools and context (personality)
Configurations: Predefined rules and behaviors

Why Create Your Own Plugins?

For Developers

Automating repetitive tasks: Turn 15-step workflows into a single command
Team consistency: Everyone uses the same practices and standards
Codified knowledge: Best practices become documented and executable
Integration with internal tools: Connect with Jira, Confluence, internal APIs, etc.

For the Organization

Consistent quality: Code reviews, commits, and PRs follow defined standards
Preserved knowledge: “How we do things here” gets captured

Basic Plugin Structure

A typical plugin follows this directory structure:

my-plugin/
├── plugin.json           # Main configuration
├── AGENTS.md             # Global instructions for the assistant
├── skills/               # Available skills/commands
│   ├── my-skill.md
│   └── another-skill.md
├── agents/               # Specialized agents
│   └── my-agent.md
└── commands/             # Additional commands
    └── my-command.md

Step 1: Create the Configuration File

The plugin.json file defines the identity and components of your plugin:

{
  "name": "my-plugin",
  "version": "1.0.0",
  "description": "Custom plugin for my team",
  "skills": [
    "skills/deploy.md",
    "skills/code-review.md"
  ],
  "agents": [
    "agents/frontend-expert.md"
  ]
}

This file acts as the index of everything your plugin offers.

Step 2: Define Skills

A skill is an invocable command the assistant recognizes. It’s defined in a markdown file with a YAML frontmatter:

---
name: deploy
description: "Deploys the application to the specified environment"
invocation: user
arguments:
  - name: environment
    description: "Target environment (dev, staging, prod)"
    required: true
---

Followed by the content with instructions:

# Deployment Instructions

When the user invokes this skill:

1. Verify that the current branch is clean (no pending changes)
2. Run tests before proceeding
3. Based on the specified environment:
   - **dev**: Deploy directly
   - **staging**: Requires tests to pass at 100%
   - **prod**: Requires explicit user approval

The assistant now understands what to do when you type /deploy staging.

Step 3: Create Specialized Agents

Agents are like virtual experts with specific knowledge. The frontmatter defines their capabilities:

---
name: frontend-expert
description: "Expert in React and the company's Design System" # The more specific, the better.
model: sonnet
tools:
  - Read
  - Edit
  - Write
  - Glob
  - Grep
  - Bash
---

And the content defines their personality and knowledge:

# Frontend Expert Agent

You are a senior frontend developer specialized in:

- React 18+ with TypeScript
- Our internal Design System
- Accessibility patterns (WCAG 2.1)
- Internationalization with react-intl

## Project Conventions

- Use functional components with hooks
- Styles go in `.module.scss` files
- Each component must have unit tests

## When Reviewing Code

Always verify:
1. Correct use of Design System tokens
2. Internationalized strings (never hardcoded)
3. Appropriate handling of loading and error states
4. Accessibility (aria-labels, roles, etc.)

Step 4: Document the Global Context

The AGENTS.md file at the root provides context that all agents and skills inherit:

# Project Context

## Tech Stack
- Frontend: React 18, TypeScript 5, SCSS Modules
- Backend: Node.js, Express, PostgreSQL
- CI/CD: GitHub Actions
- Cloud: AWS (ECS, RDS, S3)

## Repository Structure
- `/src/components` - React components
- `/src/services` - Business logic
- `/src/api` - Backend endpoints
- `/tests` - Unit and integration tests

## Team Standards
- Commits in English, following Conventional Commits
- PRs require at least 1 approval
- Minimum coverage: 80%

Step 5: Integration with External Tools

The real power emerges when integrating with your tools. For example, a skill that connects with Jira:

# Jira Task Implementation Flow

1. **Get context**: Read the ticket details from Jira
2. **Analyze requirements**: Identify which files to modify
3. **Implement**: Make the necessary changes
4. **Verify**: Run tests and linting
5. **Document**: Create the PR with a detailed description
6. **Update Jira**: Move the ticket to "Code Review"

This skill uses the Jira API to read the description, acceptance criteria, update the ticket status, and add the PR link as a comment.

Practical Example: Code Review Plugin

Let’s look at a complete example of a useful skill for any team:

---
name: code-review
description: "Performs an exhaustive code review"
invocation: user
---

# Automated Code Review

## Review Process

### 1. Security Analysis
- Search for OWASP Top 10 vulnerabilities
- Verify secure handling of sensitive data
- Review input validation

### 2. Code Quality
- Cyclomatic complexity
- Code duplication
- Naming conventions

### 3. Architecture
- Separation of concerns
- Appropriate patterns
- Error handling

### 4. Testing
- Edge case coverage
- Appropriate mocks
- Readable tests

## Output Format

Present findings organized by severity:
- 🔴 **Critical**: Must be fixed before merge
- 🟡 **Important**: Recommended to fix
- 🟢 **Suggestion**: Optional improvement

Potential and Advanced Use Cases

Orchestrating Multiple Agents

You can create skills that coordinate several agents working in parallel:

User: /implement-feature social-login

The system automatically:
1. Backend Agent → Creates OAuth endpoints
2. Frontend Agent → Builds the login UI
3. QA Agent → Writes e2e tests
4. Docs Agent → Updates documentation

All in parallel, reducing development time.

Complete Workflows

A single command can chain an entire flow:

/full-feature "Add search filter"

1. Create branch from main
2. Implement the functionality
3. Write tests
4. Run linting and formatting
5. Create commit with appropriate message
6. Open PR with detailed description
7. Request reviewers automatically

Important Considerations

Security

Never include credentials in plugin files
Use environment variables for tokens and secrets
Review agent permissions (which tools they can use)

Maintenance

Version your plugin alongside your code
Document changes in a CHANGELOG
Test skills before sharing with the team

Limitations

Plugins inherit the limitations of the base assistant
Very long tasks may require human intervention
AI can make mistakes; always review critical output
Be mindful of token consumption — I strongly recommend optimizing by model

Recommendations

You can take a look at this open-source plugin as a guide: oh-my-claudecode.

Conclusion

Creating plugins for AI terminal assistants is an investment that pays off quickly. You turn tribal knowledge into executable automation, reduce human error, and significantly accelerate team workflows.

Start simple: identify a repetitive task you do frequently and create a skill for it. Then iterate and expand based on your needs.