How to Contribute to the Everything Claude Code Project: A Complete Guide

To contribute to the Everything Claude Code (ECC) project, fork the repository, create a descriptive feature branch, add your skill or agent following the established templates, ensure test coverage remains at or above 80%, and submit a pull request using conventional commit format.

The Everything Claude Code project is an open-source collection of agents, skills, commands, and hook workflows designed to extend Claude Code functionality. Whether you want to add a new automation skill or define a custom agent workflow, the contribution process follows strict quality standards documented in CONTRIBUTING.md and AGENTS.md to maintain security, test coverage, and immutability principles.

Fork and Clone the Repository

Start by creating your own copy of the codebase. Navigate to the affaan-m/everything-claude-code repository on GitHub and click Fork. Then clone your fork locally:

git clone https://github.com/<your-username>/everything-claude-code.git
cd everything-claude-code

This establishes your local development environment where you can create isolated branches and run the full test suite.

Create a Feature Branch

Never commit directly to the main branch. Instead, create a descriptive branch using the prefixes defined in the Git workflow:

git checkout -b feat/add-my-skill

Valid prefixes include feat/ for new features, fix/ for bug fixes, and docs/ for documentation updates. This naming convention helps maintainers quickly identify the purpose of your contribution during review.

Add or Modify Components

ECC organizes contributions into four component types. Choose the appropriate directory and template based on your contribution type.

Contributing Skills

Skills are reusable capabilities stored in the skills/ directory. To add a new skill:

1. Create a subdirectory under skills/ named for your skill (e.g., skills/my-awesome-skill/)
2. Add a SKILL.md file following the standard frontmatter format

Required SKILL.md structure:

---
name: my-awesome-skill
description: One-sentence summary shown in the skill list
origin: ECC
---

# My Awesome Skill

Brief overview of the problem this skill solves.

## Core Concepts

Explain the main patterns or guidelines.

## Code Examples

```typescript
// Example usage that can be run with Claude Code
function demo() {
  console.log('Hello, ECC!')
}

Best Practices

• ✅ Do this
• ❌ Don't do that

When to Use

Describe the scenarios where the skill is appropriate.

Reference the [`skills/coding-standards/SKILL.md`](https://github.com/affaan-m/everything-claude-code/blob/main/skills/coding-standards/SKILL.md) file for a complete example of the documentation standard.

### Contributing Agents

Agents define automated workflows and tool permissions. Create a Markdown file in `agents/` named `<agent-name>.md` following the **Agent Template** from [`CONTRIBUTING.md`](https://github.com/affaan-m/everything-claude-code/blob/main/CONTRIBUTING.md). Specify the exact tools your agent requires:

```markdown
---
name: tdd-guide
tools: ["Read", "Write", "Bash"]
---

# TDD Guide Agent

This agent enforces test-driven development workflows...

The agents/tdd-guide.md file demonstrates how to structure agent definitions with proper tool arrays like ["Read","Write","Bash"].

Contributing Hooks

Hooks intercept Claude Code events. Edit hooks/hooks.json to insert new hook objects using the JSON schema defined in the contribution guidelines. Hooks support pre-tool, post-tool, and session-level triggers.

Contributing Commands

Slash commands provide quick actions. Place new command definitions under commands/ (e.g., commands/my-command.md). The commands/commit.md file shows how commands integrate with git operations via Claude Code.

Testing Requirements

ECC enforces ≥80% overall test coverage across unit, integration, and E2E tests. Before submitting, run the verification suite:

npm install
npm test -- --coverage

The output must show coverage metrics meeting the threshold:

Coverage: 92.3% statements, 90.1% branches, 93.0% functions

The verification loop skill (skills/verification-loop/SKILL.md) automatically enforces these coverage gates. If your contribution drops coverage below 80%, add additional test cases to the tests/ directory.

Submit Your Contribution

Commit your changes using conventional commit format to maintain changelog consistency:

git add .
git commit -m "feat: add my-awesome-skill"
git push -u origin feat/add-my-skill

Open a pull request using the GitHub CLI or web interface. Include the required checklist from CONTRIBUTING.md:

gh pr create --title "feat: add my-awesome-skill" \
  --body "## Summary

- Introduces my-awesome-skill for X use-case.
- Includes unit tests and documentation.

## Type

- [x] Skill

## Testing

- npm test -- --coverage passes with 92% coverage.

## Checklist

- [x] Follows format guidelines
- [x] Tested with Claude Code
- [x] No sensitive info"

Maintainers review PRs against the core principles documented in AGENTS.md: agent-first architecture, test-driven development, security-first design, and immutability.

Summary

• Fork and clone the affaan-m/everything-claude-code repository to your GitHub account.
• Create descriptive branches using feat/, fix/, or docs/ prefixes before making changes.
• Follow templates when adding skills (SKILL.md), agents (Markdown with tool arrays), hooks (hooks/hooks.json), or commands (commands/).
• Maintain ≥80% test coverage by running npm test -- --coverage before submitting.
• Use conventional commits and detailed PR descriptions to streamline the review process.

Frequently Asked Questions

What is the minimum test coverage required for contributions?

The Everything Claude Code project requires ≥80% overall coverage across all test types (unit, integration, and E2E). Run npm test -- --coverage locally to verify your changes meet this threshold. The verification loop skill enforces this requirement automatically during CI checks.

Where can I find the templates for adding new skills or agents?

Reference the primary documentation files: CONTRIBUTING.md contains the full contribution guide with templates, while AGENTS.md outlines core principles and coding standards. For working examples, examine skills/coding-standards/SKILL.md for skill structure and agents/tdd-guide.md for agent configuration patterns.

How do I name my feature branches when contributing?

Use descriptive prefixes based on the change type: feat/ for new features, fix/ for bug fixes, docs/ for documentation, or refactor/ for code restructuring. For example, feat/add-aws-deployment-skill or fix/validation-hook-error. This convention appears in the Git workflow section of AGENTS.md.

Can I contribute hooks that modify Claude Code's default behavior?

Yes. Hooks are configured in hooks/hooks.json and support pre-tool, post-tool, and session-level interception. Follow the JSON schema documented in CONTRIBUTING.md when adding new hook definitions. Ensure your hook includes a concise description and respects the security-first principles outlined in the project guidelines.

{
  "mcpServers": {
    "instagit": {
      "command": "npx",
      "args": ["-y", "instagit@latest"]
    }
  }
}