Skip to main content
skill CX Codex

roblox-security · el4cteo — Claude Code skill: what it does, how to install

roblox-security — a skill for Claude Code enforces server-authoritative security for Roblox experiences. Runs during reviews of remote event handlers, combat calculations, inventory transactions, and character physics.

MIT 1,300 installs ★ 131 updated 2026-11-03

Install into Claude Code · Skills CLI (Vercel) All methods and platforms ↓
npx skills add EL4CTEO/roblox-skills --skill roblox-security -a claude-code
Open on GitHub

What roblox-security does

Guides the coding model to treat client environments as fully compromised. The server validates player intent instead of blindly accepting state changes like awarded coins or registered hits.

Covers argument sanitization patterns rejecting NaN values and spoofed instance tables, token bucket rate limiters, and server-side verification for ClickDetector or ProximityPrompt objects. It details combat hit-validation flows using server raycasts and distance checks scaled by ping.

Sensitive logic must remain isolated within ServerScriptService or ServerStorage. External secrets require HttpService:GetSecret(), while physics exploits require unanchored parts to drop client network ownership via SetNetworkOwner(nil) or adopt server authority mode.

What it helps with

  • reject malicious remote arguments including NaN numbers, unbounded vectors, and invalid UTF-8 strings
  • enforce token bucket rate limiting on client-triggered actions
  • verify combat hits on the server with raycasts and ping tolerances
  • block exploitation of client-side ClickDetector and ProximityPrompt interactions
  • prevent physics manipulation by revoking network ownership from clients

Example prompts for the agent

  • Audit this Luau remote handler for parameter spoofing and NaN vulnerabilities
  • Create a token bucket rate limiter for our inventory interaction events
  • Write a server-side hit validation check using character positions and raycasts

How to install roblox-security

1Skills CLI (Vercel)

npx skills add EL4CTEO/roblox-skills --skill roblox-security -a claude-code

2Manually: put the files in place

~/.claude/skills/roblox-security/SKILL.md

Copy the whole skill folder; for one project use .claude/skills/roblox-security/

Step by step, with commands for each platform: How to install skills in Claude Code: five ways

Questions about roblox-security

How to install roblox-security in Claude Code?

Run npx skills add EL4CTEO/roblox-skills --skill roblox-security -a claude-code. This adds the skill definition to ~/.claude/skills/roblox-security/SKILL.md.

What does roblox-security do?

It equips the coding agent with server-side security guidelines for Roblox Luau, covering remote argument sanitization, rate limiting, and physics ownership rules.

What is required for roblox-security to work?

Game secrets must use HttpService:GetSecret(), critical logic belongs in ServerScriptService or ServerStorage, and unanchored objects require network ownership assigned via SetNetworkOwner(nil).

Source text

SKILL.md · MIT
---
name: roblox-security
description: Anti-exploit design - never trust the client, validate every remote argument (NaN, spoofed instances, strings), rate limiting, ProximityPrompt/ClickDetector abuse, network ownership, movement and hit validation, economy/trade duplication, code confidentiality, secure teleports, Device Trust API, heuristics, Ban API. Use when writing server handlers for client input, combat/economy/trading, or reviewing for exploits.
---

# Roblox security

**Exploiters fully control their client**: they can run any Luau, read every replicated script
(decompiled), fire any remote with any arguments at any rate, edit any local property (WalkSpeed,
prompt `Enabled`, `MaxActivationDistance`), and move anything they have network ownership of.
Client-side anti-cheat is at best a speed bump. Security comes from server design.

## Core rules

1. **The server decides.** Clients send *intent* ("I pressed attack aiming here"), never *results*
   ("I dealt 50 damage", "give me 100 coins").
2. **Validate every argument** of every `OnServerEvent`/`OnServerInvoke`: type, structure, range, finiteness.
3. **Validate context**: is the player alive, in range, not on cooldown, owns the item, allowed to act?
4. **Rate limit** everything a client can trigger (remotes, prompts, touches, clicks).
5. **Keep secrets server-side**: server code in `ServerScriptService`/`ServerStorage`; API keys via
   `HttpService:GetSecret()`; never ship unreleased content to production places.
6. **Prefer silent mitigation** (drop, clamp, correct state) over instant kicks; escalate on repeated signals.

## Argument validation toolkit

```luau
--!strict
-- ServerScriptService/Server/Validate.luau
local Validate = {}

function Validate.number(value: unknown, min: number, max: number): number?
	if typeof(value) ~= "number" or not math.isfinite(value) then
		return nil -- rejects NaN and ±inf (NaN fails every comparison, so range checks alone don't catch it)
	end
	if value < min or value > max then
		return nil
	end
	return value
end

function Validate.integer(value: unknown, min: number, max: number): number?
	local n = Validate.number(value, min, max)
	return if n and n == math.floor(n) then n else nil
end

function Validate.string(value: unknown, maxLength: number): string?
	if typeof(value) ~= "string" or #value > maxLength or utf8.len(value) == nil then
		return nil -- also rejects invalid UTF-8 (which DataStores refuse)
	end
	return value
end

function Validate.vector3(value: unknown, maxMagnitude: number): Vector3?
	if typeof(value) ~= "Vector3" then
		return nil
	end
	if not (math.isfinite(value.X) and math.isfinite(value.Y) and math.isfinite(value.Z)) then
		return nil
	end
	return if value.Magnitude <= maxMagnitude then value else nil
end

-- Accept only a real instance of the expected class that lives under a trusted container.
-- Exploiters can send tables shaped like instances ({ ClassName = "Part", ... }).
function Validate.instanceIn(value: unknown, className: string, container: Instance): Instance?
	if typeof(value) ~= "Instance" or not value:IsA(className) or not value:IsDescendantOf(container) then
		return nil
	end
	return value
end

function Validate.enum<T>(value: unknown, allowed: { [T]: boolean }): T?
	if allowed[value :: any] then
		return value :: any
	end
	return nil
end

return Validate
```

- Treat every handler parameter after `player` as `unknown` and narrow it with these helpers.
- Look items up by ID in **server** tables (`ITEMS[itemId]`); never read prices/stats from client data
  or from replicated `NumberValue`s the client could reference.
- Cap table sizes and iterate client tables defensively (keys may be NaN-like, nested, huge).

## Rate limiting (token bucket)

```luau
--!strict
local Players = game:GetService("Players")

type Bucket = { tokens: number, last: number }

local function newLimiter(capacity: number, windowSeconds: number)
	local refillRate = capacity / windowSeconds
	local buckets: { [Player]: Bucket } = {}

	Players.PlayerRemoving:Connect(function(player)
		buckets[player] = nil
	end)

	return function(player: Player): boolean
		local now = os.clock()
		local bucket = buckets[player]
		if not bucket then
			bucket = { tokens = capacity, last = now }
			buckets[player] = bucket
		else
			bucket.tokens = math.min(capacity, bucket.tokens + (now - bucket.last) * refillRate)
			bucket.last = now
		end
		if bucket.tokens >= 1 then
			bucket.tokens -= 1
			return true
		end
		return false
	end
end

local allowAttack = newLimiter(5, 1) -- bursts of 5, refills 5/second
print(allowAttack)
```

Rate-limit expensive or exploitable operations especially: DataStore/Badge/HTTP calls (they have
their own budgets), cloning large models, teleports, currency grants, anything broadcast to all clients.

## Client-triggered instances are not safe

| Object | What exploiters can do | Server must |
| --- | --- | --- |
| `ProximityPrompt` | Fire events while disabled; change distance/line-of-sight/`HoldDuration` locally. Only `Triggered` gets a distance check. | Re-check enabled state, distance from character, alive, cooldown. |
| `ClickDetector` | Fire from any distance even when disabled. No server checks at all. | Same as above. |
| `DragDetector` | Inherited click events unchecked; drag respects only `Enabled` and `PermissionPolicy`. | Validate drag results on the server. |
| `Touched` on client-owned parts | Fake or suppress touches. | Validate with server-side distance/overlap queries. |

If these objects sit in **unanchored** parts the client can own, an exploiter can pull the part to
themselves: anchor them, or `part:SetNetworkOwner(nil)` for server ownership.

## Network ownership and movement

Clients own their character's physics, so they can teleport, fly, noclip, speed hack, fling other
players (NaN/huge velocities), and suppress `Touched`. Options, strongest first:

1. **Server authority** (Workspace `AuthorityMode = Server`; fully released, opt-in): the
   server simulates movement with client prediction and rollback, eliminating movement exploits.
   See `roblox-physics`.
2. Server-side movement checks: compare horizontal (XZ) displacement per interval against max speed
   plus latency tolerance; exempt legitimate teleports (set a flag server-side when *you* move them);
   rubber-band to the last valid position instead of kicking.
3. Keep gameplay-critical unanchored parts server-owned: `part:SetNetworkOwner(nil)`.

## Combat validation (hit reports)

Client sends origin, direction/target part, and timestamp. Server checks:
- Origin is near the character's **server** position (tolerance scaled by `player:GetNetworkPing()`).
- Target is alive, an enemy, and within weapon range; claimed hit point is near the target's server position.
- A server raycast against **static** geometry finds no wall between origin and target.
- Fire rate, ammo, reload/sprint state tracked on the server.

## Economy, trading, purchases

- Currency, inventory, and prices exist only on the server. Clients request; the server checks balance
  and applies changes atomically.
- Trades: validate both sides fully, then commit both, then save both; on any failure revert everything.
  Beware "trade then leave before save" duplication: lock items during trades and save immediately after.
- Robux purchases: grant only in `MarketplaceService.ProcessReceipt` (developer products) or after a server
  ownership check (passes). Never trust `PromptProductPurchaseFinished` from the client. See `roblox-monetization`.

## Confidentiality

- Any `LocalScript`, client `Script`, or `ModuleScript` that replicates can be decompiled — even if
  disabled or never required. Don't mix server-only branches into shared modules.
- Anything replicated (models, UI, attributes) can be data-mined. Keep unreleased content in separate
  private universes, not hidden in production.
- Clients can teleport to **any place in the universe**: set **Access Control for Places → Secure within
  universe only** in Creator Dashboard, and verify eligibility on join in restricted places (default deny).
- Never put API keys in scripts or attributes; use the in-experience Secrets store (`HttpService:GetSecret`).

## Device trust (hardware attestation)

`Player.DeviceTrustLevel` (server-read) reports `Pending` → `Unknown` / `None` / `Standard` / `Full`. Supported
today on Android, Chromebook, and Meta Quest; web reports `None`; iOS, desktop, and consoles report `Unknown`
until supported (**`Unknown` ≠ untrusted**). Studio is always `Pending`. It describes the device, not the
player — it complements server validation, never replaces it.

- Prefer routing (ranked place for `Standard`/`Full`) or gating features (trading) over rejecting players;
  check the impact first in Creator Hub → Safety → Anti-cheat.
- Treat `Pending` as untrusted for sensitive features. Decide on the server; tell the client via a remote.
- To reject on join, assign the one-per-place callback in a server script:

```luau
--!strict
local IntegrityService = game:GetService("IntegrityService")

type Decision = { Action: Enum.PlayerDeviceTrustDecision, Message: string? }

IntegrityService.EvaluatePlayerDeviceTrust = function(player: Player, _measures): Decision
	if player.DeviceTrustLevel == Enum.PlayerDeviceTrustLevel.None then
		return { Action = Enum.PlayerDeviceTrustDecision.Reject, Message = "This game can't verify your device." }
	end
	return { Action = Enum.PlayerDeviceTrustDecision.Accept }
end
```

## Detection and consequences

Layer server-side heuristics on top of validation: fastest-possible completion time, rate of resource
gain, inhumanly regular action cadence, honeypot remotes no legit client fires. Accumulate a
suspicion score; act on multiple signals. Ladder: silent logging → quiet mitigation → restrict
features → kick/ban. Delay visible consequences so exploiters can't bisect your checks.

```luau
--!strict
local Players = game:GetService("Players")

local function banForExploiting(player: Player, evidence: string)
	local ok, err = pcall(function()
		Players:BanAsync({
			UserIds = { player.UserId },
			Duration = 7 * 24 * 60 * 60, -- seconds; -1 = permanent
			DisplayReason = "Exploiting detected.", -- shown to the user (max 400 chars, filtered)
			PrivateReason = evidence, -- visible to you only
			ExcludeAltAccounts = false, -- also ban detected alt accounts
			ApplyToUniverse = true,
		})
	end)
	if not ok then
		warn("BanAsync failed:", err)
		player:Kick("Exploiting detected.")
	end
end

return banForExploiting
```

Enable `Players.BanningEnabled` for the Ban API. Prefer reversible, time-limited bans (check
`Players:GetBanHistoryAsync` to escalate); version detection rules and monitor false-positive rates.

Security review checklist and common vulnerable-code patterns: [references/checklist.md](references/checklist.md).

## Related skills

`roblox-networking`, `roblox-physics` (ownership, server authority), `roblox-data-stores`,
`roblox-monetization`, `roblox-code-review`.

© EL4CTEO · MIT · EL4CTEO/roblox-skills

Similar skills

All skills for Security →

roblox-security by other authors comes first.

roblox-security TabooHarmony roblox-security is a Claude Code skill that audits Roblox game code for exploits, remote abuse, and DataStore duplication. It can be used before releases or in-game economy updates. CX Codex +1 3,500installs roblox-security sentinelcore roblox-security — a skill for Claude Code and five other coding agents that teaches secure Roblox scripting patterns. It kicks in when you write RemoteEvent handlers, currency logic, damage systems or any server-authoritative code. CX Codex +1 783installs roblox-anti-exploit-review LihFolk roblox-anti-exploit-review is a Claude Code skill for reviewing exploit risks in Roblox games. It runs during checks of remotes, trades, and purchases before release. CX Codex +1 ★ 98repo stars roblox-remote-events sentinelcore roblox-remote-events — a skill that steers your coding agent through Roblox client-server messaging and the server-side checks that keep exploiters out. CX Codex +1 656installs roblox-networking gamedev-skills roblox-networking — a skill for Claude Code, Codex, Cursor and other platforms handles Roblox client-server networking and anti-exploit rules. Used when remotes trust the client, exploiters spam requests or hits register incorrectly. CX Codex +1 9,300installs roblox-game brockmartin roblox-game is a Claude Code skill that assists with Luau scripting, architecture design, and game security for Roblox. It adapts workflows to active Roblox Studio MCP tools. CX Codex +1 553installs roblox-system-builder LihFolk roblox-system-builder is a Claude Code skill that structures full-stack Roblox gameplay systems with server validation, session-locked storage, and client UI. CX Codex +1 ★ 98repo stars roblox-luau gamedev-skills This Claude Code skill helps write Roblox Luau and run project checks. It activates for a LocalScript that will not run, a client-side nil after joining, or legacy wait() calls. CX Codex +1 12,300installs

From the same set22

The whole set →
roblox-world-building roblox-world-building — a skill for Claude Code and other platforms that automates world-building and 3D environment generation in Roblox. Invoked when creating maps, lighting effects, or procedural levels. CX Codex +1 1,400installs roblox-performance roblox-performance — a skill for Claude Code that diagnoses Roblox game performance, detects memory leaks, and fixes frame rate drops. Used when games lag, stutter, drop FPS, or experience high ping. CX Codex +1 1,300installs roblox-code-review The roblox-code-review Claude Code skill reviews Roblox code for security flaws, data loss, and lifecycle bugs. It runs for PR or script reviews, game audits, and legacy-code updates. CX Codex +1 1,300installs roblox-characters-animation roblox-characters-animation — a Claude Code skill for Roblox characters and animation. It applies to work on movement, damage, respawns, avatars, weapons, and tweens. CX Codex +1 1,300installs roblox-game-systems roblox-game-systems — a skill for Claude Code and Codex providing server-authoritative Roblox gameplay recipes. Activates when building currencies, inventory, weapons, round loops, or progression. CX Codex +1 1,300installs roblox-luau The roblox-luau Claude Code skill supports writing and explaining Roblox scripts in Luau. It activates for script creation, refactoring, type-error fixes, and updates to older Lua code. CX Codex +1 1,300installs roblox-ui roblox-ui — a skill for Claude Code and Codex constructs responsive Roblox interfaces. Runs when building HUDs, inventories, storefronts, or fixing layouts across mobile devices and consoles. CX Codex +1 1,300installs roblox-testing The roblox-testing Claude Code skill covers testing Roblox code and checking gameplay changes. It applies when adding tests, configuring a runner, or setting up CI. CX Codex +1 1,300installs

Project sponsors

Companies that keep this analytics open