multi-lang

Multi-Language Skill — Universal Development Patterns

This skill provides language-specific best practices for the most used programming languages and frameworks. Works WITH Context7 (recommended) or WITHOUT (using built-in knowledge with lower confidence).

Language Detection

When the project uses a language, adapt ALL output to that language's conventions:

TypeScript / JavaScript

// Naming: camelCase for variables/functions, PascalCase for classes/types
interface UserRepository {
  findById(id: string): Promise<User | null>;
  findMany(
    filters: UserFilters,
    pagination: Pagination
  ): Promise<PaginatedResult<User>>;
}

// Error handling: typed errors
class NotFoundError extends AppError {
  constructor(resource: string, id: string) {
    super(`${resource} with id ${id} not found`, 404, 'NOT_FOUND');
  }
}

PHP / Laravel

// Naming: camelCase methods, PascalCase classes, snake_case DB columns
class UserRepository
{
    /**
     * Find users with filters and pagination.
     *
     * @param  array<string, mixed>  $filters
     * @return \Illuminate\Contracts\Pagination\LengthAwarePaginator
     */
    public function findMany(array $filters, int $perPage = 20): LengthAwarePaginator
    {
        return User::query()
            ->select(['id', 'name', 'email', 'created_at'])
            ->when($filters['search'] ?? null, fn ($q, $search) =>
                $q->where(fn ($q) =>
                    $q->where('name', 'like', "%{$search}%")
                      ->orWhere('email', 'like', "%{$search}%")
                )
            )
            ->whereNull('deleted_at')
            ->orderBy('created_at', 'desc')
            ->paginate($perPage);
    }
}

Python

# Naming: snake_case for functions/variables, PascalCase for classes
class UserRepository:
    """Repository for user data access with filtering and pagination."""

    def find_many(
        self,
        filters: UserFilters,
        pagination: Pagination,
    ) -> PaginatedResult[User]:
        """Find users matching filters with pagination."""
        query = self.session.query(User).filter(User.deleted_at.is_(None))

        if filters.search:
            search_pattern = f"%{filters.search}%"
            query = query.filter(
                or_(
                    User.name.ilike(search_pattern),
                    User.email.ilike(search_pattern),
                )
            )

        total = query.count()
        results = (
            query.order_by(User.created_at.desc())
            .offset(pagination.offset)
            .limit(pagination.per_page)
            .all()
        )
        return PaginatedResult(items=results, total=total, page=pagination.page)