Moai Lang Unified

Quick Reference (30 seconds)

Unified Enterprise Programming Language Expert - 25+ languages with patterns, best practices, and Context7 integration.

Auto-Triggers: Any language-specific code, files, or discussions (.py, .ts, .go, .rs, .java, .js, .cpp, .cs, .php, .swift, .kt, .scala, .ex, .rb, .r, .sql, .sh)

Core Capabilities:

• ✅ 25+ programming languages with latest versions
• ✅ Language-specific patterns and best practices
• ✅ Cross-language concepts and comparisons
• ✅ Context7 integration for latest documentation
• ✅ Progressive disclosure from basics to advanced
• ✅ Enterprise-ready patterns and deployment

Implementation Guide (5 minutes)

Features

• Multi-language support (Python, TypeScript, JavaScript, Java, C#, etc.)
• Modern language features and best practices
• Framework-specific patterns (FastAPI, React, Next.js, Spring, etc.)
• Type safety and linting standards
• Testing patterns for each language

When to Use

• Implementing backend APIs in Python (FastAPI) or TypeScript (Express)
• Building frontend UIs with React 19, Next.js 15, or Vue 3.5
• Setting up full-stack applications with type-safe communication
• Configuring linters and formatters for consistent code style
• Writing language-specific tests with appropriate frameworks

Core Patterns

Pattern 1: FastAPI Backend (Python)

from fastapi import FastAPI, HTTPException
from pydantic import BaseModel

app = FastAPI()

class Item(BaseModel):
    name: str
    price: float

@app.post("/items/")
async def create_item(item: Item):
    # Implementation
    return item

Pattern 2: Next.js 15 Frontend (TypeScript)

// app/page.tsx (App Router)
export default async function Page() {
  const data = await fetch('https://api.example.com/data');
  return <main>{/* Render data */}</main>;
}

Pattern 3: Type-Safe API Integration

// Shared types between frontend/backend
export interface User {
  id: string;
  name: string;
  email: string;
}

// Backend endpoint types
export type GetUserResponse = User;
export type CreateUserRequest = Omit<User, 'id'>;

Language Coverage

Scripting & Dynamic Languages

• Python 3.13 - FastAPI, Django, async patterns, data science
• JavaScript ES2025 - Node.js 22 LTS, Express, browser development
• TypeScript 5.9 - React 19, Next.js 16, type safety
• PHP 8.4 - Laravel, Symfony, composer patterns
• Ruby 3.3 - Rails, Sinatra, metaprogramming
• Shell/Bash - DevOps, scripting, system automation

Systems & Performance Languages

• Go 1.23 - Concurrency, Fiber, systems programming
• Rust 1.91 - Memory safety, Tokio, async systems
• C++ - Systems programming, performance optimization
• C - Low-level programming, embedded systems

Enterprise & JVM Languages

• Java 21 LTS - Spring Boot, enterprise patterns
• Kotlin - Android, server-side, coroutines
• Scala - Functional programming, big data

Mobile & Platform Languages

• Swift - iOS development, server-side Swift
• C# (.NET 8) - Enterprise applications, game development
• Dart - Flutter, cross-platform development

Data & Domain Languages

• R - Statistical computing, data analysis
• SQL - Database queries across PostgreSQL, MySQL, etc.
• Elixir - Functional programming, Phoenix, BEAM

Quick Reference Examples

Python 3.13+ FastAPI Pattern

from fastapi import FastAPI, Depends
from sqlalchemy.ext.asyncio import AsyncSession

app = FastAPI(title="API", version="1.0.0")

@app.get("/users/{user_id}")
async def get_user(user_id: int, db: AsyncSession = Depends(get_db)) -> UserResponse:
    user = await get_user_by_id(db, user_id)
    return UserResponse.model_validate(user)

TypeScript 5.9+ React Pattern

// React 19 Server Component
export default async function UserProfile({ userId }: { userId: string }) {
  const user = await getUser(userId)
  return <div><h1>{user.name}</h1><p>{user.email}</p></div>
}

Go 1.23+ Fiber Pattern

func main() {
    app := fiber.New()
    app.Get("/users", func(c fiber.Ctx) error {
        return c.JSON(fiber.Map{"users": []string{"John", "Jane"}})
    })
    app.Listen(":3000")
}

Rust 1.91+ Axum Pattern

#[tokio::main]
async fn main() {
    let app = Router::new().route("/users/:id", get(get_user));
    axum::serve(listener, app).await.unwrap()
}

Java 21 LTS Spring Boot Pattern

@RestController
@RequestMapping("/api/users")
public class UserController {
    @GetMapping("/{id}")
    public ResponseEntity<UserDto> getUser(@PathVariable Long id) {
        return ResponseEntity.ok(userService.findById(id));
    }
}

Cross-Language Patterns

Async Programming Comparison

Error Handling Patterns

Python: try/except with exceptions TypeScript: try/catch with async/await Go: Multiple return values (result, err) Rust: Result/Option types with match or ? Java: Checked exceptions with try/catch/finally

Package Management

When to Use Each Language

Python 3.13

✅ Use for: Data science, ML/AI, web APIs, automation ❌ Avoid: Real-time performance <1ms, embedded systems

TypeScript 5.9

✅ Use for: Enterprise applications, full-stack, type safety ❌ Avoid: Rapid prototyping, simple scripts

Go 1.23

✅ Use for: Microservices, CLI tools, cloud-native apps ❌ Avoid: Complex GUI, rapid prototyping

Rust 1.91

✅ Use for: Performance-critical, systems programming ❌ Avoid: Rapid prototyping, simple CRUD

Java 21 LTS

✅ Use for: Enterprise apps, large systems, big data ❌ Avoid: Lightweight CLI, rapid prototyping

Context7 Integration

Automatically fetches latest documentation for:

Python: FastAPI, Django, Pydantic, SQLAlchemy, pytest
TypeScript: React, Next.js, Node.js, tRPC, Zod
Go: Gin, Echo, GORM
Rust: Tokio, Axum, Serde
Java: Spring Boot, Hibernate

Usage example:

docs = await mcp__context7__get_library_docs(
    context7CompatibleLibraryID="/tiangolo/fastapi",
    topic="async dependency-injection",
    page=1
)

Works Well With

• moai-domain-backend — REST API, GraphQL, microservices
• moai-domain-frontend — React, Vue, Angular, UI components
• moai-domain-database — SQL, NoSQL, ORM patterns
• moai-foundation-trust — TRUST 5 quality principles
• moai-essentials-debug — AI-powered debugging
• moai-context7-integration — Latest documentation access

Troubleshooting

Python: Check venv, pip list, python -c "import sys"
TypeScript: npx tsc --noEmit, npm ls typescript
Go: go mod tidy, go mod verify
Rust: rustc --version, cargo check, cargo tree
Java: java -version, mvn/gradle build

Advanced Documentation

For comprehensive reference materials:

• reference.md - Complete language coverage, Context7 library mappings, performance characteristics
• examples.md - Multi-language code examples, REST API implementations, testing patterns, deployment configurations

Conclusion

This unified language skill replaces all individual moai-lang* skills while maintaining their expertise and functionality. It automatically detects programming context and provides relevant expertise for 25+ languages with Context7 integration and cross-language capabilities.

Last Updated: 2025-11-25
Status: Production Ready (Enterprise v1.0.0)
Replaces: All moai-lang-* individual skills