Agent skill
musubix-code-generation
Guide for generating code from design specifications using MUSUBIX. Use this when asked to generate code, implement features, or create components following design documents.
Install this agent skill to your Project
npx add-skill https://github.com/majiayu000/claude-skill-registry/tree/main/skills/data/musubix-code-generation
SKILL.md
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.mdfor 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
anytypes (TypeScript) - Traceability: All classes/functions have
@seereferences - Tests: Test coverage ≥ 80%
- Linting:
npm run lintpasses - Build:
npm run buildsucceeds
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
);
Recommended Agent Skills
Expand your agent's capabilities with these related and highly-rated skills.
majiayu000/claude-skill-registry
agent-ops-spec
Manage specification documents in .agent/specs/. Use when user provides requirements, acceptance criteria, or feature descriptions that need to be tracked and validated against implementation.
majiayu000/claude-skill-registry
agent-ops-state
Maintain .agent state files. Use at session start, after meaningful steps, and before concluding: read/update constitution/memory/focus/issues/baseline consistently.
majiayu000/claude-skill-registry
agent-ops-spec
Manage specification documents in .agent/specs/. Use when user provides requirements, acceptance criteria, or feature descriptions that need to be tracked and validated against implementation.
majiayu000/claude-skill-registry
agent-ops-testing
Test strategy, execution, and coverage analysis. Use when designing tests, running test suites, or analyzing test results beyond baseline checks.
majiayu000/claude-skill-registry
agent-ops-testing
Test strategy, execution, and coverage analysis. Use when designing tests, running test suites, or analyzing test results beyond baseline checks.
majiayu000/claude-skill-registry
agent-ops-state
Maintain .agent state files. Use at session start, after meaningful steps, and before concluding: read/update constitution/memory/focus/issues/baseline consistently.
Didn't find tool you were looking for?