luumenlabs/luau-skills

luau-core

Use for idiomatic, correct pure Luau language work focused on syntax, functions, tables, control flow, metatables, standard library behavior, and Lua compatibility details outside Roblox APIs, deep typing, or performance tuning.

소스 보기

사용 방법

  1. 설치 명령을 복사하고 자신의 에이전트 환경에 설치하기 전에 소스 패키지를 확인하세요.
  2. 필요한 도구, 인증 정보, 지원 환경은 원본 문서에서 확인하세요.
  3. 입력과 원하는 산출물을 설명하고 출처와 결과를 대조하세요.
npx skills add https://github.com/luumenlabs/luau-skills --skill luau-core

시작 전 확인

  • 설치에는 모델 구독, API 한도, 파일 접근 권한이 포함되지 않습니다.
  • 별점 수와 설치 수는 활동 지표이며 독립적인 품질·보안 검증이 아닙니다.
원본 Skill 문서

원본 저장소의 제목, 예시, 코드, 표, 링크, 이미지를 유지해 표시합니다.

luau-core

When to Use

Use this skill when the task is primarily about plain Luau language behavior:

  • Writing or fixing pure Luau syntax.
  • Choosing idiomatic control flow, variable scope, or function structure.
  • Working with tables as arrays, dictionaries, or object-like values.
  • Using the standard library correctly.
  • Applying metatables for indexing, operators, iteration, or object-like patterns.
  • Checking whether a Lua feature or idiom is compatible with Luau.

Do not use this skill when the task is mainly about:

  • Luau type annotations, generics, inference, refinements, or strictness policy.
  • Profiling, optimization strategy, or performance tradeoffs.
  • Roblox engine APIs, services, events, classes, networking, data, or gameplay architecture.

Decision Rules

  • Use this skill if the answer can stay within pure Luau syntax, semantics, idioms, and standard library usage.
  • If the task centers on type aliases, annotations, generics, exported types, or analyzer behavior, hand off to luau-types.
  • If the task centers on allocation patterns, hot loops, benchmarking, profiling, or optimization strategy, hand off to luau-performance.
  • If the task depends on game, Instance, services, remotes, datastores, UI, physics, or other Roblox runtime concepts, use the appropriate roblox/* skill instead.
  • If a request mixes core language work with out-of-scope topics, answer only the pure Luau portion and explicitly exclude the rest.
  • If unsure, prefer the narrower interpretation and omit material that could overlap another skill.

Instructions

  1. Treat Luau as Lua 5.1 plus selected Luau extensions. Do not assume Lua 5.2+ features unless Luau explicitly supports them.
  2. Prefer local variables and local function declarations by default. Use globals only when the broader scope is required by the task.
  3. Keep control flow direct. Prefer normal if, elseif, else, loops, break, and continue over clever boolean tricks.
  4. Use Luau-specific syntax when it improves correctness or readability:
  • if ... then ... else ... expressions instead of a and b or c ternary emulation.
  • Compound assignment such as += when the left side should only be evaluated once.
  • Generalized iteration for k, v in table do when iterating a table directly is the clearest form.
  1. Model tables intentionally:
  • Arrays for ordered numeric sequences.
  • Dictionaries for keyed lookup.
  • Metatable-backed records only when custom behavior materially improves the API.
  1. Use : for method definitions and calls that conceptually pass self; use . for plain function access.
  2. Prefer built-in library functions over handwritten helpers when the standard library already expresses the operation clearly.
  3. Use metatables sparingly and explicitly. Define only the metamethods needed for the abstraction and avoid surprising behavior.
  4. When discussing compatibility, call out unsupported assumptions early, such as goto, bitwise operators, integer-only reasoning, or full Lua standard library access.
  5. Keep all examples host-agnostic and pure Luau. Do not rely on Roblox engine objects or services.

Using References

  • Open references/getting-started-and-syntax.md for syntax forms, literals, assignments, expression forms, and Luau-only syntax additions.
  • Open references/functions-tables-operators-scope-and-control-structures.md for the core execution model: functions, closures, tables, truthiness, iteration, and control flow.
  • Open references/metatables-and-userdata-concepts.md for metamethod behavior, object-like table patterns, raw operations, and userdata boundaries.
  • Open references/library-and-grammar-reference.md for standard-library selection and compact grammar reminders for statements and expressions.
  • Open references/compatibility-notes.md when a request compares Luau with Lua or depends on version-specific behavior.
  • Do not open or cite references outside this skill unless the task clearly crosses into another skill's scope.

Checklist

  • The solution is valid Luau syntax.
  • Scope is explicit and defaults to local.
  • Control flow is clear and uses the simplest correct construct.
  • Table usage is intentional: array, dictionary, or metatable-backed record.
  • Iteration choice matches the data shape.
  • Standard library usage is correct and simpler than a custom helper.
  • Any metatable behavior is minimal, predictable, and documented in code if non-obvious.
  • No deep type-system material is included.
  • No performance-tuning guidance is included.
  • No Roblox engine APIs or architecture advice is included.

Common Mistakes

  • Treating 0 or "" as falsy. In Luau, only false and nil are falsy.
  • Using a and b or c as a ternary replacement when b can be false or nil.
  • Assuming arrays are zero-based instead of one-based.
  • Mixing method and function syntax, such as defining with : and calling with ..
  • Relying on dictionary iteration order.
  • Forgetting that missing function arguments become nil and extra arguments are ignored.
  • Using globals where locals or closures are the correct fit.
  • Overusing metatables for simple data containers.
  • Assuming newer Lua features like goto, bitwise operators, or integer semantics exist in Luau.

Examples

Use if expressions instead of boolean ternary tricks

luau
local function labelScore(score)
    return if score >= 100 then "high" else "normal"
end

Prefer locals and straightforward control flow

luau
local function firstPositive(values)
    for _, value in values do
        if value > 0 then
            return value
        end
    end

    return nil
end

Use tables intentionally

luau
local queue = {}

queue[#queue + 1] = "a"
queue[#queue + 1] = "b"

local first = table.remove(queue, 1)

Use method syntax for object-like tables

luau
local Counter = {}
Counter.__index = Counter

function Counter.new()
    return setmetatable({ value = 0 }, Counter)
end

function Counter:increment()
    self.value += 1
    return self.value
end

Add metatables only when behavior is deliberate

luau
local Range = {}
Range.__index = Range

function Range.new(minimum, maximum)
    return setmetatable({ minimum = minimum, maximum = maximum }, Range)
end

function Range:contains(value)
    return value >= self.minimum and value <= self.maximum
end

function Range:__tostring()
    return string.format("[%d, %d]", self.minimum, self.maximum)
end
같은 저장소의 Skills

더 많은 Skills

모든 Skills
luumenlabs
커뮤니티

luau-performance

Use for Luau performance work focused on profiling hotspots, allocation-aware code structure, table and iteration costs, builtin and function-call fast paths, compiler/runtime optimization behavior, and environment constraints that change execution speed.

1시간 설치 수
1
GitHub Stars
12
업데이트
5월 27일
luumenlabs
커뮤니티

luau-types

Use for Luau type-system work focused on strictness modes, annotations, inference-aware API design, generics, refinements, advanced type patterns, and Roblox-aware type usage at the type level.

1시간 설치 수
1
GitHub Stars
12
업데이트
5월 27일
luumenlabs
커뮤니티

roblox-api

Use for Roblox Engine API lookup during implementation: finding the correct engine class or service, confirming properties, methods, events, callbacks, datatypes, enums, globals, and built-in libraries, and verifying parameter, return, and property usage for a known engine task. Prefer this skill when the problem is referential rather than architectural.

1시간 설치 수
1
GitHub Stars
12
업데이트
5월 27일
luumenlabs
커뮤니티

roblox-cloud

Use for Roblox Open Cloud and external integration work: choosing API-key-based authentication for server-to-server automation, constructing and troubleshooting Open Cloud REST requests, checking scopes and rate limits, determining whether HttpService can call an endpoint, setting up webhook receivers, and using Roblox OpenAPI and reference JSON artifacts for tooling or client generation.

1시간 설치 수
1
GitHub Stars
12
업데이트
5월 27일