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 itemPattern 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
| Language | Syntax | Runtime | Best For |
|---|---|---|---|
| Python | async/await | asyncio | I/O-bound, data science |
| TypeScript | async/await | Node.js | Full-stack, real-time |
| Go | goroutines | Go runtime | Concurrent systems |
| Rust | async/await | Tokio | Performance-critical |
| Java | virtual threads | JVM | Enterprise systems |
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
| Language | Package Manager | Lock File | Registry |
|---|---|---|---|
| Python | pip/poetry | requirements.txt/poetry.lock | PyPI |
| TypeScript | npm/yarn | package-lock.json/yarn.lock | npm |
| Go | go modules | go.sum | Go Modules |
| Rust | cargo | Cargo.lock | crates.io |
| Java | Maven/Gradle | pom.xml/build.gradle | Maven Central |
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, microservicesmoai-domain-frontend— React, Vue, Angular, UI componentsmoai-domain-database— SQL, NoSQL, ORM patternsmoai-foundation-trust— TRUST 5 quality principlesmoai-essentials-debug— AI-powered debuggingmoai-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