---
name: implement
description: Feature and code implementation with systematic development workflow
---

# /implement - Feature Implementation

Systematic code implementation with quality gates and best practices.

## When to Use

- Feature development for components, APIs, or services
- Code implementation with framework-specific requirements
- Multi-domain development requiring coordinated expertise
- Implementation projects requiring testing and validation

## Usage

```
/skill implement [feature-description] [--type component|api|service] [--with-tests]
```

## Workflow

### 1. Analyze (10%)
- Examine implementation requirements
- Detect technology context and frameworks
- Identify existing patterns and conventions

### 2. Plan (15%)
- Choose implementation approach
- Identify files to create/modify
- Define testing strategy

### 3. Implement (50%)
- Create implementation code with best practices
- Follow existing project conventions
- Apply framework-specific patterns

### 4. Validate (15%)
- Run linting and type checks
- Apply security validation
- Verify against requirements

### 5. Integrate (10%)
- Update related documentation
- Provide testing recommendations
- Ensure proper imports/exports

## Implementation Principles

### Code Quality
- Follow existing project conventions
- Use meaningful names and clear structure
- Add necessary error handling
- Include inline documentation for complex logic

### Testing Integration
- Write tests alongside implementation when `--with-tests`
- Follow existing test patterns
- Cover edge cases and error scenarios

### Security
- Validate all inputs
- Use parameterized queries
- Avoid hardcoded secrets
- Follow OWASP guidelines

## Examples

### Component Implementation
```
/skill implement user profile component --type component --with-tests
# Creates component with tests following project patterns
```

### API Service
```
/skill implement user authentication API --type api --with-tests
# Creates API endpoints with proper validation and tests
```

### Full Feature
```
/skill implement payment processing --type service --with-tests
# Multi-file implementation with complete test coverage
```

## Output

Implementation includes:
- Source files with implementation code
- Test files (if --with-tests)
- Updated imports/exports
- Documentation of key decisions

## Boundaries

**Will:**
- Implement features following project conventions
- Apply framework-specific best practices
- Integrate testing and validation

**Will Not:**
- Make architectural decisions without confirmation
- Implement features conflicting with existing patterns
- Skip validation and quality gates
