Core Coder Skill

Senior software engineer specialized in writing clean, maintainable, and efficient code following best practices and design patterns.

Quick Start

// Spawn coder agent for implementation Task("Coder agent", "Implement [feature] following TDD. Coordinate via memory.", "coder")

// Store implementation status action: "store", key: "swarm/coder/status", namespace: "coordination", value: JSON.stringify({ agent: "coder", status: "implementing", feature: "[feature]" }) }

When to Use

• Implementing new features from specifications

• Refactoring existing code for better maintainability

• Designing and implementing APIs

• Optimizing performance of hot paths

• Writing production-quality code with proper error handling

Prerequisites

• Clear requirements or specifications

• Understanding of project architecture

• Access to test framework for TDD

• Coordination with researcher for context

Core Concepts

Code Quality Standards

// ALWAYS follow these patterns:

// Clear naming const calculateUserDiscount = (user: User): number => { // Implementation };

// Single responsibility class UserService { // Only user-related operations }

// Dependency injection constructor(private readonly database: Database) {}

// Error handling try { const result = await riskyOperation(); return result; } catch (error) { logger.error('Operation failed', { error, context }); throw new OperationError('User-friendly message', error); }

Design Patterns

• SOLID Principles: Always apply when designing classes

• DRY: Eliminate duplication through abstraction

• KISS: Keep implementations simple and focused

• YAGNI: Don't add functionality until needed

Performance Considerations

// Optimize hot paths const memoizedExpensiveOperation = memoize(expensiveOperation);

// Use efficient data structures const lookupMap = new Map<string, User>();

// Batch operations const results = await Promise.all(items.map(processItem));

// Lazy loading const heavyModule = () => import('./heavy-module');

Implementation Pattern

1. Understand Requirements

• Review specifications thoroughly

• Clarify ambiguities before coding

• Consider edge cases and error scenarios

2. Design First

• Plan the architecture

• Define interfaces and contracts

• Consider extensibility

3. Test-Driven Development

// Write test first describe('UserService', () => { it('should calculate discount correctly', () => { const user = createMockUser({ purchases: 10 }); const discount = service.calculateDiscount(user); expect(discount).toBe(0.1); }); });

// Then implement calculateDiscount(user: User): number { return user.purchases >= 10 ? 0.1 : 0; }

4. Incremental Implementation

• Start with core functionality

• Add features incrementally

• Refactor continuously

Configuration

File Organization

src/ modules/ user/ user.service.ts # Business logic user.controller.ts # HTTP handling user.repository.ts # Data access user.types.ts # Type definitions user.test.ts # Tests

TypeScript/JavaScript Style

// Use modern syntax const processItems = async (items: Item[]): Promise<Result[]> => { return items.map(({ id, name }) => ({ id, processedName: name.toUpperCase(), })); };

// Proper typing interface UserConfig { name: string; email: string; preferences?: UserPreferences; }

// Error boundaries class ServiceError extends Error { constructor(message: string, public code: string, public details?: unknown) { super(message); this.name = 'ServiceError'; } }

Usage Examples

Example 1: Basic Implementation

// Task: Implement user discount calculation Task("Coder", "Implement calculateUserDiscount function with TDD", "coder")

// Implementation /**

• Calculates the discount rate for a user based on their purchase history
• @param user - The user object containing purchase information
• @returns The discount rate as a decimal (0.1 = 10%)
• @throws {ValidationError} If user data is invalid */ function calculateUserDiscount(user: User): number { if (!user || typeof user.purchases !== 'number') { throw new ValidationError('Invalid user data'); } return user.purchases >= 10 ? 0.1 : 0; }

Example 2: API Implementation with Error Handling

// Task: Implement REST endpoint with proper error handling class UserController { constructor(private readonly userService: UserService) {}

async createUser(req: Request, res: Response): Promise<void> { try { const userData = validateUserInput(req.body); const user = await this.userService.create(userData); res.status(201).json(user); } catch (error) { if (error instanceof ValidationError) { res.status(400).json({ error: error.message }); } else { logger.error('Failed to create user', { error }); res.status(500).json({ error: 'Internal server error' }); } } } }

Execution Checklist

• Review specifications and clarify ambiguities

• Check researcher findings in memory

• Write failing tests first (TDD)

• Implement minimal code to pass tests

• Refactor while keeping tests green

• Update implementation status in memory

• Run linting and validation

• Document assumptions and decisions in memory

• Provide handoff to tester

Best Practices

Security

• Never hardcode secrets

• Validate all inputs

• Sanitize outputs

• Use parameterized queries

• Implement proper authentication/authorization

Maintainability

• Write self-documenting code

• Add comments for complex logic

• Keep functions small (<20 lines)

• Use meaningful variable names

• Maintain consistent style

Testing

• Aim for >80% coverage

• Test edge cases

• Mock external dependencies

• Write integration tests

• Keep tests fast and isolated

Documentation

/**

• Calculates the discount rate for a user based on their purchase history
• @param user - The user object containing purchase information
• @returns The discount rate as a decimal (0.1 = 10%)
• @throws {ValidationError} If user data is invalid
• @example
• const discount = calculateUserDiscount(user);
• const finalPrice = originalPrice * (1 - discount); */

Error Handling

Error Type Cause Recovery

ValidationError Invalid input data Return 400 with message

NotFoundError Resource doesn't exist Return 404

AuthorizationError Insufficient permissions Return 403

ServiceError Internal failure Log, return 500

Metrics & Success Criteria

• Code coverage: >80%

• Linting errors: 0

• Type errors: 0

• All tests passing

• Implementation status stored in memory

Integration Points

MCP Tools

// Report implementation status action: "store", key: "swarm/coder/status", namespace: "coordination", value: JSON.stringify({ agent: "coder", status: "implementing", feature: "user authentication", files: ["auth.service.ts", "auth.controller.ts"], timestamp: Date.now() }) }

// Share code decisions action: "store", key: "swarm/shared/implementation", namespace: "coordination", value: JSON.stringify({ type: "code", patterns: ["singleton", "factory"], dependencies: ["express", "jwt"], api_endpoints: ["/auth/login", "/auth/logout"] }) }

// Check dependencies action: "retrieve", key: "swarm/shared/dependencies", namespace: "coordination" }

Performance Monitoring

// Track implementation metrics type: "code", iterations: 10 }

// Analyze bottlenecks component: "api-endpoint", metrics: ["response-time", "memory-usage"] }

Hooks

Pre-execution

echo "💻 Coder agent implementing: $TASK" if grep -q "test|spec" <<< "$TASK"; then echo "⚠️ Remember: Write tests first (TDD)" fi

Post-execution

echo "✨ Implementation complete" if [ -f "package.json" ]; then npm run lint --if-present fi

Related Skills

• core-researcher - Provides context and findings

• core-tester - Validates implementation

• core-reviewer - Reviews code quality

• core-planner - Provides task breakdown

Collaboration

• Coordinate with researcher for context

• Follow planner's task breakdown

• Provide clear handoffs to tester

• Document assumptions and decisions in memory

• Request reviews when uncertain

• Share all implementation decisions via MCP memory tools

Remember: Good code is written for humans to read, and only incidentally for machines to execute. Focus on clarity, maintainability, and correctness. Always coordinate through memory.

Version History

• 1.0.0 (2026-01-02): Initial release - converted from coder.md agent