Action-Skills are FOCUSED:
- Do ONE thing well
- Accept clear inputs
- Produce clear outputs
- Report status accurately
- Don't orchestrate other skills

Input Requirements

{
  "specification": {
    "description": "What to generate",
    "type": "function | class | module | api | test"
  },
  "context": {
    "language": "javascript | python | typescript | go | ...",
    "framework": "express | react | fastapi | ...",
    "style": "reference to project style guide"
  },
  "requirements": {
    "functional": ["requirement 1", "requirement 2"],
    "nonFunctional": ["performance", "security"]
  },
  "constraints": {
    "dependencies": ["allowed packages"],
    "patterns": ["patterns to follow"],
    "avoid": ["patterns to avoid"]
  }
}

Execution Protocol

Step 1: Parse Specification

UNDERSTAND:
  ├─ What type of code to generate?
  ├─ What are the functional requirements?
  ├─ What are the constraints?
  └─ What patterns should be followed?

Step 2: Design Structure

DESIGN:
  ├─ Identify components needed
  ├─ Plan function/class structure
  ├─ Define interfaces
  └─ Plan error handling

Step 3: Generate Code

GENERATE:
  ├─ Write main implementation
  ├─ Add helper functions
  ├─ Include error handling
  ├─ Add type annotations
  └─ Include documentation

Step 4: Validate

VALIDATE:
  ├─ Syntax check
  ├─ Type check (if applicable)
  ├─ Style check
  └─ Requirement coverage

Step 5: Return Result

RETURN:
  ├─ Generated code
  ├─ Validation status
  ├─ Coverage of requirements
  └─ Any warnings or notes

Code Generation Templates

Function Template

/**
 * {function_description}
 * 
 * @param {type} paramName - Description
 * @returns {type} Description
 * @throws {ErrorType} When condition
 * 
 * @example
 * // Example usage
 * const result = functionName(arg);
 */
function functionName(paramName) {
  // Input validation
  if (!paramName) {
    throw new Error('paramName is required');
  }
  
  // Main logic
  try {
    const result = /* implementation */;
    return result;
  } catch (error) {
    // Error handling
    throw new Error(`Operation failed: ${error.message}`);
  }
}

Class Template

/**
 * {ClassName} - {description}
 * 
 * @example
 * const instance = new ClassName(options);
 * instance.method();
 */
class ClassName {
  /**
   * Create a new {ClassName}
   * @param {Object} options - Configuration options
   */
  constructor(options = {}) {
    // Validate options
    this.validateOptions(options);
    
    // Initialize state
    this.state = this.initializeState(options);
  }
  
  /**
   * Validate constructor options
   * @private
   */
  validateOptions(options) {
    const required = ['option1'];
    for (const key of required) {
      if (!options[key]) {
        throw new Error(`${key} is required`);
      }
    }
  }
  
  /**
   * Main method description
   * @param {type} param - Description
   * @returns {type} Description
   */
  async mainMethod(param) {
    // Implementation
  }
  
  /**
   * Cleanup resources
   */
  destroy() {
    // Cleanup
  }
}

API Route Template

/**
 * {route_name} endpoint
 * 
 * @route {METHOD} /api/{path}
 * @param {Request} req - Express request
 * @param {Response} res - Express response
 */
router.{method}('/{path}', async (req, res) => {
  try {
    // 1. Validate input
    const { param1, param2 } = validateInput(req.body);
    
    // 2. Process request
    const result = await service.process(param1, param2);
    
    // 3. Return response
    res.json({
      success: true,
      data: result
    });
  } catch (error) {
    // 4. Handle errors
    if (error instanceof ValidationError) {
      return res.status(400).json({
        success: false,
        error: error.message
      });
    }
    
    console.error('Route error:', error);
    res.status(500).json({
      success: false,
      error: 'Internal server error'
    });
  }
});

Output Format

{
  "status": "success",
  "output": {
    "files": [
      {
        "path": "src/module/function.js",
        "content": "// Generated code...",
        "language": "javascript",
        "lines": 50
      }
    ],
    "exports": [
      {
        "name": "functionName",
        "type": "function",
        "description": "Description of function"
      }
    ]
  },
  "validation": {
    "syntax": "valid",
    "types": "valid",
    "style": "passes",
    "requirements": {
      "covered": ["req1", "req2"],
      "missing": []
    }
  },
  "metrics": {
    "linesOfCode": 50,
    "complexity": "low",
    "executionTime": "1.5s"
  },
  "notes": [
    "Added input validation as per security requirements"
  ]
}

Generation Patterns

Pattern: Input Validation

// Always validate inputs
function validateInput(data, schema) {
  const errors = [];
  
  for (const [field, rules] of Object.entries(schema)) {
    if (rules.required && !data[field]) {
      errors.push(`${field} is required`);
    }
    if (rules.type && typeof data[field] !== rules.type) {
      errors.push(`${field} must be ${rules.type}`);
    }
    if (rules.pattern && !rules.pattern.test(data[field])) {
      errors.push(`${field} format is invalid`);
    }
  }
  
  if (errors.length > 0) {
    throw new ValidationError(errors);
  }
  
  return data;
}

Pattern: Error Handling

// Structured error handling
class AppError extends Error {
  constructor(message, code, details = {}) {
    super(message);
    this.code = code;
    this.details = details;
    this.timestamp = new Date().toISOString();
  }
}

class ValidationError extends AppError {
  constructor(errors) {
    super('Validation failed', 'VALIDATION_ERROR', { errors });
  }
}

class NotFoundError extends AppError {
  constructor(resource) {
    super(`${resource} not found`, 'NOT_FOUND', { resource });
  }
}

Pattern: Async Operations

// Proper async/await pattern
async function asyncOperation(params) {
  let connection;
  try {
    connection = await getConnection();
    const result = await connection.query(params);
    return result;
  } catch (error) {
    // Log error with context
    console.error('Async operation failed:', {
      params,
      error: error.message
    });
    throw new AppError(
      'Operation failed',
      'OPERATION_ERROR',
      { originalError: error.message }
    );
  } finally {
    // Always cleanup
    if (connection) {
      await connection.close();
    }
  }
}

Quality Checklist

Before returning generated code, verify:

Examples

Example 1: Generate Function

Input:

{
  "specification": {
    "description": "Calculate total price with discount",
    "type": "function"
  },
  "context": {
    "language": "javascript"
  },
  "requirements": {
    "functional": [
      "Accept price and discount percentage",
      "Return final price after discount",
      "Handle edge cases (negative, zero)"
    ]
  }
}

Output:

/**
 * Calculate total price after applying discount
 * 
 * @param {number} price - Original price (must be positive)
 * @param {number} discountPercent - Discount percentage (0-100)
 * @returns {number} Final price after discount
 * @throws {Error} If price is negative or discount is invalid
 * 
 * @example
 * calculateTotalPrice(100, 20); // Returns 80
 * calculateTotalPrice(50, 0);   // Returns 50
 */
function calculateTotalPrice(price, discountPercent) {
  // Input validation
  if (typeof price !== 'number' || price < 0) {
    throw new Error('Price must be a positive number');
  }
  
  if (typeof discountPercent !== 'number' || discountPercent < 0 || discountPercent > 100) {
    throw new Error('Discount must be between 0 and 100');
  }
  
  // Handle zero price
  if (price === 0) {
    return 0;
  }
  
  // Calculate discount
  const discountAmount = price * (discountPercent / 100);
  const finalPrice = price - discountAmount;
  
  // Round to 2 decimal places
  return Math.round(finalPrice * 100) / 100;
}

Example 2: Generate API Route

Input:

{
  "specification": {
    "description": "User registration endpoint",
    "type": "api"
  },
  "context": {
    "language": "javascript",
    "framework": "express"
  },
  "requirements": {
    "functional": [
      "Accept email, password, name",
      "Validate email format",
      "Hash password",
      "Create user in database",
      "Return user object (without password)"
    ]
  }
}

Output:

/**
 * User registration endpoint
 * 
 * @route POST /api/users/register
 * @param {Request} req - Express request
 * @param {Response} res - Express response
 */
router.post('/register', async (req, res) => {
  try {
    // 1. Validate input
    const { email, password, name } = req.body;
    
    if (!email || !password || !name) {
      return res.status(400).json({
        success: false,
        error: 'Email, password, and name are required'
      });
    }
    
    // Email format validation
    const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
    if (!emailRegex.test(email)) {
      return res.status(400).json({
        success: false,
        error: 'Invalid email format'
      });
    }
    
    // Password strength check
    if (password.length < 8) {
      return res.status(400).json({
        success: false,
        error: 'Password must be at least 8 characters'
      });
    }
    
    // 2. Check if user exists
    const existingUser = await User.findOne({ email });
    if (existingUser) {
      return res.status(409).json({
        success: false,
        error: 'Email already registered'
      });
    }
    
    // 3. Hash password
    const hashedPassword = await bcrypt.hash(password, 10);
    
    // 4. Create user
    const user = await User.create({
      email,
      password: hashedPassword,
      name
    });
    
    // 5. Return user (without password)
    const userResponse = {
      id: user._id,
      email: user.email,
      name: user.name,
      createdAt: user.createdAt
    };
    
    res.status(201).json({
      success: true,
      data: userResponse
    });
    
  } catch (error) {
    console.error('Registration error:', error);
    res.status(500).json({
      success: false,
      error: 'Registration failed'
    });
  }
});

Input Requirements

Execution Protocol

Step 1: Parse Specification

Step 2: Design Structure

Step 3: Generate Code

Step 4: Validate

Step 5: Return Result

Code Generation Templates

Function Template

Class Template

API Route Template

Output Format

Generation Patterns

Pattern: Input Validation

Pattern: Error Handling

Pattern: Async Operations

Quality Checklist

Examples

Example 1: Generate Function

Example 2: Generate API Route

Related Skills

Parent Workflows

Peer Action-Skills

code-generator

Code Generator

Role Definition

Key Principle