luumenlabs/luau-skills

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 fo…

Voir la source

Mode d’emploi

  1. Copiez la commande et examinez le paquet avant de l’installer dans votre environnement agent.
  2. Consultez le document original pour les outils, identifiants et environnements requis.
  3. Décrivez les entrées et le livrable souhaité ; comparez la sortie aux sources.
npx skills add https://github.com/luumenlabs/luau-skills --skill roblox-api

Avant de commencer

  • L’installation n’inclut ni abonnement au modèle, ni quota API, ni accès aux fichiers.
  • Étoiles et installations reflètent l’activité, pas un test indépendant de qualité ou de sécurité.
Document Skill original

Rendu depuis le dépôt source en conservant titres, exemples, code, tableaux, liens et images.

roblox-api

When to Use

Use this skill when the task is mainly about identifying or confirming the correct Roblox engine surface:

  • Finding which class or service owns a capability.
  • Checking whether a member is a property, method, event, or callback.
  • Confirming datatype constructors, properties, methods, constants, or math behavior.
  • Choosing the correct enum family and item for a property or parameter.
  • Looking up globals such as game, workspace, script, plugin, or Enum.
  • Confirming built-in library behavior such as task, math, string, table, os, or vector.
  • Verifying exact parameter shapes, return values, and deprecation status before writing code.

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

  • Overall Roblox project structure, code placement, or client-server responsibility.
  • Remote security, replication architecture, persistence design, or Open Cloud workflows.
  • Broader system design where API lookup is secondary to structural decisions.

Decision Rules

  • Use this skill if the main question is "what engine API should I call or read here?"
  • Use this skill when a known problem needs the correct class, member, datatype, enum, global, or library surface.
  • Start with the narrowest surface that matches the question:
  • Class or service for engine objects and services.
  • Datatype for value objects such as Vector3, CFrame, RaycastParams, or TweenInfo.
  • Enum for preset values such as Enum.RaycastFilterType.Exclude.
  • Global for always-available names like game, workspace, script, or Enum.
  • Library for free functions under tables like task, math, table, or string.
  • If the task is really about where code belongs, which side owns state, or how systems should be arranged, hand off to roblox-core.
  • If the task centers on remotes, trust boundaries, replication correctness, or server authority, hand off to roblox-networking.
  • If the task centers on persistent storage, quotas, save design, or cross-server state, hand off to roblox-data.
  • If the task centers on Open Cloud, OAuth, or external integrations, hand off to roblox-cloud or roblox-oauth.
  • If a request mixes referential lookup with out-of-scope design, answer only the engine-reference portion and explicitly exclude the rest.

Instructions

  1. Identify the missing fact before searching:
  • Which engine object or service is responsible?
  • Which member kind is needed?
  • Which datatype or enum is expected by the API?
  • Which global or library helper fits the job?
  1. Choose the correct reference file first:
  • references/engine-overview.md for surface selection.
  • references/classes-reference.md for class, service, and member lookup.
  • references/datatypes-reference.md for value types and their usage.
  • references/enums-reference.md for enum families and items.
  • references/globals-reference.md for Luau and Roblox globals.
  • references/engine-library-yaml-files.md for built-in libraries.
  • references/datatype-yaml-files.md for interpreting datatype YAML shape and overloads.
  1. Confirm the exact API contract before coding:
  • Member name.
  • Member kind.
  • Parameter order and types.
  • Return type.
  • Property type.
  • Enum family and item names.
  • Deprecation or other tags.
  1. Prefer the documented modern surface when an older global or legacy form also exists:
  • Prefer task.wait() over wait().
  • Prefer task.delay() over delay().
  • Prefer game:GetService() for service access when clarity matters.
  1. When a datatype or library page shows overloads, read all overloads before choosing a call pattern.
  2. When a parameter or property type points to another datatype or enum, follow that dependency and confirm it separately.
  3. Keep the answer referential and implementation-facing:
  • Name the correct surface.
  • State the relevant signature or property type.
  • Mention any important enum values, tags, or constraints.
  • Do not drift into architecture, persistence, or security-system design.

Using References

  • Open references/engine-overview.md first when the user only knows the problem and not the engine surface.
  • Open references/classes-reference.md when the question is about classes, services, or member discovery.
  • Open references/datatypes-reference.md when a value object or helper container is involved.
  • Open references/enums-reference.md when an API expects a preset constant.
  • Open references/globals-reference.md when the question involves built-in names available in scripts.
  • Open references/engine-library-yaml-files.md when the needed API lives under task, math, string, table, os, utf8, coroutine, debug, buffer, bit32, or vector.
  • Open references/datatype-yaml-files.md when constructor overloads, mutable-vs-immutable behavior, constants, or member lists need careful interpretation.

Checklist

  • The missing fact is identified as class, member, datatype, enum, global, or library lookup.
  • The chosen engine surface is the narrowest one that matches the problem.
  • Member kind, parameter order, return type, and property type are confirmed before use.
  • Required enum family and item names are spelled exactly.
  • Datatype constructors or methods match the documented overload.
  • Deprecated globals or legacy forms are not recommended unless necessary for compatibility.
  • The response stays referential and does not drift into project architecture, persistence, or cloud workflows.
  • Out-of-scope systems are handed off to the proper Roblox skill when needed.

Common Mistakes

  • Using roblox-api for project structure questions that belong to roblox-core.
  • Guessing a member name without confirming whether it is a property, method, event, or callback.
  • Passing raw numbers where an enum item is expected.
  • Treating a datatype like an Instance class, or vice versa.
  • Missing constructor overloads and choosing the wrong parameter order.
  • Recommending deprecated globals like wait() or delay() when task equivalents are the modern surface.
  • Assuming a global exists in every context, especially plugin.
  • Expanding a simple API lookup into networking, data, or cloud-system design.

Examples

Choose the right surface for a raycast

  • Class or service: Workspace (via WorldRoot behavior)
  • Method: Workspace:Raycast(origin, direction, raycastParams)
  • Datatype: RaycastParams
  • Enum: Enum.RaycastFilterType
  • Result datatype: RaycastResult

Confirm a tween API call

  • Class or service: TweenService
  • Method: TweenService:Create(instance, tweenInfo, propertyTable)
  • Datatype: TweenInfo
  • Enums often involved: Enum.EasingStyle, Enum.EasingDirection

Distinguish global, datatype, and enum usage

lua
local Workspace = game:GetService("Workspace")

local params = RaycastParams.new()
params.FilterType = Enum.RaycastFilterType.Exclude

local cf = CFrame.lookAt(Vector3.new(0, 5, 10), Vector3.zero)
  • game is a Roblox global.
  • RaycastParams, CFrame, and Vector3 are datatypes.
  • Enum.RaycastFilterType.Exclude is an enum item.
du même dépôt

Autres Skills

Tous les Skills
luumenlabs
Communauté

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.

Installations / 1h
1
GitHub Stars
12
Mis à jour
27 mai
luumenlabs
Communauté

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.

Installations / 1h
1
GitHub Stars
12
Mis à jour
27 mai
luumenlabs
Communauté

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.

Installations / 1h
1
GitHub Stars
12
Mis à jour
27 mai
luumenlabs
Communauté

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.

Installations / 1h
1
GitHub Stars
12
Mis à jour
27 mai