Content
# AI MAX
> This is a secondary development based on [everything-claude-code](https://github.com/affaan-m/everything-claude-code), providing a one-click npm installation method, and the protocol follows MIT.
**Claude Code enhanced configuration, out of the box.**
This repository contains production-grade agents, skills, hooks, commands, rules, and MCP configurations to help you quickly improve your Claude Code experience.
---
## Quick Start
```bash
# Global installation
npm install -g aimax
# Execute aimax to enhance Claude code IQ
aimax # Execute aimax in the terminal for interactive installation
# Claude Code Usage
/aimax:auto your question # Automatically select the optimal aimax instruction
```
The CLI provides an interactive interface that allows you to select the components to install:
- **Agents** - Dedicated sub-agents (planner, architect, tdd-guide, etc.)
- **Rules** - Guidelines to be followed (security, testing, coding-style, etc.)
- **Commands** - Slash commands (/aimax:plan, /aimax:tdd, /aimax:code-review, etc.)
- **Skills** - Workflow definitions and domain knowledge
---
## Slash Command Usage Guide
After installing AI MAX, you can use the following slash commands in Claude Code. Just enter `/aimax:command name` plus your requirements.
### Quick Reference
| Command | Purpose | Example |
|------|------|------|
| `/aimax:auto` | Smartly choose the most appropriate command | `/aimax:auto help me fix this bug` |
| `/aimax:plan` | Function planning and implementation plan | `/aimax:plan add user login function` |
| `/aimax:tdd` | Test-driven development | `/aimax:tdd implement shopping cart function` |
| `/aimax:code-review` | Code quality and security review | `/aimax:code-review` |
| `/aimax:build-fix` | Fix build/type errors | `/aimax:build-fix` |
| `/aimax:e2e` | End-to-end test generation | `/aimax:e2e test user registration process` |
| `/aimax:test-coverage` | Test coverage analysis | `/aimax:test-coverage` |
| `/aimax:refactor-clean` | Code refactoring and cleanup | `/aimax:refactor-clean optimize this module` |
| `/aimax:update-docs` | Update project documentation | `/aimax:update-docs` |
| `/aimax:update-codemaps` | Update code architecture diagram | `/aimax:update-codemaps` |
---
### Detailed explanation
#### `/aimax:auto` - Smart Command Selector
Not sure which command to use? Use `/aimax:auto`, which automatically selects the most appropriate command based on your description.
```
/aimax:auto My build failed, there is a type error
→ Automatically select /aimax:build-fix
/aimax:auto Help me write a new feature
→ Automatically select /aimax:plan
/aimax:auto Check if there are any security issues in the code
→ Automatically select /aimax:code-review
```
#### `/aimax:plan` - Implementation Planning
Create a detailed implementation plan before writing code. Applicable to:
- New feature development
- Major architectural changes
- Complex refactoring work
```
/aimax:plan Add real-time notification function
```
AI will analyze requirements, identify risks, create step-by-step plans, **and wait for your confirmation before starting to code**.
#### `/aimax:tdd` - Test Driven Development
Enforce TDD workflow: write tests first, then write implementation. Applicable to:
- New feature implementation
- Bug fixes
- Critical business logic
```
/aimax:tdd Implement price calculator
```
Follow the **Red-Green-Refactor** cycle to ensure 80%+ test coverage.
#### `/aimax:code-review` - Code Review
Conduct a comprehensive review of uncommitted changes, checking:
- 🔴 Security issues (credential leakage, SQL injection, XSS)
- 🟠 Code quality (functions too long, nesting too deep)
- 🟡 Best practices (mutable patterns, missing tests)
```
/aimax:code-review
```
#### `/aimax:build-fix` - Build Error Fix
Quickly fix build and type errors. Applicable to:
- TypeScript type errors
- Compilation failure
- Build process issues
```
/aimax:build-fix
```
#### `/aimax:e2e` - End-to-End Testing
Generate and run E2E tests using Playwright. Applicable to:
- User flow testing
- Cross-page function verification
- UI automation testing
```
/aimax:e2e Test the complete process of user login to placing an order
```
#### `/aimax:test-coverage` - Coverage Analysis
Analyze test coverage to identify uncovered code.
```
/aimax:test-coverage
```
#### `/aimax:refactor-clean` - Refactor Cleanup
Remove dead code, optimize structure, eliminate duplication.
```
/aimax:refactor-clean Clean up unused code in this module
```
#### `/aimax:update-docs` - Documentation Update
Update project documentation, README, API documentation.
```
/aimax:update-docs
```
#### `/aimax:update-codemaps` - Architecture Diagram Update
Generate or update code architecture diagrams and module dependency diagrams.
```
/aimax:update-codemaps
```
### Recommended Workflow
```
1. /aimax:plan → Plan function
2. /aimax:tdd → Test-driven implementation
3. /aimax:code-review → Review code
4. /aimax:build-fix → Fix build issues (if any)
5. git commit → Commit code
```
---
## Core Concepts
### Agents
Sub-agents handle delegated tasks with a limited scope. Example:
```markdown
---
name: code-reviewer
description: Review code quality, security, and maintainability
tools: Read, Grep, Glob, Bash
model: opus
---
You are a senior code reviewer...
```
### Skills
Skills are workflow definitions called by commands or agents:
```markdown
# TDD Workflow
1. Define the interface first
2. Write failing tests (red light)
3. Implement minimal code (green light)
4. Refactor (improve)
5. Verify 80%+ coverage
```
### Hooks
Hooks are triggered on tool events. Example - warning console.log:
```json
{
"matcher": "tool == \"Edit\" && tool_input.file_path matches \"\\\\.(ts|tsx|js|jsx)$\"",
"hooks": [{
"type": "command",
"command": "#!/bin/bash\ngrep -n 'console\\.log' \"$file_path\" && echo '[Hook] Remove console.log' >&2"
}]
}
```
### Rules
Rules are guidelines that must always be followed. Keep it modular:
```
~/.claude/rules/
security.md # Prohibit hard-coded keys
coding-style.md # Immutability, file limits
testing.md # TDD, coverage requirements
```
---
## Important Notes
### Context Window Management
**Key:** Do not enable all MCPs at the same time. Enabling too many tools may shrink your 200k context window to 70k.
Rule of thumb:
- Configure 20-30 MCPs
- Enable no more than 10 per project
- No more than 80 active tools
Use `disabledMcpServers` in the project configuration to disable unused tools.
### Customization
These configurations are suitable for my workflow. You should:
1. Start with what resonates with you
2. Modify according to your technology stack
3. Remove what you don't use
4. Add your own patterns
---
## Repository Content
```
aimax/
|-- agents/ # Dedicated sub-agents for task delegation
| |-- planner.md # Function implementation planning
| |-- architect.md # System design decisions
| |-- tdd-guide.md # Test-driven development
| |-- code-reviewer.md # Quality and security review
| |-- security-reviewer.md # Vulnerability analysis
| |-- build-error-resolver.md
| |-- e2e-runner.md # Playwright E2E testing
| |-- refactor-cleaner.md # Dead code cleanup
| |-- doc-updater.md # Documentation synchronization
|
|-- skills/ # Workflow definitions and domain knowledge
| |-- coding-standards.md # Programming language best practices
| |-- backend-patterns.md # API, database, cache patterns
| |-- frontend-patterns.md # React, Next.js patterns
| |-- project-guidelines-example.md # Project-specific skill examples
| |-- tdd-workflow/ # TDD methodology
| |-- security-review/ # Security checklist
| |-- clickhouse-io.md # ClickHouse analysis
|
|-- commands/ # Slash commands for quick execution
| |-- tdd.md # /aimax:tdd - Test-driven development
| |-- plan.md # /aimax:plan - Implementation planning
| |-- e2e.md # /aimax:e2e - E2E test generation
| |-- code-review.md # /aimax:code-review - Quality review
| |-- build-fix.md # /aimax:build-fix - Fix build errors
| |-- refactor-clean.md # /aimax:refactor-clean - Dead code removal
| |-- test-coverage.md # /aimax:test-coverage - Coverage analysis
| |-- update-codemaps.md # /aimax:update-codemaps - Refresh documentation
| |-- update-docs.md # /aimax:update-docs - Synchronize documentation
|
|-- rules/ # Guidelines to be followed
| |-- security.md # Mandatory security checks
| |-- coding-style.md # Immutability, file organization
| |-- testing.md # TDD, 80% coverage requirements
| |-- git-workflow.md # Commit format, PR process
| |-- agents.md # When to delegate to sub-agents
| |-- performance.md # Model selection, context management
| |-- patterns.md # API response format, hooks
| |-- hooks.md # Hook documentation
|
|-- hooks/ # Trigger-based automation
| |-- hooks.json # PreToolUse, PostToolUse, Stop hooks
|
|-- mcp-configs/ # MCP Server configuration
| |-- mcp-servers.json # GitHub, Supabase, Vercel, Railway, etc.
|
|-- plugins/ # Plugin ecosystem documentation
| |-- README.md # Plugin, market, skill guide
|
|-- examples/ # Example configuration
|-- CLAUDE.md # Project-level configuration example
|-- user-CLAUDE.md # User-level configuration example (~/.claude/CLAUDE.md)
|-- statusline.json # Custom status bar configuration
```
---
## License
MIT - Free to use, modify as needed, please contribute back if you can.
---
**Star this repository if it helps. Read the guide. Build great things.**
