메뉴
Enterprise Programming Languages Foundation with AI-powered language selection, Context7 integration, and intelligent multi-language orchestration for optimal technology choices
기본적으로 소스를 먼저 확인하는 Prompt가 선택됩니다. 직접 명령으로 전환하거나 로컬 사본을 다운로드할 수도 있습니다.
설치 여부를 결정하기 전에 SKILL.md와 SkillsMP에 표시된 보조 파일을 읽어 보세요.
Codex 또는 Claude로 설치 이 Prompt를 복사해 Codex, Claude 또는 다른 어시스턴트에 붙여 넣으면 Skill 페이지를 검토하고 설치를 진행할 수 있습니다.
직접 명령은 검토 Prompt를 거치지 않습니다. 실행하기 전에 소스를 확인하세요.
npx skills add https://github.com/AJBcoding/claude-skill-eval --skill moai-foundation-langs명령은 한 줄로 유지됩니다. 복사하기 전에 가로로 스크롤해 전체 내용을 확인하세요.
로컬 사본을 원하시나요? SkillsMP에서 현재 제공할 수 있는 파일을 다운로드하세요.
SKILL.md 표시 중
SOC 직업 분류 기준
| name | moai-foundation-langs |
| version | 4.0.0 |
| created | 2025-11-11T00:00:00.000Z |
| updated | 2025-11-13T00:00:00.000Z |
| status | stable |
| description | Enterprise Programming Languages Foundation with AI-powered language selection, Context7 integration, and intelligent multi-language orchestration for optimal technology choices |
| keywords | ["programming-languages","language-selection","technology-stack","multi-language","context7-integration","ai-orchestration","production-deployment"] |
| allowed-tools | ["Read","Bash","Write","Edit","Glob","Grep","WebFetch","mcp__context7__resolve-library-id","mcp__context7__get-library-docs"] |
| Field | Value |
|---|---|
| Skill Name | moai-foundation-langs |
| Version | 4.0.0 (2025-11-13) |
| Tier | Foundation Language Expert |
| AI-Powered | ✅ Context7 Integration, Intelligent Selection |
| Auto-load | On demand when language selection keywords detected |
Enterprise Programming Languages Foundation expert with AI-powered language selection, Context7 integration, and intelligent multi-language orchestration for optimal technology choices.
Revolutionary v4.0.0 capabilities:
Automatic triggers:
Manual invocation:
# AI-powered language selection with Context7
class LanguageSelectionOptimizer:
def __init__(self):
self.context7_client = Context7Client()
self.performance_analyzer = LanguagePerformanceAnalyzer()
self.compatibility_checker = LanguageCompatibilityChecker()
async def select_optimal_languages(self,
requirements: ProjectRequirements) -> LanguageSelection:
"""Select optimal programming languages using AI analysis."""
# Get latest language documentation via Context7
language_docs = {}
primary_languages = ['typescript', 'python', 'rust', 'go', 'java', 'kotlin']
for lang in primary_languages:
docs = await self.context7_client.get_library_docs(
context7_library_id=await self._resolve_language_library(lang),
topic="performance optimization ecosystem best practices 2025",
tokens=2000
)
language_docs[lang] = docs
# Analyze project requirements
requirement_analysis = self._analyze_requirements(requirements)
# Optimize language combinations
language_combinations = self._generate_language_combinations(
requirement_analysis,
language_docs
)
# Evaluate performance characteristics
performance_evaluation = await self.performance_analyzer.evaluate_languages(
language_combinations,
requirement_analysis.performance_requirements,
language_docs
)
# Check compatibility and integration
compatibility_analysis = await self.compatibility_checker.check_compatibility(
language_combinations,
requirement_analysis.integration_requirements
)
return LanguageSelection(
recommended_stack=self._select_optimal_stack(
language_combinations,
performance_evaluation,
compatibility_analysis
),
alternative_stacks=self._identify_alternatives(
language_combinations,
performance_evaluation
),
performance_comparison=performance_evaluation,
compatibility_matrix=compatibility_analysis,
migration_strategy=self._plan_migration_strategy(requirements),
risk_assessment=self._assess_language_risks(
language_combinations,
compatibility_analysis
)
)
class MultiLanguageArchitect:
def __init__(self):
self.integration_patterns = IntegrationPatternLibrary()
self.performance_optimizer = CrossLanguageOptimizer()
def design_multi_language_architecture(self,
language_selection: LanguageSelection,
system_requirements: SystemRequirements) -> MultiLanguageArchitecture:
"""Design optimized multi-language system architecture."""
# Define service boundaries based on language strengths
service_boundaries = self._define_service_boundaries(
language_selection.recommended_stack,
system_requirements.domain_boundaries
)
# Design integration patterns
integration_patterns = self.integration_patterns.select_patterns(
service_boundaries,
system_requirements.communication_requirements
)
# Optimize cross-language performance
performance_optimization = self.performance_optimizer.optimize_cross_language_performance(
language_selection.recommended_stack,
service_boundaries,
integration_patterns
)
return MultiLanguageArchitecture(
service_boundaries=service_boundaries,
integration_patterns=integration_patterns,
performance_optimization=performance_optimization,
deployment_strategy=self._design_deployment_strategy(
service_boundaries,
language_selection.recommended_stack
),
monitoring_setup=self._configure_monitoring(
service_boundaries,
integration_patterns
)
)
def _define_service_boundaries(self,
recommended_stack: LanguageStack,
domain_boundaries: List[DomainBoundary]) -> List[ServiceDefinition]:
"""Define service boundaries based on language strengths."""
services = []
for domain in domain_boundaries:
optimal_language = self._select_optimal_language_for_domain(
domain, recommended_stack
)
service = ServiceDefinition(
name=domain.name,
domain=domain,
language=optimal_language,
responsibilities=domain.responsibilities,
interfaces=self._define_service_interfaces(domain, optimal_language),
dependencies=self._identify_dependencies(domain, domain_boundaries),
performance_requirements=domain.performance_requirements
)
services.append(service)
return services
class IntegrationPatternLibrary:
def __init__(self):
self.patterns = {
'rest_api': RESTAPIPattern(),
'graphql': GraphQLPattern(),
'message_queue': MessageQueuePattern(),
'event_bus': EventBusPattern(),
'shared_database': SharedDatabasePattern(),
'grpc': GRPCPattern(),
'websocket': WebSocketPattern()
}
def select_patterns(self,
service_boundaries: List[ServiceDefinition],
communication_requirements: CommunicationRequirements) -> List[IntegrationPattern]:
"""Select optimal integration patterns for service communication."""
selected_patterns = []
for service in service_boundaries:
for dependency in service.dependencies:
pattern = self._select_pattern_for_dependency(
service, dependency, communication_requirements
)
if pattern and pattern not in selected_patterns:
selected_patterns.append(pattern)
return selected_patterns
// Cross-language performance optimization
export class LanguagePerformanceOptimizer {
private languageProfiles = new Map<string, LanguageProfile>();
constructor() {
this.initializeLanguageProfiles();
}
private initializeLanguageProfiles() {
// Rust profile - systems programming
this.languageProfiles.set('rust', {
strengths: ['performance', 'memory_safety', 'concurrency'],
weaknesses: ['development_speed', 'ecosystem_size'],
useCases: ['systems_programming', 'high_performance_services', 'cli_tools'],
benchmarks: {
cpuIntensive: 95,
memoryEfficiency: 98,
developmentSpeed: 60,
ecosystemMaturity: 75
}
});
// TypeScript profile - web development
this.languageProfiles.set('typescript', {
strengths: ['type_safety', 'ecosystem', 'tooling'],
weaknesses: ['runtime_performance', 'memory_usage'],
useCases: ['web_apis', 'frontend_development', 'microservices'],
benchmarks: {
cpuIntensive: 70,
memoryEfficiency: 65,
developmentSpeed: 90,
ecosystemMaturity: 95
}
});
// Go profile - backend services
this.languageProfiles.set('go', {
strengths: ['concurrency', 'deployment', 'simplicity'],
weaknesses: ['generic_programming', 'error_handling'],
useCases: ['microservices', 'cli_tools', 'network_services'],
benchmarks: {
cpuIntensive: 85,
memoryEfficiency: 80,
developmentSpeed: 85,
ecosystemMaturity: 80
}
});
}
optimizeLanguageSelection(requirements: ProjectRequirements): LanguageOptimization {
const languageScores = new Map<string, number>();
// Score each language against requirements
for (const [language, profile] of this.languageProfiles) {
let score = 0;
// Performance requirements
if (requirements.performance === 'high') {
score += profile.benchmarks.cpuIntensive * 0.3;
score += profile.benchmarks.memoryEfficiency * 0.2;
} else if (requirements.performance === 'medium') {
score += profile.benchmarks.cpuIntensive * 0.2;
score += profile.benchmarks.memoryEfficiency * 0.1;
}
// Development speed requirements
if (requirements.timeline === 'short') {
score += profile.benchmarks.developmentSpeed * 0.3;
} else {
score += profile.benchmarks.developmentSpeed * 0.1;
}
// Ecosystem maturity requirements
if (requirements.complexity === 'high') {
score += profile.benchmarks.ecosystemMaturity * 0.2;
} else {
score += profile.benchmarks.ecosystemMaturity * 0.1;
}
languageScores.set(language, score);
}
// Sort languages by score
const sortedLanguages = Array.from(languageScores.entries())
.sort((a, b) => b[1] - a[1])
.slice(0, 5); // Top 5 languages
return {
primaryRecommendation: sortedLanguages[0][0],
alternatives: sortedLanguages.slice(1).map(([lang]) => lang),
scores: Object.fromEntries(languageScores),
reasoning: this.generateReasoning(sortedLanguages, requirements)
};
}
private generateReasoning(
sortedLanguages: [string, number][],
requirements: ProjectRequirements
): string {
const [primary, score] = sortedLanguages[0];
const profile = this.languageProfiles.get(primary)!;
let reasoning = `${primary} is recommended because it excels in `;
if (requirements.performance === 'high') {
reasoning += `performance (CPU: ${profile.benchmarks.cpuIntensive}%, Memory: ${profile.benchmarks.memoryEfficiency}%)`;
}
if (requirements.timeline === 'short') {
reasoning += ` and has fast development speed (${profile.benchmarks.developmentSpeed}%)`;
}
reasoning += `. It's particularly suited for ${profile.useCases.join(', ')}.`;
return reasoning;
}
}
class LanguageMigrationPlanner:
def __init__(self):
self.risk_assessor = MigrationRiskAssessor()
self.cost_analyzer = MigrationCostAnalyzer()
def plan_migration(self,
current_stack: TechnologyStack,
target_stack: TechnologyStack,
migration_scope: MigrationScope) -> MigrationPlan:
"""Plan comprehensive language migration strategy."""
# Risk assessment
risk_assessment = self.risk_assessor.assess_migration_risks(
current_stack,
target_stack,
migration_scope
)
# Cost analysis
cost_analysis = self.cost_analyzer.analyze_migration_costs(
current_stack,
target_stack,
migration_scope,
risk_assessment
)
# Migration phases
migration_phases = self._plan_migration_phases(
current_stack,
target_stack,
migration_scope,
risk_assessment
)
return MigrationPlan(
risk_assessment=risk_assessment,
cost_analysis=cost_analysis,
migration_phases=migration_phases,
rollback_strategy=self._create_rollback_strategy(current_stack),
validation_criteria=self._create_validation_criteria(target_stack),
team_training_plan=self._create_team_training_plan(target_stack)
)
def _plan_migration_phases(self,
current_stack: TechnologyStack,
target_stack: TechnologyStack,
migration_scope: MigrationScope,
risk_assessment: RiskAssessment) -> List[MigrationPhase]:
"""Plan detailed migration phases."""
phases = []
# Phase 1: Preparation
phases.append(MigrationPhase(
name="Preparation",
duration="2-4 weeks",
activities=[
"Set up development environments for target language",
"Create proof-of-concept implementations",
"Define migration standards and guidelines",
"Train development team on target language"
],
deliverables=[
"Development environment setup",
"POC implementations",
"Migration guidelines",
"Team training completion"
],
risks=["Learning curve", "Tooling setup"],
mitigation=["Comprehensive training", "Expert consultation"]
))
# Phase 2: Gradual Migration
phases.append(MigrationPhase(
name="Gradual Migration",
duration="8-16 weeks",
activities=[
"Migrate non-critical components first",
"Implement parallel systems for validation",
"Gradually migrate core functionality",
"Monitor performance and stability"
],
deliverables=[
"Migrated components",
"Parallel system implementation",
"Performance monitoring setup",
"Migration progress reports"
],
risks=["System instability", "Performance degradation"],
mitigation=["Comprehensive testing", "Gradual rollout"]
))
# Phase 3: Full Migration
phases.append(MigrationPhase(
name="Full Migration",
duration="4-8 weeks",
activities=[
"Decommission legacy systems",
"Complete migration of remaining components",
"Optimize performance in target language",
"Finalize documentation and knowledge transfer"
],
deliverables=[
"Complete system migration",
"Legacy system decommissioning",
"Performance optimization",
"Final documentation"
],
risks=["Data loss", "System downtime"],
mitigation=["Comprehensive backups", "Maintenance windows"]
))
return phases
// Language ecosystem integration management
export class EcosystemIntegrationManager {
private ecosystemIntegrators = new Map<string, EcosystemIntegrator>();
constructor() {
this.setupEcosystemIntegrators();
}
private setupEcosystemIntegrators() {
// Node.js ecosystem
this.ecosystemIntegrators.set('typescript', new NodeJSIntegrator());
// Python ecosystem
this.ecosystemIntegrators.set('python', new PythonIntegrator());
// Rust ecosystem
this.ecosystemIntegrators.set('rust', new RustIntegrator());
// Go ecosystem
this.ecosystemIntegrators.set('go', new GoIntegrator());
}
async setupLanguageEnvironment(language: string, projectConfig: ProjectConfig): Promise<EnvironmentSetup> {
const integrator = this.ecosystemIntegrators.get(language);
if (!integrator) {
throw new Error(`No ecosystem integrator available for ${language}`);
}
return await integrator.setupEnvironment(projectConfig);
}
async manageDependencies(language: string, dependencies: Dependency[]): Promise<DependencyManagement> {
const integrator = this.ecosystemIntegrators.get(language);
if (!integrator) {
throw new Error(`No ecosystem integrator available for ${language}`);
}
return await integrator.manageDependencies(dependencies);
}
}
// TypeScript/Node.js ecosystem integrator
class NodeJSIntegrator implements EcosystemIntegrator {
async setupEnvironment(projectConfig: ProjectConfig): Promise<EnvironmentSetup> {
return {
packageManager: this.selectPackageManager(projectConfig),
buildTool: this.selectBuildTool(projectConfig),
testingFramework: this.selectTestingFramework(projectConfig),
linting: this.setupLinting(),
typeChecking: this.setupTypeChecking(),
bundler: this.selectBundler(projectConfig)
};
}
async manageDependencies(dependencies: Dependency[]): Promise<DependencyManagement> {
const packageJson = this.generatePackageJson(dependencies);
const lockFile = await this.generateLockFile(dependencies);
return {
packageJson,
lockFile,
versionConflicts: this.detectVersionConflicts(dependencies),
securityVulnerabilities: await this.checkSecurityVulnerabilities(dependencies),
optimizationSuggestions: this.generateOptimizationSuggestions(dependencies)
};
}
private selectPackageManager(projectConfig: ProjectConfig): PackageManager {
switch (projectConfig.packageManager) {
case 'npm':
return { name: 'npm', version: 'latest', lockFile: 'package-lock.json' };
case 'yarn':
return { name: 'yarn', version: 'latest', lockFile: 'yarn.lock' };
case 'pnpm':
return { name: 'pnpm', version: 'latest', lockFile: 'pnpm-lock.yaml' };
default:
return { name: 'npm', version: 'latest', lockFile: 'package-lock.json' };
}
}
}
select_languages(requirements, constraints) - Optimal language selectionanalyze_compatibility(languages, integrations) - Compatibility analysisoptimize_performance(stack, requirements) - Performance optimizationplan_migration(from_stack, to_stack) - Migration planningsetup_ecosystem(language, project_config) - Environment setupget_latest_language_documentation() - Language docs via Context7analyze_ecosystem_trends() - Ecosystem analysis via Context7optimize_language_patterns() - Language optimization via Context7moai-baas-foundation (Technology stack selection)moai-domain-backend (Backend language patterns)moai-domain-frontend (Frontend language patterns)moai-foundation-trust (Language security and compliance)moai-essentials-perf (Language performance optimization)moai-domain-devops (Language deployment patterns)moai-security-api (Language-specific security)moai-domain-database (Database integration patterns)End of Skill | Updated 2025-11-13
End of Enterprise Programming Languages Foundation Expert v4.0.0