What is musubix-code-generation?

The MUSUBIX Code Generation skill streamlines the software development lifecycle by transforming design specifications into high-quality, production-ready code. It ensures architectural integrity through a structured methodology that emphasizes requirement traceability, multi-language support, and adherence to Test-Driven Development (TDD) principles.

When should I use musubix-code-generation?

musubix-code-generation is useful in the following scenarios: • Design-to-Code Automation: Rapidly generate functional components and boilerplate from design documents (DES-*) and requirement files (REQ-*) using the MUSUBIX CLI. • Requirement Traceability: Automatically embed metadata and '@see' references into source code to maintain a clear link between implementation and business requirements. • Standardized Pattern Implementation: Deploy consistent architectural patterns like Singleton, Factory, and Repository across various languages including TypeScript, Python, and Go. • Quality-Assured Development: Implement a 'Test-First' workflow that enforces minimal code implementation, high test coverage, and strict type safety checks. • Neuro-Symbolic Logic Integration: Develop advanced decision-making modules that balance neural network outputs with symbolic rule-based logic for high-confidence results.

name	musubix-code-generation
description	Guide for generating code from design specifications using MUSUBIX. Use this when asked to generate code, implement features, or create components following design documents.
license	MIT

MUSUBIX Code Generation Skill

This skill guides you through generating code from design specifications following MUSUBIX methodology.

Prerequisites

Before generating code:

Verify design document exists (DES-*)
Verify requirements are traceable (REQ-*)
Check steering/tech.ja.md for technology stack

Supported Languages

Language	Extension	Features
TypeScript	`.ts`	Full support with types
JavaScript	`.js`	ES6+ modules
Python	`.py`	Type hints support
Java	`.java`	Interface/Class generation
Go	`.go`	Struct/Interface generation
Rust	`.rs`	Trait/Struct generation
C#	`.cs`	Interface/Class generation

Code Generation Workflow

Step 1: Read Design Document

# Generate code from design
npx musubix codegen generate <design-file>

Step 2: Generate with Traceability

Always include requirement references:

/**
 * UserService - Handles user operations
 * 
 * @see REQ-INT-001 - Neuro-Symbolic Integration
 * @see DES-INT-001 - Integration Layer Design
 */
export class UserService {
  // Implementation
}

Step 3: Follow Test-First (Article III)

Write test first:

describe('UserService', () => {
  it('should create user', async () => {
    const service = new UserService();
    const user = await service.create({ name: 'Test' });
    expect(user.id).toBeDefined();
  });
});

Implement minimal code:

export class UserService {
  async create(data: CreateUserDto): Promise<User> {
    return { id: generateId(), ...data };
  }
}

Refactor

Design Pattern Templates

Singleton Pattern

/**
 * @see REQ-DES-001 - Pattern Detection
 * @pattern Singleton
 */
export class ConfigManager {
  private static instance: ConfigManager;
  
  private constructor() {}
  
  static getInstance(): ConfigManager {
    if (!ConfigManager.instance) {
      ConfigManager.instance = new ConfigManager();
    }
    return ConfigManager.instance;
  }
}

Factory Pattern

/**
 * @see REQ-DES-001 - Pattern Detection
 * @pattern Factory
 */
export interface ServiceFactory {
  create(type: string): Service;
}

export class DefaultServiceFactory implements ServiceFactory {
  create(type: string): Service {
    switch (type) {
      case 'auth': return new AuthService();
      case 'user': return new UserService();
      default: throw new Error(`Unknown service: ${type}`);
    }
  }
}

Repository Pattern

/**
 * @see REQ-COD-001 - Code Generation
 * @pattern Repository
 */
export interface Repository<T> {
  findById(id: string): Promise<T | null>;
  findAll(): Promise<T[]>;
  save(entity: T): Promise<T>;
  delete(id: string): Promise<void>;
}

export class UserRepository implements Repository<User> {
  async findById(id: string): Promise<User | null> {
    // Implementation
  }
  // ... other methods
}

CLI Commands

# Generate code from design
npx musubix codegen generate <design-file>

# Analyze existing code
npx musubix codegen analyze <file>

# Security scan
npx musubix codegen security <path>

Quality Checks (Article IX)

Before committing code:

Type Safety: No any types (TypeScript)
Traceability: All classes/functions have @see references
Tests: Test coverage ≥ 80%
Linting: npm run lint passes
Build: npm run build succeeds

Neuro-Symbolic Integration (REQ-INT-002)

When generating code that involves decision-making:

/**
 * @see REQ-INT-002 - Confidence Evaluation
 */
async function integrateResults(
  neuralResult: NeuralResult,
  symbolicResult: SymbolicResult
): Promise<FinalResult> {
  // Decision rules from REQ-INT-002
  if (symbolicResult.status === 'invalid') {
    return rejectNeural(neuralResult);
  }
  
  if (neuralResult.confidence >= 0.8) {
    return adoptNeural(neuralResult);
  }
  
  return prioritizeSymbolic(symbolicResult);
}

File Structure Convention

packages/
├── core/
│   └── src/
│       ├── [feature]/
│       │   ├── index.ts        # Public exports
│       │   ├── [feature].ts    # Main implementation
│       │   ├── types.ts        # Type definitions
│       │   └── __tests__/      # Tests
│       └── index.ts            # Package exports

Error Handling Pattern

/**
 * @see REQ-ERR-001 - Graceful Degradation
 */
export class MuSubixError extends Error {
  constructor(
    message: string,
    public code: string,
    public recoverable: boolean = true
  ) {
    super(message);
    this.name = 'MuSubixError';
  }
}

// Usage
throw new MuSubixError(
  'Failed to connect to YATA',
  'YATA_CONNECTION_ERROR',
  true // Can retry
);

musubix-code-generation

When & Why to Use This Skill

Use Cases