Skills et agents personnalisés : étendez les capacités de Claude Code

Introduction aux skills

Pourquoi les skills sont importants

La hiérarchie des skills

.claude/
├── CLAUDE.md            # Contexte au niveau du projet
├── settings.json        # Configuration
└── skills/              # Répertoire des skills
    ├── code-review/
    │   └── SKILL.md
    ├── security-audit/
    │   └── SKILL.md
    └── test-generator/
        └── SKILL.md

Architecture des skills

Chaque skill est défini par un fichier SKILL.md avec une structure spécifique :

Anatomie du SKILL.md

---
name: security-audit
description: Comprehensive security analysis following OWASP standards
allowed-tools: Read, Grep, Glob, Bash
context: fork
model: sonnet
---

# Security Audit Skill

You are a security expert...

[Detailed instructions]

Champs du frontmatter

Modes de contexte

Constructeur interactif de skills

Utilisez cet assistant pour créer votre propre skill personnalisé. Choisissez un type, configurez les options et générez un fichier SKILL.md complet :

Skills intégrés

Claude Code est livré avec plusieurs skills pré-construits que vous pouvez utiliser immédiatement ou personnaliser :

1. Skill de revue de code

---
name: code-review
description: Thorough code review with actionable feedback
allowed-tools: Read, Grep, Glob
context: fork
---

# Code Review Skill

You are a senior engineer conducting a thorough code review.

## Review Checklist
- [ ] Logic correctness
- [ ] Error handling
- [ ] Performance implications
- [ ] Security considerations
- [ ] Test coverage
- [ ] Code style/conventions

## Severity Levels
- 🔴 Critical: Must fix before merge
- 🟡 Warning: Should address
- 🟢 Suggestion: Nice to have
- ℹ️ Info: FYI only

## Output Format
For each finding:
1. File and line number
2. Severity level
3. Issue description
4. Suggested fix with code example

2. Skill de génération de tests

---
name: test-generator
description: Generate comprehensive test suites with TDD methodology
allowed-tools: Read, Write, Grep, Bash
context: fork
---

# Test Generator Skill

You are a testing expert practicing TDD methodology.

## Test Types to Generate
1. **Unit Tests**: Pure function testing
2. **Integration Tests**: Component interaction
3. **Edge Cases**: Boundary conditions
4. **Error Cases**: Expected failures

## Framework Detection
- React: Jest + React Testing Library
- Node: Vitest or Jest
- Python: pytest
- Go: testing package

## Naming Convention
`test_[function_name]_[scenario]_[expected_result]`

Example:
```python
def test_validate_email_empty_string_returns_false():
    assert validate_email("") == False

Coverage Goals

• →Happy path: 100%
• →Edge cases: 80%
• →Error handling: 90%

### 3. Skill de documentation

```markdown
---
name: documentation
description: Generate comprehensive documentation for any codebase
allowed-tools: Read, Write, Grep, Glob
context: fork
---

# Documentation Skill

You are a technical writer creating clear, comprehensive documentation.

## Documentation Types
1. **README.md**: Project overview, setup, usage
2. **API Docs**: Endpoint reference with examples
3. **Code Docs**: JSDoc/docstrings
4. **Guides**: How-to tutorials

## Quality Checklist
- [ ] Clear purpose statement
- [ ] Prerequisites listed
- [ ] Step-by-step instructions
- [ ] Code examples for key features
- [ ] Troubleshooting section
- [ ] Contribution guidelines

## Style Guide
- Use active voice
- Keep sentences short
- Include code examples
- Add diagrams for complex flows
- Link to related resources

Patterns d'agents

Combinez les skills en agents puissants pour des workflows complexes :

Pattern 1 : Pipeline séquentiel

# PR Review Agent

## Steps
1. Run `code-review` skill on changed files
2. Run `security-audit` skill on changed files  
3. Run `test-generator` for new code paths
4. Compile results into PR comment format

## Configuration
```json
{
  "name": "pr-review-agent",
  "skills": ["code-review", "security-audit", "test-generator"],
  "mode": "sequential"
}

Pattern 2 : Analyse parallèle

# Codebase Health Check Agent

## Parallel Skills
- Performance analyzer
- Security auditor
- Dependency checker
- Code quality scorer

## Aggregation
Combine all results into unified health report with scores.

Pattern 3 : Branchement conditionnel

# Smart Review Agent

## Logic
IF file is `.py`:
  → Run Python-specific review
ELIF file is `.tsx`:
  → Run React + TypeScript review
ELIF file is `.sql`:
  → Run SQL security review
ELSE:
  → Run generic code review

Techniques avancées

1. Composition de skills

Créez des méta-skills qui combinent d'autres skills :

---
name: full-audit
description: Complete codebase audit combining multiple skills
allowed-tools: Task, Read, Grep
---

# Full Audit Meta-Skill

## Execution Order
1. Spawn `security-audit` task
2. Spawn `performance-review` task  
3. Spawn `accessibility-check` task
4. Await all results
5. Generate unified report

## Usage
Use the `Task` tool to spawn sub-agents:
- Each skill runs in forked context
- Results are collected and synthesized
- Final report highlights critical issues first

2. Chargement dynamique de skills

Chargez les skills en fonction du type de projet :

---
name: project-analyzer
description: Detect project type and load appropriate skills
allowed-tools: Read, Glob, Task
---

# Project Analyzer

## Detection Logic
1. Check for package.json → Load Node.js skills
2. Check for requirements.txt → Load Python skills
3. Check for go.mod → Load Go skills
4. Check for Cargo.toml → Load Rust skills

## Per-Project Skills
- Node.js: eslint-check, npm-audit, jest-runner
- Python: pylint-check, bandit-audit, pytest-runner
- Go: golint-check, gosec-audit, gotest-runner

3. Chaînage de skills avec état

Transmettez l'état entre les skills :

---
name: refactor-pipeline
description: Multi-stage refactoring with state preservation
allowed-tools: Read, Write, Edit, Task
---

# Refactor Pipeline

## Stage 1: Analysis
- Identify code smells
- Map dependencies
- Output: analysis.json

## Stage 2: Planning
- Input: analysis.json
- Generate refactor plan
- Output: plan.json

## Stage 3: Execution
- Input: plan.json
- Apply refactoring
- Run tests after each change

## Stage 4: Verification
- Run full test suite
- Compare before/after metrics
- Generate summary report

4. Skills avec interaction utilisateur

Skills qui demandent des informations à l'utilisateur :

---
name: interactive-setup
description: Guided project setup with user prompts
allowed-tools: Read, Write, Bash
---

# Interactive Setup Skill

## Flow
1. Detect project type
2. Ask: "Which testing framework?"
   - Options: Jest, Vitest, Mocha
3. Ask: "Include TypeScript?"
   - Options: Yes, No
4. Ask: "Add CI/CD?"
   - Options: GitHub Actions, GitLab CI, None

## Based on answers:
- Generate appropriate configuration files
- Install dependencies
- Create starter tests

Bonnes pratiques

À faire ✅

1. →Gardez les skills ciblés — Responsabilité unique
2. →Incluez des exemples — Montrez les entrées/sorties attendues
3. →Définissez des sorties claires — Spécifiez les attentes de format
4. →Versionnez vos skills — Suivez les changements dans git
5. →Testez régulièrement les skills — Validez avec des cas d'utilisation réels

À ne pas faire ❌

1. →Ne codez pas les chemins en dur — Utilisez des patterns et des chemins relatifs
2. →N'accordez pas d'outils inutiles — Principe du moindre privilège
3. →Ne rendez pas les skills trop génériques — Le spécifique est préférable
4. →N'oubliez pas la description — Les autres doivent comprendre
5. →N'oubliez pas les cas limites — Définissez le comportement pour les entrées inhabituelles

Testez vos connaissances

Prochaines étapes

Maintenant que vous savez créer des skills personnalisés :

1. →Maîtrisez les hooks — Déclenchez automatiquement les skills avec des hooks d'événements
2. →Explorez les serveurs MCP — Connectez les skills à des services externes
3. →Construisez des workflows — Orchestrez des pipelines multi-outils