Slot-Casino-Game-Developer-Skills-for-Stake-Engine

Create structured game info/rules content for slot games. Invoke when drafting game info sections, symbol payouts, bonus purchase rules, or required disclaimers.

End-to-end Stake game development workflow for math, RGS contract, frontend playback, and compliance gating. Use when building or updating Stake games, defining game modes and RTP targets, validating generated books/index metadata, validating event streams, integrating frontend event playback, implementing RGS communication and replay mode, or preparing publication checks including social-language and jurisdiction requirements.

Define auto-play UX, stop conditions, and safeguards for slot games. Invoke when implementing autoplay controls, confirmations, or stop-on-event rules.

Design, mix, and integrate slot game audio including ambient loops, spin sounds, win celebrations, and feature music. Use when defining audio assets, tuning volume levels, synchronizing sound with animations, or validating audio loop seamlessness.

Design and execute test plans for slot games covering math correctness, UI logic, performance, and compliance. Use when validating game rules, running regression tests, verifying error handling, checking jurisdiction constraints, or preparing release sign-off reports.

Design and implement visual effects for slot games using shaders, particle systems, and sprite animations. Use when defining big win sequences, feature transitions, symbol animations, or optimizing VFX performance for mobile devices.

Define turbo/quick spin behavior, timings, and UI rules for slot games. Invoke when implementing fast spin modes, stop/skip behavior, or spin-speed UX standards.

Design CSS animation systems and motion recipes for casino game UI. Use when building round transitions, idle loops, inter-round motion, background patterns, or CSS-only animation specs.

Generate, package, and validate weighted outcome books for slot/casino game modes. Use when defining mode book schemas, producing `books_*.jsonl(.zst)` files, generating `lookUpTable_*.csv` weights, assembling `index.json`, or running publication-ready integrity checks across books/index/weights artifacts.

Design and validate AI-assisted game design specifications from concept to implementation handoff. Use when defining core loops, progression systems, economy sinks/sources, feature specs, risk constraints, content generation hooks, or quality gates for translating design docs into engineering-ready contracts.

Build, integrate, and validate AI-driven gameplay systems for production game runtimes. Use when implementing AI behavior modules, wiring inference providers into game loops, enforcing latency/fallback budgets, validating safety and telemetry contracts, or auditing AI game features before release.

Build, integrate, and validate AI-driven slot gameplay systems in production runtimes. Use when implementing AI features for slot modes, wiring model providers, enforcing spin-cycle latency budgets, defining deterministic fallbacks, validating mode/runtime/safety/telemetry contracts, or auditing AI slot readiness before release.

Automatically tune game/system parameters toward target metrics under explicit constraints. Use when iterating configuration weights, payout tables, trigger rates, or other balancing levers; running balance loops against simulation outputs; validating tolerance gates; and preparing pass/fail balancing sign-off artifacts.

Develop and harden C++ engine core systems with correctness, stability, and performance controls. Use when implementing engine subsystems, refactoring core runtime paths, enforcing contract boundaries, or validating engine-core readiness.

Profile, diagnose, and optimize C++ performance bottlenecks with measurable evidence. Use when analyzing CPU/memory hotspots, benchmarking before/after changes, triaging regressions from benchmark outputs, improving cache behavior, reducing lock contention, tuning compiler flags, or preparing performance sign-off reports.

Design, sequence, and validate event-driven animation systems for games and interactive UI. Use when defining animation triggers, timeline ordering, transition guards, interruption/cancel rules, easing/duration consistency, event-to-animation mapping, or release readiness checks for animation flow contracts.

Design and validate AI-driven anomaly/fraud-style detection workflows for game operations. Use when defining signal features, model scoring thresholds, investigation routing, or validating detection pipeline reliability and false-positive controls.

Direct game-math strategy, target setting, and validation governance across game modes. Use when aligning RTP/volatility goals, defining math sign-off criteria, reviewing simulation evidence, or coordinating math decisions across teams.

Design, diagnose, and optimize low-latency request paths in backend and realtime systems. Use when profiling p50/p95/p99 latency regressions, reducing queueing and lock contention, tuning network/serialization overhead, validating tail-latency improvements, or preparing latency sign-off evidence with strict percentile gates.

Coordinate multi-agent execution plans with explicit dependencies, ownership boundaries, and completion gates. Use when orchestrating multiple autonomous workstreams, sequencing inter-agent tasks, resolving dependency conflicts, or validating end-to-end pipeline readiness.

Design, optimize, and validate parallel execution across CPU threads/workers with measurable scaling evidence. Use when selecting parallelization strategy, diagnosing contention and load imbalance, evaluating speedup/efficiency curves, tuning task granularity, or triaging baseline-vs-current parallel performance regressions.

Integrate and validate PixiJS rendering pipelines inside Svelte applications. Use when wiring Pixi application lifecycle to Svelte component lifecycle, handling mount/unmount cleanup, coordinating reactive state with render loop events, validating resize/high-DPI behavior, or debugging event/input/render synchronization issues.

Integrate external/internal providers through stable adapter contracts and resilience controls. Use when adding or auditing provider APIs, normalizing data contracts, defining fallback behavior, or validating provider integration readiness before release.

Design, implement, and audit provably fair RNG and cryptographic seed workflows for casino games. Use when defining commit-reveal architecture, server/client seed lifecycle, nonce progression, hash/HMAC outcome derivation, bias-free range mapping, fairness transcript verification, or cryptographic release sign-off evidence.

Optimize and validate slot/casino RTP against explicit targets using simulation evidence. Use when defining RTP targets per mode, tuning paytables and feature frequencies, validating convergence from simulation runs, comparing theoretical vs empirical RTP, or preparing release sign-off with pass/fail thresholds.

Design, audit, and tune casino game math for Stake-style game pipelines. Use when defining mode math, paytables, reel strips, feature frequencies, RTP/volatility/hit-rate targets, book weights, max-win controls, simulation plans, or release sign-off evidence.

Design, review, and harden slot feature mechanics from product idea to implementation-ready behavior spec. Use when defining feature triggers, state transitions, retrigger rules, multipliers, respins, bonus entry/exit flow, mechanic sequencing, anti-loop constraints, or pre-implementation mechanic validation.

Build scalable slot UI production systems with shared components, state patterns, and release quality controls. Use when structuring slot UI architecture, component libraries, interaction contracts, or validating production UI readiness across titles.

Architect Stake platform integration layers across services, contracts, and release workflows. Use when defining platform boundaries, service contracts, compliance-aware architecture decisions, or validating integration readiness for Stake-aligned systems.

Scale game studio delivery systems across teams, pipelines, and release cadences. Use when designing team topology changes, pipeline throughput improvements, cross-team dependency governance, or operational maturity gates for scaling production.

Design telemetry and analytics systems for reliable KPI tracking and decision support. Use when defining event schemas, metric derivations, analytics pipelines, anomaly checks, or validating telemetry coverage for product releases.

Design, review, and validate slot game UI/UX flows for desktop and mobile play. Use when defining control hierarchy, spin-state UX, bet/balance presentation, modal interactions, responsive layouts, accessibility constraints, animation-feedback timing, or release readiness checks for slot user experience contracts.

Design retention-focused UX systems for games with measurable engagement impact. Use when defining habit loops, friction reduction patterns, re-engagement flows, or validating UX retention hypotheses against explicit success metrics.

Integrate, validate, and harden WebAssembly modules in frontend/backend application pipelines. Use when wiring WASM build artifacts with JS/TS loaders, validating module/loader contracts, checking init symbols and runtime assumptions, triaging WASM loading failures, or preparing release sign-off for wasm bundle integrity.