task_types listlengths 1 4 | difficulty large_stringclasses 4
values | conversations listlengths 4 10 | processed large_stringlengths 1.38k 17.1k |
|---|---|---|---|
[
"Bug Fix",
"Q/A"
] | beginner | [
{
"role": "user",
"content": "My Studio recipe-checking utility has a verbose option. This makes it verbose even when I pass false. I only want an omitted option to default to true.\n```luau\nlocal function checkRecipes(options)\n local verbose = options.verbose or true\n if verbose then\n prin... | <|open|>message role="system" type="thinking-effort"<|sep|>`thinking_effort` guides on how much to think in your thinking channel (not including the response channel), supported values include `low`, `medium`, `high`, and `max`.
Now the system is invoked with `thinking_effort=max`.<|close|>message<|sep|><|end_of_msg|><... |
[
"Debugging",
"Bug Fix"
] | beginner | [
{
"role": "user",
"content": "I'm inspecting numbered crafting slots in a Roblox ModuleScript. There are three occupied slots, but my count and loop don't agree with that.\n```luau\nlocal slots = { [1] = \"Wood\", [4] = \"Stone\", [9] = \"Fiber\" }\nprint(#slots)\nfor slot, item in ipairs(slots) do\n pri... | <|open|>message role="system" type="thinking-effort"<|sep|>`thinking_effort` guides on how much to think in your thinking channel (not including the response channel), supported values include `low`, `medium`, `high`, and `max`.
Now the system is invoked with `thinking_effort=max`.<|close|>message<|sep|><|end_of_msg|><... |
[
"Bug Fix",
"Optimization"
] | intermediate | [
{
"role": "user",
"content": "This function in my recipe-job ModuleScript sometimes leaves expired jobs behind, especially two adjacent ones. `jobs` is a dense array, and `now` is passed in so I can test it.\n```luau\nlocal function prune(jobs, now)\n for index, job in ipairs(jobs) do\n if job.exp... | <|open|>message role="system" type="thinking-effort"<|sep|>`thinking_effort` guides on how much to think in your thinking channel (not including the response channel), supported values include `low`, `medium`, `high`, and `max`.
Now the system is invoked with `thinking_effort=max`.<|close|>message<|sep|><|end_of_msg|><... |
[
"Debugging",
"Bug Fix",
"Refactor"
] | intermediate | [
{
"role": "user",
"content": "My Roblox quest simulation tests leak progress between runs. The QuestProgress ModuleScript has this factory:\n```luau\nlocal defaults = {\n coins = 0,\n quests = { Intro = { step = 0, done = false } },\n}\nlocal function newProgress()\n return table.clone(defaults)\ne... | <|open|>message role="system" type="thinking-effort"<|sep|>`thinking_effort` guides on how much to think in your thinking channel (not including the response channel), supported values include `low`, `medium`, `high`, and `max`.
Now the system is invoked with `thinking_effort=max`.<|close|>message<|sep|><|end_of_msg|><... |
[
"Review",
"Bug Fix",
"Q/A"
] | intermediate | [
{
"role": "user",
"content": "Please review this tiny Catalog ModuleScript for runtime immutability. This is the entire schema; power is a number.\n```luau\nlocal catalog = table.freeze({\n Hammer = { power = 12 },\n})\nreturn catalog\n```\nMy recipe editor shouldn't be able to change any shared catalog ... | <|open|>message role="system" type="thinking-effort"<|sep|>`thinking_effort` guides on how much to think in your thinking channel (not including the response channel), supported values include `low`, `medium`, `high`, and `max`.
Now the system is invoked with `thinking_effort=max`.<|close|>message<|sep|><|end_of_msg|><... |
[
"Debugging",
"Bug Fix",
"Q/A"
] | beginner | [
{
"role": "user",
"content": "I'm counting validated assets with a Counter ModuleScript. This is in ServerScriptService next to my test Script.\n```luau\nlocal Counter = { value = 0 }\nfunction Counter:add(amount)\n self.value += amount\nend\nreturn Counter\n```\nThe test calls it like this and gets an a... | <|open|>message role="system" type="thinking-effort"<|sep|>`thinking_effort` guides on how much to think in your thinking channel (not including the response channel), supported values include `low`, `medium`, `high`, and `max`.
Now the system is invoked with `thinking_effort=max`.<|close|>message<|sep|><|end_of_msg|><... |
[
"Bug Fix",
"Q/A"
] | advanced | [
{
"role": "user",
"content": "My Studio command recorder has optional positional arguments, including trailing nils. This loses the argument count:\n```luau\nlocal function capture(...)\n return { ... }\nend\nlocal saved = capture(\"Rename\", nil, 3, nil)\nprint(#saved)\n```\nHow do I preserve all four p... | <|open|>message role="system" type="thinking-effort"<|sep|>`thinking_effort` guides on how much to think in your thinking channel (not including the response channel), supported values include `low`, `medium`, `high`, and `max`.
Now the system is invoked with `thinking_effort=max`.<|close|>message<|sep|><|end_of_msg|><... |
[
"Bug Fix",
"Q/A"
] | beginner | [
{
"role": "user",
"content": "In a strict Roblox building-tool module, this helper complains that Transparency isn't on Instance, and that candidate might be nil:\n```luau\n--!strict\nlocal function paintMarker(candidate: Instance?)\n candidate.Transparency = 0.5\nend\n```\nA marker is supposed to be a P... | <|open|>message role="system" type="thinking-effort"<|sep|>`thinking_effort` guides on how much to think in your thinking channel (not including the response channel), supported values include `low`, `medium`, `high`, and `max`.
Now the system is invoked with `thinking_effort=max`.<|close|>message<|sep|><|end_of_msg|><... |
[
"Generation",
"Q/A"
] | intermediate | [
{
"role": "user",
"content": "Can you write a strict StackCount ModuleScript for my Roblox inventory-data validator? parse(text) should accept counts 1 through 999, integers only, and return either a number or an explanation. Normal Luau tonumber syntax is fine. I'd prefer a tagged result instead of throwin... | <|open|>message role="system" type="thinking-effort"<|sep|>`thinking_effort` guides on how much to think in your thinking channel (not including the response channel), supported values include `low`, `medium`, `high`, and `max`.
Now the system is invoked with `thinking_effort=max`.<|close|>message<|sep|><|end_of_msg|><... |
[
"Debugging",
"Bug Fix",
"Refactor"
] | intermediate | [
{
"role": "user",
"content": "This pure helper is used by my Studio asset-name importer. Invalid size text is supposed to produce nil and a message, but the pcall says success and then I get an arithmetic error.\n```luau\nlocal function parseSize(text)\n local value = tonumber(text)\n if value == nil ... | <|open|>message role="system" type="thinking-effort"<|sep|>`thinking_effort` guides on how much to think in your thinking channel (not including the response channel), supported values include `low`, `medium`, `high`, and `max`.
Now the system is invoked with `thinking_effort=max`.<|close|>message<|sep|><|end_of_msg|><... |
[
"Bug Fix",
"Refactor"
] | intermediate | [
{
"role": "user",
"content": "My Roblox build-manifest exporter sorts entries by priority, highest first. Priorities are finite numbers and IDs are unique strings. Equal-priority entries move around when the input order changes, so exports get noisy diffs.\n```luau\ntable.sort(entries, function(a, b)\n r... | <|open|>message role="system" type="thinking-effort"<|sep|>`thinking_effort` guides on how much to think in your thinking channel (not including the response channel), supported values include `low`, `medium`, `high`, and `max`.
Now the system is invoked with `thinking_effort=max`.<|close|>message<|sep|><|end_of_msg|><... |
[
"Generation",
"Q/A"
] | intermediate | [
{
"role": "user",
"content": "I need an AssetChoice ModuleScript in ReplicatedStorage for selecting an asset ID from a dense array. Empty pools should return nil, not error. Please accept a Roblox Random object so tests can supply their own seed, and don't modify the pool. A generic typed function would be ... | <|open|>message role="system" type="thinking-effort"<|sep|>`thinking_effort` guides on how much to think in your thinking channel (not including the response channel), supported values include `low`, `medium`, `high`, and `max`.
Now the system is invoked with `thinking_effort=max`.<|close|>message<|sep|><|end_of_msg|><... |
[
"Generation",
"Q/A"
] | advanced | [
{
"role": "user",
"content": "Write a pure MapStyleWeights ModuleScript in ServerScriptService. Input is a dense array of {id: string, weight: number}. Nonnegative integer weights only, and cap total tickets at 1,000,000 as our own data rule. Zero-weight styles must never win. Empty/all-zero pools return ni... | <|open|>message role="system" type="thinking-effort"<|sep|>`thinking_effort` guides on how much to think in your thinking channel (not including the response channel), supported values include `low`, `medium`, `high`, and `max`.
Now the system is invoked with `thinking_effort=max`.<|close|>message<|sep|><|end_of_msg|><... |
[
"Debugging",
"Refactor"
] | intermediate | [
{
"role": "user",
"content": "My Studio source-analysis module uses session tables as weak cache keys. Dropping the session variable doesn't seem to release its entry while work is pending. This is the relevant code; pending is a normal module-local table, not task.spawn work.\n```luau\nlocal cache = setmet... | <|open|>message role="system" type="thinking-effort"<|sep|>`thinking_effort` guides on how much to think in your thinking channel (not including the response channel), supported values include `low`, `medium`, `high`, and `max`.
Now the system is invoked with `thinking_effort=max`.<|close|>message<|sep|><|end_of_msg|><... |
[
"Debugging",
"Refactor",
"Bug Fix"
] | advanced | [
{
"role": "user",
"content": "My item-description utility stops during require. These are sibling ModuleScripts in ServerScriptService.ItemTools. Is returning the table earlier or adding a wait the right fix?\n```luau\n-- ItemBook\nlocal FormatItem = require(script.Parent.FormatItem)\nlocal ItemBook = {}\nI... | <|open|>message role="system" type="thinking-effort"<|sep|>`thinking_effort` guides on how much to think in your thinking channel (not including the response channel), supported values include `low`, `medium`, `high`, and `max`.
Now the system is invoked with `thinking_effort=max`.<|close|>message<|sep|><|end_of_msg|><... |
[
"Q/A",
"Generation"
] | beginner | [
{
"role": "user",
"content": "ReplicatedStorage.BuildCounter is a ModuleScript containing `return { value = 0 }`. An ordinary server Script requires it and sets value to 10. My LocalScript requires the same ModuleScript but still reads 0. Neither uses Actors. I thought require caches one table, so why isn't... | <|open|>message role="system" type="thinking-effort"<|sep|>`thinking_effort` guides on how much to think in your thinking channel (not including the response channel), supported values include `low`, `medium`, `high`, and `max`.
Now the system is invoked with `thinking_effort=max`.<|close|>message<|sep|><|end_of_msg|><... |
[
"Bug Fix",
"Generation"
] | beginner | [
{
"role": "user",
"content": "I'm making plain track records for a Roblox timeline-authoring utility, not creating Animation instances yet. Why does renaming track 1 rename every track?\n```luau\nlocal tracks = table.create(3, { name = \"\", keyframes = {} })\ntracks[1].name = \"Opening\"\nassert(tracks[2].... | <|open|>message role="system" type="thinking-effort"<|sep|>`thinking_effort` guides on how much to think in your thinking channel (not including the response channel), supported values include `low`, `medium`, `high`, and `max`.
Now the system is invoked with `thinking_effort=max`.<|close|>message<|sep|><|end_of_msg|><... |
[
"Bug Fix",
"Q/A"
] | beginner | [
{
"role": "user",
"content": "My Roblox building-tool module has a pure coordinate snap helper. Inputs are finite coordinates from -10000 to 10000; supported steps are 0.25, 1, and 2. Negative halfway coordinates snap toward zero, which looks asymmetric.\n```luau\nlocal function snapCoordinate(value: number... | <|open|>message role="system" type="thinking-effort"<|sep|>`thinking_effort` guides on how much to think in your thinking channel (not including the response channel), supported values include `low`, `medium`, `high`, and `max`.
Now the system is invoked with `thinking_effort=max`.<|close|>message<|sep|><|end_of_msg|><... |
[
"Bug Fix",
"Generation"
] | intermediate | [
{
"role": "user",
"content": "My Studio asset-renaming plugin uses this local helper on names. I only need the returned string for now. Searching for Ore[Old].v1 doesn't match that literal text, and replacement names can contain percent signs. Empty search strings should be rejected.\n```luau\nlocal functio... | <|open|>message role="system" type="thinking-effort"<|sep|>`thinking_effort` guides on how much to think in your thinking channel (not including the response channel), supported values include `low`, `medium`, `high`, and `max`.
Now the system is invoked with `thinking_effort=max`.<|close|>message<|sep|><|end_of_msg|><... |
[
"Review",
"Q/A"
] | beginner | [
{
"role": "user",
"content": "Please review this lookup in my Roblox achievement-import utility. Missing IDs are intentionally nil and IDs are case-sensitive strings. The table is local, plain, and initialized before calls.\n```luau\n--!strict\ntype Achievement = { label: string, unlocked: boolean }\nlocal ... | <|open|>message role="system" type="thinking-effort"<|sep|>`thinking_effort` guides on how much to think in your thinking channel (not including the response channel), supported values include `low`, `medium`, `high`, and `max`.
Now the system is invoked with `thinking_effort=max`.<|close|>message<|sep|><|end_of_msg|><... |
[
"Debugging",
"Bug Fix"
] | beginner | [
{
"role": "user",
"content": "My Roblox banner selector does nothing. ChooseBanner is a RemoteEvent in ReplicatedStorage. The LocalScript in StarterPlayerScripts sends this:\n```luau\nChooseBanner:FireServer(game.Players.LocalPlayer, \"Blue\")\n```\nThe Script in ServerScriptService has this handler. The pr... | <|open|>message role="system" type="thinking-effort"<|sep|>`thinking_effort` guides on how much to think in your thinking channel (not including the response channel), supported values include `low`, `medium`, `high`, and `max`.
Now the system is invoked with `thinking_effort=max`.<|close|>message<|sep|><|end_of_msg|><... |
[
"Review",
"Bug Fix",
"Q/A"
] | intermediate | [
{
"role": "user",
"content": "Review the quantity check in my session-only ticket exchange. In a ServerScriptService Script, ExchangeTickets.OnServerEvent supplies player and quantity. A non-yielding admission check already limits requests to four per second per player. profiles[player] is server-owned, exi... | <|open|>message role="system" type="thinking-effort"<|sep|>`thinking_effort` guides on how much to think in your thinking channel (not including the response channel), supported values include `low`, `medium`, `high`, and `max`.
Now the system is invoked with `thinking_effort=max`.<|close|>message<|sep|><|end_of_msg|><... |
[
"Review",
"Bug Fix"
] | intermediate | [
{
"role": "user",
"content": "Can you review this small cosmetic unlock endpoint? BuyStyle is a RemoteEvent in ReplicatedStorage. This is server code; allowPurchase is an existing non-yielding per-player limiter, and sessions is a server table cleaned on PlayerRemoving. Each session has coins and an unlocke... | <|open|>message role="system" type="thinking-effort"<|sep|>`thinking_effort` guides on how much to think in your thinking channel (not including the response channel), supported values include `low`, `medium`, `high`, and `max`.
Now the system is invoked with `thinking_effort=max`.<|close|>message<|sep|><|end_of_msg|><... |
[
"Bug Fix",
"Q/A"
] | intermediate | [
{
"role": "user",
"content": "I have a logical loadout, not Tool instances. ReplicatedStorage.ItemDefinitions contains direct Configuration children named Lantern and Compass, with unique names. Profiles are server-only tables: profiles[player] = {owned = {Lantern = true}, equipped = nil}. SetLoadoutItem is... | <|open|>message role="system" type="thinking-effort"<|sep|>`thinking_effort` guides on how much to think in your thinking channel (not including the response channel), supported values include `low`, `medium`, `high`, and `max`.
Now the system is invoked with `thinking_effort=max`.<|close|>message<|sep|><|end_of_msg|><... |
[
"Bug Fix",
"Generation"
] | intermediate | [
{
"role": "user",
"content": "My lobby chime has a five-second LocalScript cooldown, but our tester can trigger it repeatedly by calling the remote directly. RequestChime and ChimePlayed are RemoteEvents in ReplicatedStorage. Currently the server just fires ChimePlayed to everyone with the sender's UserId. ... | <|open|>message role="system" type="thinking-effort"<|sep|>`thinking_effort` guides on how much to think in your thinking channel (not including the response channel), supported values include `low`, `medium`, `high`, and `max`.
Now the system is invoked with `thinking_effort=max`.<|close|>message<|sep|><|end_of_msg|><... |
[
"Debugging",
"Bug Fix"
] | advanced | [
{
"role": "user",
"content": "Two players both get true from ClaimBriefingSlot, although there's only one logical briefing slot. This is a RemoteFunction in ReplicatedStorage, handled in one ordinary server Script. No Actors. isEligible yields while a server worker answers. Can you explain the race before p... | <|open|>message role="system" type="thinking-effort"<|sep|>`thinking_effort` guides on how much to think in your thinking channel (not including the response channel), supported values include `low`, `medium`, `high`, and `max`.
Now the system is invoked with `thinking_effort=max`.<|close|>message<|sep|><|end_of_msg|><... |
[
"Debugging",
"Bug Fix",
"Q/A"
] | advanced | [
{
"role": "user",
"content": "My client board sometimes goes backwards during bootstrap. GetBoard is a RemoteFunction and BoardChanged a RemoteEvent, both in ReplicatedStorage. Every payload is a full {revision, red, blue} snapshot; revision increases for the server lifetime. I saw a BoardChanged revision 1... | <|open|>message role="system" type="thinking-effort"<|sep|>`thinking_effort` guides on how much to think in your thinking channel (not including the response channel), supported values include `low`, `medium`, `high`, and `max`.
Now the system is invoked with `thinking_effort=max`.<|close|>message<|sep|><|end_of_msg|><... |
[
"Debugging",
"Bug Fix",
"Q/A"
] | intermediate | [
{
"role": "user",
"content": "ReplicatedStorage.MatchState is a Folder created in Studio. The server sets its Mode attribute to Waiting at startup. In a StarterPlayerScripts LocalScript I connect GetAttributeChangedSignal(\"Mode\"), but I get no initial print until the server changes it to Playing. Does the... | <|open|>message role="system" type="thinking-effort"<|sep|>`thinking_effort` guides on how much to think in your thinking channel (not including the response channel), supported values include `low`, `medium`, `high`, and `max`.
Now the system is invoked with `thinking_effort=max`.<|close|>message<|sep|><|end_of_msg|><... |
[
"Review",
"Ideas",
"Q/A"
] | advanced | [
{
"role": "user",
"content": "Our match coordinator loops over players and calls ApproveMatch:InvokeClient(player). The client checks a locally displayed access flag and returns true or false. A false answer excludes them. Sometimes the whole coordinator stops at one player. Could I wrap InvokeClient in pca... | <|open|>message role="system" type="thinking-effort"<|sep|>`thinking_effort` guides on how much to think in your thinking channel (not including the response channel), supported values include `low`, `medium`, `high`, and `max`.
Now the system is invoked with `thinking_effort=max`.<|close|>message<|sep|><|end_of_msg|><... |
[
"Generation",
"Q/A"
] | intermediate | [
{
"role": "user",
"content": "I need a server-side limiter for RequestForecast, a RemoteEvent in ReplicatedStorage. It returns the current public forecast string only to the requester. Allow a burst of three and then two requests per second, independently per player. Can this be lazy instead of running a lo... | <|open|>message role="system" type="thinking-effort"<|sep|>`thinking_effort` guides on how much to think in your thinking channel (not including the response channel), supported values include `low`, `medium`, `high`, and `max`.
Now the system is invoked with `thinking_effort=max`.<|close|>message<|sep|><|end_of_msg|><... |
[
"Review",
"Q/A"
] | beginner | [
{
"role": "user",
"content": "Review this Roblox server notification: PrivateQuest:FireAllClients(owner.UserId, secretObjective). Each LocalScript immediately returns unless the supplied ID is LocalPlayer.UserId. Does that keep the objective private from other players?",
"reasoning": null,
"reasonin... | <|open|>message role="system" type="thinking-effort"<|sep|>`thinking_effort` guides on how much to think in your thinking channel (not including the response channel), supported values include `low`, `medium`, `high`, and `max`.
Now the system is invoked with `thinking_effort=max`.<|close|>message<|sep|><|end_of_msg|><... |
[
"Debugging",
"Q/A"
] | intermediate | [
{
"role": "user",
"content": "A LocalScript creates a placement preview Part under Workspace, then sends it through RequestPlacement:FireServer(preview). The server receives nil for that argument. I can see the Part on my client. Is the remote too early?",
"reasoning": null,
"reasoning_1": null,
... | <|open|>message role="system" type="thinking-effort"<|sep|>`thinking_effort` guides on how much to think in your thinking channel (not including the response channel), supported values include `low`, `medium`, `high`, and `max`.
Now the system is invoked with `thinking_effort=max`.<|close|>message<|sep|><|end_of_msg|><... |
[
"Debugging",
"Bug Fix"
] | intermediate | [
{
"role": "user",
"content": "On the server I set RoundState's Winner attribute and immediately fire ShowWinner. Occasionally a client reads the old attribute in its ShowWinner callback. RoundState and the RemoteEvent are in ReplicatedStorage. Can I fix it with task.wait(0.2) before reading?",
"reasonin... | <|open|>message role="system" type="thinking-effort"<|sep|>`thinking_effort` guides on how much to think in your thinking channel (not including the response channel), supported values include `low`, `medium`, `high`, and `max`.
Now the system is invoked with `thinking_effort=max`.<|close|>message<|sep|><|end_of_msg|><... |
[
"Q/A",
"Review"
] | intermediate | [
{
"role": "user",
"content": "Our Roblox client attaches an increasing requestId to crafting requests so replies can find the correct pending UI row. A teammate says this prevents forged requests because the server can check that the ID is new. Is that a security property?",
"reasoning": null,
"reas... | <|open|>message role="system" type="thinking-effort"<|sep|>`thinking_effort` guides on how much to think in your thinking channel (not including the response channel), supported values include `low`, `medium`, `high`, and `max`.
Now the system is invoked with `thinking_effort=max`.<|close|>message<|sep|><|end_of_msg|><... |
[
"Generation",
"Q/A"
] | intermediate | [
{
"role": "user",
"content": "Write just a server validator for selected cosmetic badge IDs. The remote argument should be a dense array of 1-4 distinct strings from allowed = {Builder=true, Explorer=true, Helper=true, Artist=true}. Return boolean, no side effects. Our handler already limits requests. Don't... | <|open|>message role="system" type="thinking-effort"<|sep|>`thinking_effort` guides on how much to think in your thinking channel (not including the response channel), supported values include `low`, `medium`, `high`, and `max`.
Now the system is invoked with `thinking_effort=max`.<|close|>message<|sep|><|end_of_msg|><... |
[
"Review",
"Bug Fix"
] | intermediate | [
{
"role": "user",
"content": "Review a server vote operation. Each round we clear votes and set votingOpen=true. The remote callback takes player and mapId, validates mapId against our server ballot, then does votes[player]=mapId. We have a limiter and remove departed players. I forgot to check votingOpen. ... | <|open|>message role="system" type="thinking-effort"<|sep|>`thinking_effort` guides on how much to think in your thinking channel (not including the response channel), supported values include `low`, `medium`, `high`, and `max`.
Now the system is invoked with `thinking_effort=max`.<|close|>message<|sep|><|end_of_msg|><... |
[
"Debugging",
"Ideas"
] | intermediate | [
{
"role": "user",
"content": "In my Roblox tutorial the server fires StartTutorial from PlayerAdded. Sometimes the StarterPlayerScripts LocalScript doesn't show it. Its OnClientEvent connection is created after loading UI assets. Would firing the event three times solve startup?",
"reasoning": null,
... | <|open|>message role="system" type="thinking-effort"<|sep|>`thinking_effort` guides on how much to think in your thinking channel (not including the response channel), supported values include `low`, `medium`, `high`, and `max`.
Now the system is invoked with `thinking_effort=max`.<|close|>message<|sep|><|end_of_msg|><... |
[
"Review",
"Q/A"
] | beginner | [
{
"role": "user",
"content": "My own experience has a moderator panel. I hide it unless LocalPlayer has IsModerator=true, then a remote accepts a target UserId and kicks them. The server trusts that only moderators can see the button. What's the necessary security change?",
"reasoning": null,
"reaso... | <|open|>message role="system" type="thinking-effort"<|sep|>`thinking_effort` guides on how much to think in your thinking channel (not including the response channel), supported values include `low`, `medium`, `high`, and `max`.
Now the system is invoked with `thinking_effort=max`.<|close|>message<|sep|><|end_of_msg|><... |
[
"Review",
"Q/A"
] | beginner | [
{
"role": "user",
"content": "Review just this server fragment for a free title preference. Titles are fixed server-authored strings. A per-player limiter runs first, and player is the implicit OnServerEvent sender. No currency or unlocks are involved.\n```luau\nlocal titles = {Builder = true, Explorer = tr... | <|open|>message role="system" type="thinking-effort"<|sep|>`thinking_effort` guides on how much to think in your thinking channel (not including the response channel), supported values include `low`, `medium`, `high`, and `max`.
Now the system is invoked with `thinking_effort=max`.<|close|>message<|sep|><|end_of_msg|><... |
[
"Debugging",
"Refactor"
] | beginner | [
{
"role": "user",
"content": "Two server Scripts assign GetMenu.OnServerInvoke. One returns the shop menu, another returns crafting recipes. Only one seems to run. Can I use OnServerInvoke:Connect instead so both return?",
"reasoning": null,
"reasoning_1": null,
"reasoning_2": null,
"reasoni... | <|open|>message role="system" type="thinking-effort"<|sep|>`thinking_effort` guides on how much to think in your thinking channel (not including the response channel), supported values include `low`, `medium`, `high`, and `max`.
Now the system is invoked with `thinking_effort=max`.<|close|>message<|sep|><|end_of_msg|><... |
[
"Debugging",
"Bug Fix",
"Q/A"
] | beginner | [
{
"role": "user",
"content": "My Roblox HUD gets darker after each reset because there are several copies on top of each other. StatusHud is a ScreenGui in ReplicatedStorage with ResetOnSpawn false. This LocalScript is in StarterCharacterScripts:\n```luau\nlocal Players = game:GetService(\"Players\")\nlocal... | <|open|>message role="system" type="thinking-effort"<|sep|>`thinking_effort` guides on how much to think in your thinking channel (not including the response channel), supported values include `low`, `medium`, `high`, and `max`.
Now the system is invoked with `thinking_effort=max`.<|close|>message<|sep|><|end_of_msg|><... |
[
"Bug Fix",
"Q/A"
] | intermediate | [
{
"role": "user",
"content": "StatusHud has ResetOnSpawn false and a TextLabel named Health. Its LocalScript binds HealthChanged once to the first character, so after resetting it keeps showing the old health. Can you replace the binding? Just show whole-number health, and show a dash while there isn't a Hu... | <|open|>message role="system" type="thinking-effort"<|sep|>`thinking_effort` guides on how much to think in your thinking channel (not including the response channel), supported values include `low`, `medium`, `high`, and `max`.
Now the system is invoked with `thinking_effort=max`.<|close|>message<|sep|><|end_of_msg|><... |
[
"Debugging",
"Bug Fix"
] | beginner | [
{
"role": "user",
"content": "All three color buttons set Preview.Text to the same color. This LocalScript runs once inside my ScreenGui; Colors contains only the three TextButtons. Preview is just a TextLabel, not a purchase system.\n```luau\nlocal gui = script.Parent\nlocal chosenName\nfor _, button in gu... | <|open|>message role="system" type="thinking-effort"<|sep|>`thinking_effort` guides on how much to think in your thinking channel (not including the response channel), supported values include `low`, `medium`, `high`, and `max`.
Now the system is invoked with `thinking_effort=max`.<|close|>message<|sep|><|end_of_msg|><... |
[
"Q/A",
"Generation"
] | beginner | [
{
"role": "user",
"content": "My Roblox help menu has a TextButton to close it. I'm using MouseButton1Click. Is Activated the better event for mouse, touch, and a controller? I only mean ordinary press-and-release activation, not dragging or holding.",
"reasoning": null,
"reasoning_1": null,
"re... | <|open|>message role="system" type="thinking-effort"<|sep|>`thinking_effort` guides on how much to think in your thinking channel (not including the response channel), supported values include `low`, `medium`, `high`, and `max`.
Now the system is invoked with `thinking_effort=max`.<|close|>message<|sep|><|end_of_msg|><... |
[
"Bug Fix",
"Generation"
] | intermediate | [
{
"role": "user",
"content": "A persistent HelpGui has a Panel and one LocalScript. Pressing K toggles it, including while I type K into a TextBox. The current handler ignores the second InputBegan parameter. What should the handler check? Keep the GUI lifecycle cleanup too.",
"reasoning": null,
"re... | <|open|>message role="system" type="thinking-effort"<|sep|>`thinking_effort` guides on how much to think in your thinking channel (not including the response channel), supported values include `low`, `medium`, `high`, and `max`.
Now the system is invoked with `thinking_effort=max`.<|close|>message<|sep|><|end_of_msg|><... |
[
"Bug Fix",
"Q/A"
] | intermediate | [
{
"role": "user",
"content": "My StarterPlayerScripts controller binds a ContextActionService action called InspectHold while a tool mode is active. The callback sets holding=true on Begin and false on End. Leaving the mode calls UnbindAction, but sometimes holding stays true. What cleanup am I missing?",
... | <|open|>message role="system" type="thinking-effort"<|sep|>`thinking_effort` guides on how much to think in your thinking channel (not including the response channel), supported values include `low`, `medium`, `high`, and `max`.
Now the system is invoked with `thinking_effort=max`.<|close|>message<|sep|><|end_of_msg|><... |
[
"Debugging",
"Bug Fix"
] | intermediate | [
{
"role": "user",
"content": "A LocalScript tweens a panel closed. Its tween.Completed callback sets panel.Visible=false. If I reopen before closing finishes, I cancel the close tween but the panel still disappears. Does Cancel fire Completed?",
"reasoning": null,
"reasoning_1": null,
"reasoning... | <|open|>message role="system" type="thinking-effort"<|sep|>`thinking_effort` guides on how much to think in your thinking channel (not including the response channel), supported values include `low`, `medium`, `high`, and `max`.
Now the system is invoked with `thinking_effort=max`.<|close|>message<|sep|><|end_of_msg|><... |
[
"Generation",
"Bug Fix"
] | intermediate | [
{
"role": "user",
"content": "Write a tiny local toast helper for an existing TextLabel. show(text) should show it for two seconds; a second call replaces the message and restarts the time. My old task.delay callbacks hide the newer message early. Return a destroy function too. No animations.",
"reasoni... | <|open|>message role="system" type="thinking-effort"<|sep|>`thinking_effort` guides on how much to think in your thinking channel (not including the response channel), supported values include `low`, `medium`, `high`, and `max`.
Now the system is invoked with `thinking_effort=max`.<|close|>message<|sep|><|end_of_msg|><... |
[
"Refactor",
"Q/A"
] | intermediate | [
{
"role": "user",
"content": "Refactor my local spinning-preview setup to make its lifecycle explicit. It connects RunService.RenderStepped and rotates an anchored preview Part. The preview owner already knows when to close and can call cleanup before destroying the Part. Give me an attach function returnin... | <|open|>message role="system" type="thinking-effort"<|sep|>`thinking_effort` guides on how much to think in your thinking channel (not including the response channel), supported values include `low`, `medium`, `high`, and `max`.
Now the system is invoked with `thinking_effort=max`.<|close|>message<|sep|><|end_of_msg|><... |
[
"Bug Fix",
"Q/A"
] | intermediate | [
{
"role": "user",
"content": "A server Script installed during a Studio test only connects Players.PlayerAdded, so players already in the server never get an entry in my session table. Is GetPlayers at startup enough? Entries are just {score=0}, no persistence.",
"reasoning": null,
"reasoning_1": nu... | <|open|>message role="system" type="thinking-effort"<|sep|>`thinking_effort` guides on how much to think in your thinking channel (not including the response channel), supported values include `low`, `medium`, `high`, and `max`.
Now the system is invoked with `thinking_effort=max`.<|close|>message<|sep|><|end_of_msg|><... |
[
"Debugging",
"Bug Fix"
] | intermediate | [
{
"role": "user",
"content": "In StarterPlayerScripts I handle CharacterAdded with `local root = character:WaitForChild(\"HumanoidRootPart\")` and then assign trackedRoot=root. Rarely trackedRoot points at an old character after a fast respawn. The event argument is definitely right when the callback starts... | <|open|>message role="system" type="thinking-effort"<|sep|>`thinking_effort` guides on how much to think in your thinking channel (not including the response channel), supported values include `low`, `medium`, `high`, and `max`.
Now the system is invoked with `thinking_effort=max`.<|close|>message<|sep|><|end_of_msg|><... |
[
"Debugging",
"Bug Fix"
] | beginner | [
{
"role": "user",
"content": "My Tool LocalScript connects tool.Activated inside tool.Equipped. After equipping three times, clicking prints Swing three times. The tool itself stays the same Instance in the Backpack between equips. What's the smallest fix?",
"reasoning": null,
"reasoning_1": null,
... | <|open|>message role="system" type="thinking-effort"<|sep|>`thinking_effort` guides on how much to think in your thinking channel (not including the response channel), supported values include `low`, `medium`, `high`, and `max`.
Now the system is invoked with `thinking_effort=max`.<|close|>message<|sep|><|end_of_msg|><... |
[
"Debugging",
"Q/A"
] | beginner | [
{
"role": "user",
"content": "My ScrollingFrame has UIListLayout and dynamically cloned fixed-height inventory rows. The scrollbar doesn't get longer when I add rows. I only need vertical scrolling. Is increasing the ScrollingFrame.Size the solution?",
"reasoning": null,
"reasoning_1": null,
"re... | <|open|>message role="system" type="thinking-effort"<|sep|>`thinking_effort` guides on how much to think in your thinking channel (not including the response channel), supported values include `low`, `medium`, `high`, and `max`.
Now the system is invoked with `thinking_effort=max`.<|close|>message<|sep|><|end_of_msg|><... |
[
"Q/A",
"Bug Fix"
] | beginner | [
{
"role": "user",
"content": "My popup Position is UDim2.fromScale(0.5, 0.5), but it looks down and right of center. Its AnchorPoint is 0,0. Is Roblox calculating half the screen incorrectly? It's inside a full-size Frame.",
"reasoning": null,
"reasoning_1": null,
"reasoning_2": null,
"reaso... | <|open|>message role="system" type="thinking-effort"<|sep|>`thinking_effort` guides on how much to think in your thinking channel (not including the response channel), supported values include `low`, `medium`, `high`, and `max`.
Now the system is invoked with `thinking_effort=max`.<|close|>message<|sep|><|end_of_msg|><... |
[
"Bug Fix",
"Q/A"
] | intermediate | [
{
"role": "user",
"content": "My client displays a round countdown by subtracting one after every task.wait(1). After some lag it says 3 while the round has already ended. The server provides roundEndsAt using workspace:GetServerTimeNow(). What should I display?",
"reasoning": null,
"reasoning_1": n... | <|open|>message role="system" type="thinking-effort"<|sep|>`thinking_effort` guides on how much to think in your thinking channel (not including the response channel), supported values include `low`, `medium`, `high`, and `max`.
Now the system is invoked with `thinking_effort=max`.<|close|>message<|sep|><|end_of_msg|><... |
[
"Debugging",
"Q/A"
] | intermediate | [
{
"role": "user",
"content": "My own character's animation plays locally but others don't see it. The LocalScript creates an Animator under the Humanoid if none is found, then loads an Animation. Could that local creation matter?",
"reasoning": null,
"reasoning_1": null,
"reasoning_2": null,
... | <|open|>message role="system" type="thinking-effort"<|sep|>`thinking_effort` guides on how much to think in your thinking channel (not including the response channel), supported values include `low`, `medium`, `high`, and `max`.
Now the system is invoked with `thinking_effort=max`.<|close|>message<|sep|><|end_of_msg|><... |
[
"Debugging",
"Bug Fix"
] | intermediate | [
{
"role": "user",
"content": "I reuse one AnimationTrack for a local reload preview. Every Play button click connects GetMarkerReachedSignal('Insert') again, then calls track:Play(). After several previews the marker sound plays multiple times. The track stays alive when the panel closes.",
"reasoning":... | <|open|>message role="system" type="thinking-effort"<|sep|>`thinking_effort` guides on how much to think in your thinking channel (not including the response channel), supported values include `low`, `medium`, `high`, and `max`.
Now the system is invoked with `thinking_effort=max`.<|close|>message<|sep|><|end_of_msg|><... |
[
"Generation",
"Q/A"
] | beginner | [
{
"role": "user",
"content": "For a local menu, I have a looping Sound named MenuLoop inside SoundService. How do I make closing the menu stop the audio but opening it again start at the beginning? Please distinguish Stop from Pause.",
"reasoning": null,
"reasoning_1": null,
"reasoning_2": null,... | <|open|>message role="system" type="thinking-effort"<|sep|>`thinking_effort` guides on how much to think in your thinking channel (not including the response channel), supported values include `low`, `medium`, `high`, and `max`.
Now the system is invoked with `thinking_effort=max`.<|close|>message<|sep|><|end_of_msg|><... |
[
"Review",
"Q/A"
] | intermediate | [
{
"role": "user",
"content": "My client cutscene captures workspace.CurrentCamera, sets CameraType=Scriptable, and writes CFrame on RenderStepped. At the end it sets CameraType=Custom but forgets to disconnect. Review that cleanup only.",
"reasoning": null,
"reasoning_1": null,
"reasoning_2": nu... | <|open|>message role="system" type="thinking-effort"<|sep|>`thinking_effort` guides on how much to think in your thinking channel (not including the response channel), supported values include `low`, `medium`, `high`, and `max`.
Now the system is invoked with `thinking_effort=max`.<|close|>message<|sep|><|end_of_msg|><... |
[
"Bug Fix",
"Q/A"
] | intermediate | [
{
"role": "user",
"content": "My Roblox dialogue uses string.sub(text, 1, i) to reveal one character at a time in a TextLabel. Emoji sometimes become broken symbols. Is #text the wrong count? RichText is enabled too.",
"reasoning": null,
"reasoning_1": null,
"reasoning_2": null,
"reasoning_3... | <|open|>message role="system" type="thinking-effort"<|sep|>`thinking_effort` guides on how much to think in your thinking channel (not including the response channel), supported values include `low`, `medium`, `high`, and `max`.
Now the system is invoked with `thinking_effort=max`.<|close|>message<|sep|><|end_of_msg|><... |
[
"Debugging",
"Bug Fix"
] | beginner | [
{
"role": "user",
"content": "My server turret casts toward a target, but hits depend on where I put the whole arena. These are world positions. What's wrong with this call?\n```luau\nlocal origin = muzzle.WorldPosition\nlocal hit = workspace:Raycast(origin, target.Position, params)\n```\nThe target is a Pa... | <|open|>message role="system" type="thinking-effort"<|sep|>`thinking_effort` guides on how much to think in your thinking channel (not including the response channel), supported values include `low`, `medium`, `high`, and `max`.
Now the system is invoked with `thinking_effort=max`.<|close|>message<|sep|><|end_of_msg|><... |
[
"Q/A",
"Generation"
] | intermediate | [
{
"role": "user",
"content": "I'm placing ore beside a rotated mining machine. In a server Script I use machine.Position + Vector3.new(4, 0, 0), but it always goes east instead of to the machine's right. machine is a BasePart. Can you give me a little placement function? The ore is an anchored BasePart.",
... | <|open|>message role="system" type="thinking-effort"<|sep|>`thinking_effort` guides on how much to think in your thinking channel (not including the response channel), supported values include `low`, `medium`, `high`, and `max`.
Now the system is invoked with `thinking_effort=max`.<|close|>message<|sep|><|end_of_msg|><... |
[
"Bug Fix",
"Q/A"
] | intermediate | [
{
"role": "user",
"content": "A cargo Model has a Socket Attachment inside one of its parts. My server docking code calls cargo:PivotTo(bay.WorldCFrame), where bay is another Attachment. The model pivot reaches the bay, but the Socket is several studs off. The cargo is anchored scenery while docking; I don'... | <|open|>message role="system" type="thinking-effort"<|sep|>`thinking_effort` guides on how much to think in your thinking channel (not including the response channel), supported values include `low`, `medium`, `high`, and `max`.
Now the system is invoked with `thinking_effort=max`.<|close|>message<|sep|><|end_of_msg|><... |
[
"Q/A",
"Generation"
] | intermediate | [
{
"role": "user",
"content": "For a server-controlled crate launcher, is ApplyImpulse just another way to set AssemblyLinearVelocity? Heavy crates barely move with my fixed impulse. Each crate is a single unanchored assembly, and I assign it to the server before launching. I want to add 30 studs/sec upward ... | <|open|>message role="system" type="thinking-effort"<|sep|>`thinking_effort` guides on how much to think in your thinking channel (not including the response channel), supported values include `low`, `medium`, `high`, and `max`.
Now the system is invoked with `thinking_effort=max`.<|close|>message<|sep|><|end_of_msg|><... |
[
"Debugging",
"Bug Fix"
] | beginner | [
{
"role": "user",
"content": "My physics cart won't fall. Body.Anchored is false and its server Script sets AssemblyLinearVelocity downward. It has a Sign welded to Body with a WeldConstraint. Sign.Anchored is true because I didn't want the sign to wobble. Is the velocity API broken?",
"reasoning": null... | <|open|>message role="system" type="thinking-effort"<|sep|>`thinking_effort` guides on how much to think in your thinking channel (not including the response channel), supported values include `low`, `medium`, `high`, and `max`.
Now the system is invoked with `thinking_effort=max`.<|close|>message<|sep|><|end_of_msg|><... |
[
"Review",
"Bug Fix",
"Q/A"
] | intermediate | [
{
"role": "user",
"content": "Review this server bolt query configuration. It hits walls but passes through a shield that is CanCollide=false, CanQuery=true. The shield must block bolts without pushing bodies. turret is a Model, and Decorations is an existing Folder containing visual-only parts.\n```luau\nl... | <|open|>message role="system" type="thinking-effort"<|sep|>`thinking_effort` guides on how much to think in your thinking channel (not including the response channel), supported values include `low`, `medium`, `high`, and `max`.
Now the system is invoked with `thinking_effort=max`.<|close|>message<|sep|><|end_of_msg|><... |
[
"Bug Fix",
"Generation"
] | intermediate | [
{
"role": "user",
"content": "My one-use crumble tile schedules its fall several times because Touched fires for both feet and other limbs. I don't want a cooldown: the first living humanoid touching it should consume that tile permanently. It's one standalone anchored Part, with a server Script inside it, ... | <|open|>message role="system" type="thinking-effort"<|sep|>`thinking_effort` guides on how much to think in your thinking channel (not including the response channel), supported values include `low`, `medium`, `high`, and `max`.
Now the system is invoked with `thinking_effort=max`.<|close|>message<|sep|><|end_of_msg|><... |
[
"Q/A",
"Generation"
] | intermediate | [
{
"role": "user",
"content": "My enemy NPC is server-scripted but physics ownership sometimes goes to a nearby player. Can I force the server to simulate it? The completed rig is in Workspace, unanchored, and its root and body are one connected assembly. I only need a spawn-time helper, not an NPC framework... | <|open|>message role="system" type="thinking-effort"<|sep|>`thinking_effort` guides on how much to think in your thinking channel (not including the response channel), supported values include `low`, `medium`, `high`, and `max`.
Now the system is invoked with `thinking_effort=max`.<|close|>message<|sep|><|end_of_msg|><... |
[
"Debugging",
"Generation"
] | intermediate | [
{
"role": "user",
"content": "A slow Humanoid NPC stops before a distant waypoint. My server code is humanoid:MoveTo(goal), then local reached = humanoid.MoveToFinished:Wait(). reached becomes false even in an empty test lane. Is false an exception? The trip takes more than eight seconds at its walking spee... | <|open|>message role="system" type="thinking-effort"<|sep|>`thinking_effort` guides on how much to think in your thinking channel (not including the response channel), supported values include `low`, `medium`, `high`, and `max`.
Now the system is invoked with `thinking_effort=max`.<|close|>message<|sep|><|end_of_msg|><... |
[
"Review",
"Bug Fix",
"Generation"
] | advanced | [
{
"role": "user",
"content": "Review just this path-building helper in my server NPC controller. One controller calls it serially, and a separate follower consumes its result. It sometimes gets no useful route when a door closes.\n```luau\nlocal PathfindingService = game:GetService('PathfindingService')\nlo... | <|open|>message role="system" type="thinking-effort"<|sep|>`thinking_effort` guides on how much to think in your thinking channel (not including the response channel), supported values include `low`, `medium`, `high`, and `max`.
Now the system is invoked with `thinking_effort=max`.<|close|>message<|sep|><|end_of_msg|><... |
[
"Debugging",
"Generation",
"Bug Fix"
] | advanced | [
{
"role": "user",
"content": "My server guard recomputes a path to a moving target inside task.spawn on every Heartbeat. Sometimes it turns back to an older target position. Each spawned task creates a Path, computes it, then calls install(path, waypoints). Is PathfindingService mixing up results?",
"re... | <|open|>message role="system" type="thinking-effort"<|sep|>`thinking_effort` guides on how much to think in your thinking channel (not including the response channel), supported values include `low`, `medium`, `high`, and `max`.
Now the system is invoked with `thinking_effort=max`.<|close|>message<|sep|><|end_of_msg|><... |
[
"Debugging",
"Generation"
] | intermediate | [
{
"role": "user",
"content": "With StreamingEnabled, my local beacon lights only appear near spawn. A LocalScript in StarterPlayerScripts loops over CollectionService:GetTagged('WorldBeacon') once and adds lights. The server says distant beacon Parts have the tag too. Is GetTagged only checking nearby objec... | <|open|>message role="system" type="thinking-effort"<|sep|>`thinking_effort` guides on how much to think in your thinking channel (not including the response channel), supported values include `low`, `medium`, `high`, and `max`.
Now the system is invoked with `thinking_effort=max`.<|close|>message<|sep|><|end_of_msg|><... |
[
"Q/A",
"Generation"
] | beginner | [
{
"role": "user",
"content": "workspace:WaitForChild('FarGate') never finishes in my LocalScript until I walk toward the gate. The server has a Part named FarGate directly under Workspace. StreamingEnabled is on. Is a larger wait timeout the right fix? This is for a local world effect, not opening the gate.... | <|open|>message role="system" type="thinking-effort"<|sep|>`thinking_effort` guides on how much to think in your thinking channel (not including the response channel), supported values include `low`, `medium`, `high`, and `max`.
Now the system is invoked with `thinking_effort=max`.<|close|>message<|sep|><|end_of_msg|><... |
[
"Debugging",
"Optimization"
] | intermediate | [
{
"role": "user",
"content": "My server sorter uses GetPartBoundsInBox(sensor.CFrame, sensor.Size, params). A wedge-shaped cargo Part is reported even when only its empty bounding-box corner enters the sensor. I need actual shape intersection, not part-center containment. sensor is a box Part in Workspace, ... | <|open|>message role="system" type="thinking-effort"<|sep|>`thinking_effort` guides on how much to think in your thinking channel (not including the response channel), supported values include `low`, `medium`, `high`, and `max`.
Now the system is invoked with `thinking_effort=max`.<|close|>message<|sep|><|end_of_msg|><... |
[
"Review",
"Bug Fix",
"Q/A"
] | intermediate | [
{
"role": "user",
"content": "Review my turret's line-of-sight rule. It casts from the muzzle to a target NPC's root center, excluding only the turret. I return false if the ray hits anything. It calls the target blocked even in an empty room, because the ray hits the target's chest. Reaching any target par... | <|open|>message role="system" type="thinking-effort"<|sep|>`thinking_effort` guides on how much to think in your thinking channel (not including the response channel), supported values include `low`, `medium`, `high`, and `max`.
Now the system is invoked with `thinking_effort=max`.<|close|>message<|sep|><|end_of_msg|><... |
[
"Bug Fix",
"Q/A"
] | beginner | [
{
"role": "user",
"content": "My anchored turret head should only yaw. I use CFrame.lookAt(head.Position, targetPosition), but it pitches upward when the target jumps. How do I flatten it? This is in the server aiming Script, and the head starts upright.",
"reasoning": null,
"reasoning_1": null,
... | <|open|>message role="system" type="thinking-effort"<|sep|>`thinking_effort` guides on how much to think in your thinking channel (not including the response channel), supported values include `low`, `medium`, `high`, and `max`.
Now the system is invoked with `thinking_effort=max`.<|close|>message<|sep|><|end_of_msg|><... |
[
"Q/A",
"Generation"
] | intermediate | [
{
"role": "user",
"content": "A server-controlled delivery drone keeps flipping its inZone boolean at the edge of a radius-10 loading zone. I compare root distance <= 10 each update. This is about the root point, not the whole drone body. Would rounding the distance be a reasonable fix? I already store inZo... | <|open|>message role="system" type="thinking-effort"<|sep|>`thinking_effort` guides on how much to think in your thinking channel (not including the response channel), supported values include `low`, `medium`, `high`, and `max`.
Now the system is invoked with `thinking_effort=max`.<|close|>message<|sep|><|end_of_msg|><... |
[
"Bug Fix",
"Generation"
] | intermediate | [
{
"role": "user",
"content": "My straight server projectile is slower at low FPS and sometimes skips thin walls. I add velocity / 60 to its position each Heartbeat and only test for overlap at the new position. I already have lifetime cleanup and a caller that stops on impact. Can you provide just step(posi... | <|open|>message role="system" type="thinking-effort"<|sep|>`thinking_effort` guides on how much to think in your thinking channel (not including the response channel), supported values include `low`, `medium`, `high`, and `max`.
Now the system is invoked with `thinking_effort=max`.<|close|>message<|sep|><|end_of_msg|><... |
[
"Review",
"Bug Fix",
"Refactor"
] | intermediate | [
{
"role": "user",
"content": "Review this world-yaw rotation for an anchored display craft Model. It's supposed to spin in place around world Y, but a craft far from the origin makes a big orbit. The Model pivot is deliberately offset from its visual center, and that pivot must stay put.\n```luau\nlocal tur... | <|open|>message role="system" type="thinking-effort"<|sep|>`thinking_effort` guides on how much to think in your thinking channel (not including the response channel), supported values include `low`, `medium`, `high`, and `max`.
Now the system is invoked with `thinking_effort=max`.<|close|>message<|sep|><|end_of_msg|><... |
[
"Ideas",
"Generation"
] | intermediate | [
{
"role": "user",
"content": "I'm designing a Roblox obstacle race with streamed islands. Give me a few checkpoint approaches that keep progression server-authorized but let nearby clients show world-space cues. I don't want storage, GUI, or remote code. Some racers may move through a thin checkpoint betwee... | <|open|>message role="system" type="thinking-effort"<|sep|>`thinking_effort` guides on how much to think in your thinking channel (not including the response channel), supported values include `low`, `medium`, `high`, and `max`.
Now the system is invoked with `thinking_effort=max`.<|close|>message<|sep|><|end_of_msg|><... |
[
"Debugging",
"Bug Fix"
] | intermediate | [
{
"role": "user",
"content": "Some players got zero coins after a DataStore outage. This is inside our server loadPlayer function. decodeProfile rejects malformed profiles; profiles is the table used by autosave. Can you fix the load decision without replacing the persistence system?\n```luau\nlocal ok, raw... | <|open|>message role="system" type="thinking-effort"<|sep|>`thinking_effort` guides on how much to think in your thinking channel (not including the response channel), supported values include `low`, `medium`, `high`, and `max`.
Now the system is invoked with `thinking_effort=max`.<|close|>message<|sep|><|end_of_msg|><... |
[
"Review",
"Bug Fix",
"Q/A"
] | advanced | [
{
"role": "user",
"content": "Review this server helper. store and key refer to one global gate counter, and GateCountCommitted is a server BindableEvent used for a display. Sometimes one call produces two display notifications. Values are nonnegative integers.\n```luau\nlocal function addGateVisit()\n r... | <|open|>message role="system" type="thinking-effort"<|sep|>`thinking_effort` guides on how much to think in your thinking channel (not including the response channel), supported values include `low`, `medium`, `high`, and `max`.
Now the system is invoked with `thinking_effort=max`.<|close|>message<|sep|><|end_of_msg|><... |
[
"Review",
"Bug Fix"
] | advanced | [
{
"role": "user",
"content": "We changed SetAsync to UpdateAsync but still lose settings. Two servers can update the same user's settings while they teleport. Each loaded its own snapshot. Here is our save body:\n```luau\nsettingsStore:UpdateAsync(key, function(_current)\n return cachedSettings\nend)\n``... | <|open|>message role="system" type="thinking-effort"<|sep|>`thinking_effort` guides on how much to think in your thinking channel (not including the response channel), supported values include `low`, `medium`, `high`, and `max`.
Now the system is invoked with `thinking_effort=max`.<|close|>message<|sep|><|end_of_msg|><... |
[
"Generation",
"Q/A"
] | intermediate | [
{
"role": "user",
"content": "Write a small server ProfileSchema ModuleScript. Version 1 is {version=1, Coins=number}; version 2 is {version=2, coins=number}. Those are the only fields. Coins must be a finite nonnegative integer. I want decode(raw) to return a fresh v2 table or nil plus a reason. Nil means ... | <|open|>message role="system" type="thinking-effort"<|sep|>`thinking_effort` guides on how much to think in your thinking channel (not including the response channel), supported values include `low`, `medium`, `high`, and `max`.
Now the system is invoked with `thinking_effort=max`.<|close|>message<|sep|><|end_of_msg|><... |
[
"Review",
"Q/A"
] | expert | [
{
"role": "user",
"content": "Design review only, not a drop-in profile library. Our Roblox profile contains a session ID and leaseExpiresAt. A server can acquire it when os.time() exceeds that deadline. The owner renews periodically. Is expiry enough to stop a stalled old server saving after another server... | <|open|>message role="system" type="thinking-effort"<|sep|>`thinking_effort` guides on how much to think in your thinking channel (not including the response channel), supported values include `low`, `medium`, `high`, and `max`.
Now the system is invoked with `thinking_effort=max`.<|close|>message<|sep|><|end_of_msg|><... |
[
"Review",
"Ideas"
] | advanced | [
{
"role": "user",
"content": "Our server does guild coin transfers by debiting player A with UpdateAsync, then crediting player B with another UpdateAsync. Both calls are inside one pcall. Only authorized guild officers can invoke this internal function. Is that enough to make the transfer all-or-nothing? W... | <|open|>message role="system" type="thinking-effort"<|sep|>`thinking_effort` guides on how much to think in your thinking channel (not including the response channel), supported values include `low`, `medium`, `high`, and `max`.
Now the system is invoked with `thinking_effort=max`.<|close|>message<|sep|><|end_of_msg|><... |
[
"Review",
"Q/A"
] | expert | [
{
"role": "user",
"content": "Please review the purchase design, not write an incomplete ProcessReceipt system. A server script handles a developer product that adds coins. It keeps seen[receiptInfo.PurchaseId] in memory, adds coins to the live profile, marks seen, and returns Enum.ProductPurchaseDecision.P... | <|open|>message role="system" type="thinking-effort"<|sep|>`thinking_effort` guides on how much to think in your thinking channel (not including the response channel), supported values include `low`, `medium`, `high`, and `max`.
Now the system is invoked with `thinking_effort=max`.<|close|>message<|sep|><|end_of_msg|><... |
[
"Q/A",
"Ideas"
] | intermediate | [
{
"role": "user",
"content": "I publish an event-active boolean with MessagingService and each Roblox server remembers it. New servers sometimes think the event is off. Would putting the boolean in MemoryStore fix persistence across restarts? This is a global weekend event, changed maybe twice a week.",
... | <|open|>message role="system" type="thinking-effort"<|sep|>`thinking_effort` guides on how much to think in your thinking channel (not including the response channel), supported values include `low`, `medium`, `high`, and `max`.
Now the system is invoked with `thinking_effort=max`.<|close|>message<|sep|><|end_of_msg|><... |
[
"Optimization",
"Refactor"
] | intermediate | [
{
"role": "user",
"content": "A server script calls workspace:GetDescendants() every Heartbeat, then checks which BaseParts have our Hazard tag. There are thousands of decorative instances and only 30 hazards. The controller needs a current set, but don't implement damage. What would you change first?",
... | <|open|>message role="system" type="thinking-effort"<|sep|>`thinking_effort` guides on how much to think in your thinking channel (not including the response channel), supported values include `low`, `medium`, `high`, and `max`.
Now the system is invoked with `thinking_effort=max`.<|close|>message<|sep|><|end_of_msg|><... |
[
"Optimization",
"Q/A"
] | intermediate | [
{
"role": "user",
"content": "Forty server NPCs find the nearest of twenty active players five times a second. My teammate wants an octree immediately. We haven't profiled. Each check just compares root positions from a maintained player list. Is the nested loop automatically bad?",
"reasoning": null,
... | <|open|>message role="system" type="thinking-effort"<|sep|>`thinking_effort` guides on how much to think in your thinking channel (not including the response channel), supported values include `low`, `medium`, `high`, and `max`.
Now the system is invoked with `thinking_effort=max`.<|close|>message<|sep|><|end_of_msg|><... |
[
"Review",
"Optimization"
] | intermediate | [
{
"role": "user",
"content": "Review the idea of pooling every temporary Part in my Roblox effects code. I spawn maybe ten local sparks a second, each lasting half a second. No measurements yet. Is pooling always better than Clone and Destroy?",
"reasoning": null,
"reasoning_1": null,
"reasoning... | <|open|>message role="system" type="thinking-effort"<|sep|>`thinking_effort` guides on how much to think in your thinking channel (not including the response channel), supported values include `low`, `medium`, `high`, and `max`.
Now the system is invoked with `thinking_effort=max`.<|close|>message<|sep|><|end_of_msg|><... |
[
"Optimization",
"Ideas"
] | advanced | [
{
"role": "user",
"content": "I have 2,000 server timers for crop growth. Each timer currently wakes every 0.1 seconds to compare os.clock() with an expiry. Growth doesn't need per-frame precision. How would you reduce scheduling work without claiming a benchmark?",
"reasoning": null,
"reasoning_1":... | <|open|>message role="system" type="thinking-effort"<|sep|>`thinking_effort` guides on how much to think in your thinking channel (not including the response channel), supported values include `low`, `medium`, `high`, and `max`.
Now the system is invoked with `thinking_effort=max`.<|close|>message<|sep|><|end_of_msg|><... |
[
"Refactor",
"Generation"
] | intermediate | [
{
"role": "user",
"content": "Refactor this Luau helper so a Studio test can supply time. It's for a local hint repeat interval, not remote authorization. Keep its first-call and exact-boundary behavior.\n```luau\nlocal nextAt = -math.huge\nlocal function tryHint()\n local now = os.clock()\n if now < ... | <|open|>message role="system" type="thinking-effort"<|sep|>`thinking_effort` guides on how much to think in your thinking channel (not including the response channel), supported values include `low`, `medium`, `high`, and `max`.
Now the system is invoked with `thinking_effort=max`.<|close|>message<|sep|><|end_of_msg|><... |
[
"Debugging",
"Optimization"
] | intermediate | [
{
"role": "user",
"content": "My Roblox game drops frames when a gate opens. The gate script only changes a few properties. Is replacing pairs with ipairs likely to fix it? I haven't captured a profile.",
"reasoning": null,
"reasoning_1": null,
"reasoning_2": null,
"reasoning_3": null
},
... | <|open|>message role="system" type="thinking-effort"<|sep|>`thinking_effort` guides on how much to think in your thinking channel (not including the response channel), supported values include `low`, `medium`, `high`, and `max`.
Now the system is invoked with `thinking_effort=max`.<|close|>message<|sep|><|end_of_msg|><... |
[
"Review",
"Optimization",
"Q/A"
] | beginner | [
{
"role": "user",
"content": "Review this local Roblox UI helper for an obvious optimization. Inputs are finite numbers. It runs only when the settings slider changes.\n```luau\nlocal function toPercent(value: number): number\n return math.floor(math.clamp(value, 0, 1) * 100 + 0.5)\nend\n```\nShould I ca... | <|open|>message role="system" type="thinking-effort"<|sep|>`thinking_effort` guides on how much to think in your thinking channel (not including the response channel), supported values include `low`, `medium`, `high`, and `max`.
Now the system is invoked with `thinking_effort=max`.<|close|>message<|sep|><|end_of_msg|><... |
[
"Generation",
"Q/A"
] | intermediate | [
{
"role": "user",
"content": "For an edit-time Studio plugin, give me collectParts(selection) returning unique BaseParts from selected parts and selected Models. Ignore other selected classes. Don't modify the place. I pass Selection:Get() into it.",
"reasoning": null,
"reasoning_1": null,
"reas... | <|open|>message role="system" type="thinking-effort"<|sep|>`thinking_effort` guides on how much to think in your thinking channel (not including the response channel), supported values include `low`, `medium`, `high`, and `max`.
Now the system is invoked with `thinking_effort=max`.<|close|>message<|sep|><|end_of_msg|><... |
[
"Generation",
"Bug Fix"
] | intermediate | [
{
"role": "user",
"content": "Write a minimal Studio plugin toolbar button that toggles a dock widget. No editing tools inside yet, just an empty Inspector panel. The toolbar button should show the same active state as the widget, including when I close it with its X.",
"reasoning": null,
"reasoning... | <|open|>message role="system" type="thinking-effort"<|sep|>`thinking_effort` guides on how much to think in your thinking channel (not including the response channel), supported values include `low`, `medium`, `high`, and `max`.
Now the system is invoked with `thinking_effort=max`.<|close|>message<|sep|><|end_of_msg|><... |
[
"Review",
"Generation"
] | intermediate | [
{
"role": "user",
"content": "Review an edit-time plugin action before I add undo: it sets a string AuditGroup attribute on selected BaseParts. The attribute name is fixed. I want one undo step for a batch. Can I just call ChangeHistoryService:SetWaypoint before and after?",
"reasoning": null,
"reas... | <|open|>message role="system" type="thinking-effort"<|sep|>`thinking_effort` guides on how much to think in your thinking channel (not including the response channel), supported values include `low`, `medium`, `high`, and `max`.
Now the system is invoked with `thinking_effort=max`.<|close|>message<|sep|><|end_of_msg|><... |
[
"Bug Fix",
"Refactor"
] | intermediate | [
{
"role": "user",
"content": "My Studio plugin watches Selection.SelectionChanged and refreshes a widget. After I rebuild the plugin controller, selecting things refreshes several old controllers too. Destroying their widget didn't stop it. How should I expose cleanup?",
"reasoning": null,
"reasonin... | <|open|>message role="system" type="thinking-effort"<|sep|>`thinking_effort` guides on how much to think in your thinking channel (not including the response channel), supported values include `low`, `medium`, `high`, and `max`.
Now the system is invoked with `thinking_effort=max`.<|close|>message<|sep|><|end_of_msg|><... |
[
"Ideas",
"Generation"
] | intermediate | [
{
"role": "user",
"content": "I want a small Roblox Studio plugin that helps find bad Checkpoint tags before publishing. Suggest a few read-only checks. Our schema says the tag belongs on a BasePart under Workspace with a positive integer Order attribute. Multiple courses aren't supported yet.",
"reason... | <|open|>message role="system" type="thinking-effort"<|sep|>`thinking_effort` guides on how much to think in your thinking channel (not including the response channel), supported values include `low`, `medium`, `high`, and `max`.
Now the system is invoked with `thinking_effort=max`.<|close|>message<|sep|><|end_of_msg|><... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.