Wie man FiveM Scripts mit KI schreibt

Das Schreiben von FiveM-Skripten erforderte traditionell tiefgehende Kenntnisse in Lua, JavaScript und der FiveM-API. Heute verändern KI-Tools wie Claude Code, GitHub Copilot und ChatGPT, wie Entwickler alles von ESX-Skripte zu komplex Standalone-Systeme. Dieser umfassende Leitfaden zeigt dir genau, wie du KI für die FiveM-Entwicklung nutzen kannst, mit konkreten Beispielen und bewährten Workflows.

Warum KI-gestützte FiveM-Entwicklung alles verändert

Die traditionelle FiveM-Skriptentwicklung erfordert die gleichzeitige Beherrschung mehrerer Technologien: Lua für serverseitige Logik, JavaScript für NUI-Schnittstellen, SQL für Datenbankoperationen und die umfangreiche Native Funktionsbibliothek von FiveM. KI-Tools können routinemäßiges Entwerfen und Debuggen beschleunigen, ersetzen aber nicht das Lernen der FiveM-Runtime, Framework-APIs oder Sicherheitsgrenzen.

Echte Auswirkungen für Serverbesitzer:

• Erstelle routinemäßige Boilerplate schneller, wenn Anforderungen und Abhängigkeiten explizit sind
• Generiere Boilerplate-Code sofort für häufige Muster
• Debugge komplexe Synchronisationsprobleme zwischen Client und Server
• Wandle Ideen direkt in funktionierende Prototypen um

Wichtige KI-Tools für die FiveM-Entwicklung

Claude Code (Anthropisch)

Claude Code kann den Kontext über mehrere Dateien hinweg überprüfen. Installationsmethoden ändern sich, also folge der aktuellen offiziellen Claude Code-Dokumentation, die oben verlinkt ist, anstatt einen unverifizierten Drittanbieter-Paketbefehl zu kopieren.

FiveM-spezifische Vorteile:

• Generiert vollständige fxmanifest.lua-Konfigurationen
• Versteht ESX-, QBCore- und VRP-Frameworks
• Erstellt automatisch passende Client/Server-Eventhandler

GitHub Copilot

Lässt sich direkt in VS Code integrieren und liefert während der Eingabe Vorschläge in Echtzeit. Besonders effektiv für:

• Abschließen nativer Funktionsaufrufe
• Generieren von Eventhandler-Mustern
• Autovervollständigung von Datenbankabfragen

ChatGPT mit benutzerdefinierten Anweisungen

Konfiguriere ChatGPT speziell für FiveM, indem du benutzerdefinierte Anweisungen einstellst:

Du bist ein FiveM-Skriptentwickler. Verwende immer: - Lua 5.4-Syntax für Serverskripte - Modernes JavaScript für Clientskripte - FiveM-Natives aus der neuesten Spielversion - Angemessene Ereignissicherheit mit serverseitiger Validierung

Schritt-für-Schritt: Erstellen deines ersten KI-generierten Skripts

Lass uns ein komplettes Fahrzeuggeschäftsskript mit Claude Code erstellen und den gesamten Workflow von der Idee bis zur Bereitstellung demonstrieren.

Schritt 1: Klare Anforderungen definieren

Erstelle ein Anforderungen.md Datei:

## Anforderungen an das Fahrzeughändler-Skript
- Framework: ESX Legacy 1.9.0+
- Datenbank: MySQL mit oxmysql
- Funktionen:
 - Fahrzeuge nach Kategorie durchsuchen
 - Probefahrtsystem mit Zeitbegrenzung
 - Finanzierungsoptionen mit wöchentlichen Zahlungen
 - Admin-Befehle zum Hinzufügen von Fahrzeugen
- UI: Modernes NUI mit React

Schritt 2: Ressourcenstruktur generieren

Befehl an Claude Code:

claude-code generate "Erstelle eine vollständige FiveM-Fahrzeuggeschäftsressource basierend auf requirements.md"

Dies erzeugt:

vehicle_shop/
├── fxmanifest.lua
├── config.lua
├── server/
│ ├── main.lua
│ ├── database.lua
│ └── commands.lua
├── client/
│ ├── main.lua
│ ├── showroom.lua
│ └── testdrive.lua
├── ui/
│ ├── index.html
│ ├── style.css
│ └── script.js
└── sql/
 └── vehicle_shop.sql

Schritt 3: KI-generiertes fxmanifest.lua

fx_version 'cerulean'
game 'gta5'

author 'YourName'
description 'KI-generierter Fahrzeughändler'
version '1.0.0'

shared_scripts {
 '@es_extended/imports.lua',
 '@ox_lib/init.lua',
 'config.lua'
}

client_scripts {
 'client/*.lua'
}

server_scripts {
 '@oxmysql/lib/MySQL.lua',
 'server/*.lua'
}

ui_page 'ui/index.html'

files {
 'ui/index.html',
 'ui/style.css',
 'ui/script.js'
}

dependencies {
 'es_extended',
 'oxmysql',
 'ox_lib'
}

Schritt 4: Implementiere die Kernfunktionalität mit KI

Eingabeaufforderung zum serverseitigen Laden des Fahrzeugs:

-- AI-Generated: server/database.lua
local vehicles = {}

CreateThread(function()
 local result = MySQL.query.await('SELECT * FROM vehicle_shop WHERE stock > 0')
 
 for i = 1, #result do
 local vehicle = result[i]
 vehicles[vehicle.model] = {
 model = vehicle.model,
 name = vehicle.name,
 price = vehicle.price,
 category = vehicle.category,
 stock = vehicle.stock
 }
 end
 
 print(('[^2INFO^7] Loaded %d vehicles from database'):format(#result))
end)

-- Secure server event for purchasing
RegisterNetEvent('vehicle_shop:server:purchaseVehicle', function(vehicleModel, paymentMethod)
 local src = source
 local xPlayer = ESX.GetPlayerFromId(src)
 
 -- Security check
 if not vehicles[vehicleModel] then
 return TriggerClientEvent('ox_lib:notify', src, {
 title = 'Error',
 description = 'Invalid vehicle model',
 type = 'error'
 })
 end
 
 local vehicleData = vehicles[vehicleModel]
 
 -- Payment processing
 if paymentMethod == 'cash' then
 if xPlayer.getMoney() >= vehicleData.price then
 xPlayer.removeMoney(vehicleData.price)
 -- Generate plate and spawn vehicle
 local plate = GeneratePlate()
 
 MySQL.insert('INSERT INTO owned_vehicles (owner, plate, vehicle) VALUES (?, ?, ?)', {
 xPlayer.identifier,
 plate,
 json.encode({model = vehicleModel, plate = plate})
 })
 
 TriggerClientEvent('vehicle_shop:client:spawnVehicle', src, vehicleModel, plate)
 else
 TriggerClientEvent('ox_lib:notify', src, {
 title = 'Insufficient Funds',
 description = ('You need $%d'):format(vehicleData.price),
 type = 'error'
 })
 end
 end
end)

Schritt 5: Clientseitige Implementierung

KI-Eingabeaufforderung: “Erstelle ein clientseitiges Showroom mit Kamera-Steuerungen und Fahrzeugvorschau”

-- KI-generiert: client/showroom.lua
local currentVehicle = nil
local cam = nil
local inShowroom = false

local showroomCoords = vector3(-42.34, -1097.35, 26.42)
local vehicleSpawnCoords = vector4(-47.52, -1097.29, 26.42, 340.0)

function OpenShowroom(category)
 inShowroom = true
 DoScreenFadeOut(500)
 Wait(500)
 
 -- Kamera einrichten
 cam = CreateCam('DEFAULT_SCRIPTED_CAMERA', true)
 SetCamCoord(cam, -54.31, -1097.29, 28.42)
 PointCamAtCoord(cam, vehicleSpawnCoords.x, vehicleSpawnCoords.y, vehicleSpawnCoords.z)
 SetCamActive(cam, true)
 RenderScriptCams(true, false, 0, true, false)
 
 -- Fahrzeuge vom Server anfordern
 ESX.TriggerServerCallback('vehicle_shop:getVehicles', function(vehicles)
 SendNUIMessage({
 action = 'showVehicles',
 vehicles = vehicles,
 category = category
 })
 SetNuiFocus(true, true)
 end, category)
 
 DoScreenFadeIn(500)
end

RegisterNUICallback('previewVehicle', function(data, cb)
 if currentVehicle then
 DeleteEntity(currentVehicle)
 end
 
 local model = GetHashKey(data.model)
 RequestModel(model)
 
 while not HasModelLoaded(model) do
 Wait(10)
 end
 
 currentVehicle = CreateVehicle(model, vehicleSpawnCoords.x, vehicleSpawnCoords.y, 
 vehicleSpawnCoords.z, vehicleSpawnCoords.w, false, false)
 SetEntityAsMissionEntity(currentVehicle, true, true)
 SetVehicleOnGroundProperly(currentVehicle)
 SetVehicleDoorsLocked(currentVehicle, 2)
 
 cb('ok')
end)

Fortgeschrittene KI-Techniken für komplexe Systeme

Multi-File-Kontextverwaltung

Bei der Entwicklung vernetzter Systeme wie Telefonskripte, KI mit vollständigem Kontext versorgen:

# Mehrere Dateien an Claude Code übergeben
claude-code analyze --files "server/*.lua,client/*.lua,config.lua" 
 --prompt "Füge ein Garagensystem hinzu, das in den bestehenden Fahrzeughändler integriert ist"

Framework-spezifische Eingabeaufforderung

Unterschiedliche Frameworks erfordern unterschiedliche Ansätze. Hier ist, wie du KI-Aufforderungen für jedes optimierst:

Für ESX:

Generiere ein ESX-Job-Skript mit:
- Grades/Ranks-System mit ESX.Jobs
- Gehaltszahlungen über ESX.GetJobs()
- Boss-Menü mit Gesellschaftsfonds
- Verwende esx_society-Muster

Für QBCore:

Erstelle ein QBCore-Gang-System mit:
- Gang-Territorien mit PolyZone
- Rufsystem mit QB.Shared.Gangs
- Stash/Speicher mit qb-inventory
- Gang-Verwaltung über qb-gangmenu-Muster

Für VRP-Skripte:

Baue ein VRP-Geschäftssystem mit:
- vRP.getUserId für Spieleridentifikation
- vRP-Berechtigungssystem
- vRP-Geldmethoden (giveMoney, tryPayment)
- vRPclient-Tunnel für Client-Callbacks

Datenbankschemagenerierung

KI zeichnet sich durch die Erstellung optimierter Datenbankstrukturen aus:

-- KI-Prompt: "Erstelle MySQL-Schema für erweiterten Fahrzeughändler mit Finanzierung"
-- Generiertes Ergebnis:

CREATE TABLE IF NOT EXISTS `vehicle_shop_catalog` (
 `id` int(11) NOT NULL AUTO_INCREMENT,
 `model` varchar(60) NOT NULL,
 `name` varchar(60) NOT NULL,
 `manufacturer` varchar(60) DEFAULT NULL,
 `category` varchar(60) DEFAULT NULL,
 `price` int(11) NOT NULL,
 `stock` int(11) DEFAULT 10,
 `max_speed` int(11) DEFAULT NULL,
 `acceleration` float DEFAULT NULL,
 `braking` float DEFAULT NULL,
 `handling` float DEFAULT NULL,
 PRIMARY KEY (`id`),
 UNIQUE KEY `model` (`model`),
 KEY `idx_category` (`category`),
 KEY `idx_price` (`price`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;

CREATE TABLE IF NOT EXISTS `vehicle_financing` (
 `id` int(11) NOT NULL AUTO_INCREMENT,
 `identifier` varchar(60) NOT NULL,
 `vehicle_id` int(11) NOT NULL,
 `down_payment` int(11) NOT NULL,
 `weekly_payment` int(11) NOT NULL,
 `weeks_remaining` int(11) NOT NULL,
 `last_payment` timestamp DEFAULT CURRENT_TIMESTAMP,
 `repo_warning_sent` boolean DEFAULT FALSE,
 PRIMARY KEY (`id`),
 KEY `idx_identifier` (`identifier`),
 FOREIGN KEY (`vehicle_id`) REFERENCES `owned_vehicles`(`id`) ON DELETE CASCADE
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;

Debugging und Optimierung mit KI

Eingabeaufforderungen zur Leistungsprofilerstellung

-- Prompt: "Leistungsüberwachung zu dieser Ressource hinzufügen"
-- KI generiert:

local performanceStats = {
 events = {},
 queries = {}
}

local function profileEvent(eventName, func)
 return function(...)
 local startTime = GetGameTimer()
 local result = {func(...)}
 local executionTime = GetGameTimer() - startTime
 
 performanceStats.events[eventName] = performanceStats.events[eventName] or {}
 table.insert(performanceStats.events[eventName], executionTime)
 
 if executionTime > 50 then
 print(('[^3WARNUNG^7] Event %s dauerte %dms'):format(eventName, executionTime))
 end
 
 return table.unpack(result)
 end
end

-- Vorhandene Events umschließen
RegisterNetEvent('vehicle_shop:server:purchaseVehicle', 
 profileEvent('purchaseVehicle', purchaseVehicleHandler))

Sicherheitsüberprüfung

KI kann Sicherheitslücken identifizieren und beheben:

-- Prompt: "Sicherheitsvalidierung zu diesem Client-Server-Event hinzufügen"
-- Vorher (anfällig):
RegisterNetEvent('giveWeapon', function(weapon)
 local src = source
 GiveWeaponToPed(GetPlayerPed(src), weapon, 250, false, true)
end)

-- Nachher (KI-gesichert):
local allowedWeapons = {
 ['WEAPON_PISTOL'] = true,
 ['WEAPON_COMBATPISTOL'] = true
}

RegisterNetEvent('giveWeapon', function(weapon)
 local src = source
 local xPlayer = ESX.GetPlayerFromId(src)
 
 -- Mehrere Validierungsebenen
 if not xPlayer then return end
 if not allowedWeapons[weapon] then
 return DropPlayer(src, 'Versuch, eine ungültige Waffe zu spawnen')
 end
 if not xPlayer.hasPermission('weapons.spawn') then
 return TriggerClientEvent('ox_lib:notify', src, {
 title = 'Zugriff verweigert',
 type = 'error'
 })
 end
 
 -- Aktion protokollieren
 print(('[^3WEAPON^7] %s hat %s gespawnt'):format(xPlayer.getName(), weapon))
 
 xPlayer.addWeapon(weapon, 250)
 end)

NUI-Entwicklung mit KI

Die Erstellung moderner Schnittstellen für FiveM erfordert HTML-, CSS- und JavaScript-Kenntnisse. KI vereinfacht diesen Prozess:

Generierung von React-Komponenten

// Prompt: "Create a React vehicle shop UI with category filtering"
// AI generates:

import React, { useState, useEffect } from 'react';
import './VehicleShop.css';

const VehicleShop = () => {
 const [vehicles, setVehicles] = useState([]);
 const [selectedCategory, setSelectedCategory] = useState('all');
 const [selectedVehicle, setSelectedVehicle] = useState(null);
 const [searchTerm, setSearchTerm] = useState('');

 useEffect(() => {
 window.addEventListener('message', handleMessage);
 return () => window.removeEventListener('message', handleMessage);
 }, []);

 const handleMessage = (event) => {
 const { action, data } = event.data;
 
 switch(action) {
 case 'showVehicles':
 setVehicles(data.vehicles);
 break;
 case 'updateStock':
 updateVehicleStock(data.model, data.stock);
 break;
 }
 };

 const filteredVehicles = vehicles.filter(vehicle => {
 const matchesCategory = selectedCategory === 'all' || 
 vehicle.category === selectedCategory;
 const matchesSearch = vehicle.name.toLowerCase()
 .includes(searchTerm.toLowerCase());
 return matchesCategory && matchesSearch;
 });

 const purchaseVehicle = (vehicle, paymentMethod) => {
 fetch(`https://${GetParentResourceName()}/purchaseVehicle`, {
 method: 'POST',
 headers: { 'Content-Type': 'application/json' },
 body: JSON.stringify({
 model: vehicle.model,
 paymentMethod: paymentMethod
 })
 });
 };

 return (
 <div classname="vehicle-shop-container">
 <div classname="shop-header">
 <h1>Premium Deluxe Motorsport</h1>
 <input 
 type="text"
 placeholder="Fahrzeuge suchen..."
 value="{searchTerm}"
 onchange="{(e)" > setSearchTerm(e.target.value)}
 className="search-input"
 /&gt;
 </div>

 <div classname="category-filters">
 {[&#039;alle&#039;, &#039;Sport&#039;, &#039;Super&#039;, &#039;Limousine&#039;, &#039;SUV&#039;, &#039;Motorrad&#039;].map(cat =&gt; (
 <button
 key="{cat}"
 classname="{`category-btn" ${selectedcategory ="==" cat ? 'active' : ''}`}
 onclick="{()" > setSelectedCategory(cat)}
 &gt;
 {cat.toUpperCase()}
 </button>
 ))}
 </div>

 <div classname="vehicles-grid">
 {filteredVehicles.map(Fahrzeug =&gt; (
 <vehiclecard 
 key="{vehicle.model}"
 vehicle="{vehicle}"
 onselect="{()" > setSelectedVehicle(vehicle)}
 /&gt;
 ))}
 </div>

 {ausgewähltesFahrzeug &amp;&amp; (
 <vehicledetails 
 vehicle="{selectedVehicle}"
 onpurchase="{purchaseVehicle}"
 onclose="{()" > setSelectedVehicle(null)}
 /&gt;
 )}
 </div>
 );
};

Häufige KI-Fallstricke und Lösungen

Problem 1: Veraltete native Funktionen

Ausgabe: KI schlägt veraltete FiveM-Natives vor Lösung: Gib immer die Spielversion in deiner Aufforderung an:

Verwende nur FiveM-Natives, die mit Spielversion 3095+ kompatibel sind
Ersetze veraltete Natives wie GetPlayerPed(-1) mit PlayerPedId()

Problem 2: Speicherlecks in Schleifen

Ausgabe: KI erzeugt Endlosschleifen ohne ordnungsgemäße Bereinigung Lösung: Muster für die Garbage Collection anfordern:

-- KI-verbesserte Version mit Bereinigung
local activeThreads = {}

local function createManagedThread(id, func)
 if activeThreads[id] then
 -- Vorhandenen Thread beenden
 activeThreads[id] = false
 end
 
 activeThreads[id] = true
 
 CreateThread(function()
 while activeThreads[id] do
 func()
 Wait(0)
 end
 end)
end

-- Bereinigung beim Stoppen der Ressource
AddEventHandler('onResourceStop', function(resourceName)
 if GetCurrentResourceName() == resourceName then
 for id, _ in pairs(activeThreads) do
 activeThreads[id] = false
 end
 end
end)

Problem 3: Synchronisierungsprobleme

Ausgabe: Client-Server-Statuskonflikte Lösung: Verwende KI, um Zustandsverwaltung zu generieren:

-- Prompt: "Erstelle einen synchronisierten Zustandsmanager für Client-Server-Daten"
-- KI generiert:

-- Serverseitiger Zustandsmanager
local StateManager = {}
StateManager.states = {}

function StateManager:set(key, value)
 self.states[key] = value
 TriggerClientEvent('stateManager:sync', -1, key, value)
end

function StateManager:get(key)
 return self.states[key]
end

RegisterNetEvent('stateManager:requestSync', function()
 local src = source
 TriggerClientEvent('stateManager:fullSync', src, StateManager.states)
end)

-- Clientseitiger Zustandsmanager
local ClientState = {}

RegisterNetEvent('stateManager:sync', function(key, value)
 ClientState[key] = value
end)

RegisterNetEvent('stateManager:fullSync', function(states)
 ClientState = states
end)

-- Initiale Synchronisierung anfordern
CreateThread(function()
 Wait(1000)
 TriggerServerEvent('stateManager:requestSync')
end)

Test- und Bereitstellungsstrategien

Automatisiertes Testen mit KI

Generiere umfassende Test-Suiten:

-- Prompt: "Create unit tests for the vehicle shop purchase function"
-- AI generates:

local function runTests()
 local testResults = {
 passed = 0,
 failed = 0,
 tests = {}
 }

 -- Test 1: Valid purchase with sufficient funds
 local function testValidPurchase()
 local mockPlayer = {
 identifier = 'test_player_1',
 money = 50000,
 getMoney = function() return 50000 end,
 removeMoney = function(amount) 
 mockPlayer.money = mockPlayer.money - amount
 return true
 end
 }
 
 local result = attemptPurchase(mockPlayer, 'adder', 45000)
 assert(result.success == true, 'Valid purchase should succeed')
 assert(mockPlayer.money == 5000, 'Money should be deducted correctly')
 
 return true
 end

 -- Test 2: Purchase with insufficient funds
 local function testInsufficientFunds()
 local mockPlayer = {
 identifier = 'test_player_2',
 money = 1000,
 getMoney = function() return 1000 end
 }
 
 local result = attemptPurchase(mockPlayer, 'adder', 45000)
 assert(result.success == false, 'Purchase should fail with insufficient funds')
 assert(result.error == 'insufficient_funds', 'Should return correct error code')
 
 return true
 end

 -- Run all tests
 local tests = {
 {name = 'Valid Purchase', func = testValidPurchase},
 {name = 'Insufficient Funds', func = testInsufficientFunds}
 }

 for _, test in ipairs(tests) do
 local success, error = pcall(test.func)
 if success then
 testResults.passed = testResults.passed + 1
 print(('[^2✓^7] %s passed'):format(test.name))
 else
 testResults.failed = testResults.failed + 1
 print(('[^1✗^7] %s failed: %s'):format(test.name, error))
 end
 
 table.insert(testResults.tests, {
 name = test.name,
 passed = success,
 error = error
 })
 end

 return testResults
end

-- Run tests on resource start in development mode
if Config.Debug then
 CreateThread(function()
 Wait(1000)
 local results = runTests()
 print(('Tests completed: %d passed, %d failed'):format(
 results.passed, results.failed
 ))
 end)
end

Leistungsüberwachung

-- Prompt: "Add performance monitoring for production deployment"
-- AI generates:

local Monitor = {
 metrics = {
 eventCalls = {},
 dbQueries = {},
 memoryUsage = {}
 }
}

function Monitor:trackEvent(eventName)
 self.metrics.eventCalls[eventName] = (self.metrics.eventCalls[eventName] or 0) + 1
end

function Monitor:trackQuery(queryType, duration)
 table.insert(self.metrics.dbQueries, {
 type = queryType,
 duration = duration,
 timestamp = os.time()
 })
end

function Monitor:getReport()
 local report = {
 uptime = GetGameTimer() / 1000,
 totalEvents = 0,
 averageQueryTime = 0,
 memoryUsage = collectgarbage('count')
 }
 
 for _, count in pairs(self.metrics.eventCalls) do
 report.totalEvents = report.totalEvents + count
 end
 
 if #self.metrics.dbQueries > 0 then
 local totalTime = 0
 for _, query in ipairs(self.metrics.dbQueries) do
 totalTime = totalTime + query.duration
 end
 report.averageQueryTime = totalTime / #self.metrics.dbQueries
 end
 
 return report
end

-- Export metrics endpoint
RegisterCommand('metrics', function(source)
 if source == 0 or IsPlayerAceAllowed(source, 'admin.metrics') then
 print(json.encode(Monitor:getReport(), {indent = true}))
 end
end, true)

Integration mit vorhandenen Ressourcen

Beim Hinzufügen von KI-generierten Skripten zu bestehenden Servern mit ESX-Skripte oder Standalone-Skripte, folge diesen Integrationsmustern:

Ressourcenabhängigkeiten

-- config.lua - AI-generated configuration for compatibility
Config = {}

-- Framework detection
Config.Framework = nil

CreateThread(function()
 if GetResourceState('es_extended') == 'started' then
 Config.Framework = 'esx'
 ESX = exports['es_extended']:getSharedObject()
 elseif GetResourceState('qb-core') == 'started' then
 Config.Framework = 'qbcore'
 QBCore = exports['qb-core']:GetCoreObject()
 else
 Config.Framework = 'standalone'
 end
 
 print(('[^2INFO^7] Detected framework: %s'):format(Config.Framework))
end)

-- Framework-agnostic money functions
function GetPlayerMoney(source)
 if Config.Framework == 'esx' then
 local xPlayer = ESX.GetPlayerFromId(source)
 return xPlayer.getMoney()
 elseif Config.Framework == 'qbcore' then
 local Player = QBCore.Functions.GetPlayer(source)
 return Player.PlayerData.money.cash
 else
 -- Standalone implementation
 return exports['your_economy']:GetMoney(source)
 end
end

Best Practices-Checkliste

Vor der Bereitstellung KI-generierter Skripte:

• [ ] Sicherheitsüberprüfung: Alle Client-zu-Server-Ereignisse validiert
• [ ] Leistungstests: Keine Schleifen ohne Wait()
• [ ] Speicherverwaltung: Richtige Bereinigung bei Ressourcenstopp
• [ ] Datenbankindizes: Indizes für häufig abgefragte Spalten
• [ ] Fehler Handhabung: Try-Catch-Blöcke um kritische Operationen
• [ ] Protokollierung: Strukturiertes Logging zum Debuggen
• [ ] Konfiguration: Externalisierte Konfigurationswerte
• [ ] Dokumentation: README mit Installationsschritten
• [ ] Versionskontrolle: Semantische Versionierung in fxmanifest
• [ ] Lizenz: Entsprechende Lizenzdatei enthalten

Optimierte Eingabeaufforderung für einen FiveM-Entwickleragenten

Du bist ein Experte für FiveM mit 5+ Jahren Produktionserfahrung bei der Verwaltung von Servern mit hoher Bevölkerungszahl. Deine Expertise umfasst alle großen Frameworks und du priorisierst sicheres, leistungsfähiges Code.

---

Abschluss

KI-Tools wie Claude Code verwandeln die FiveM-Entwicklung von einem monatelangen Lernprozess innerhalb weniger Stunden in produktives Scripting und ermöglichen so schnelles Prototyping und die Entwicklung komplexer Systeme unter Wahrung von Sicherheits- und Leistungsstandards.

---

Bereit, deinen Server zu verbessern? Entdecke unsere kuratierte Sammlung von Premium-Skripte oder überprüfen Standalone-Lösungen die deine KI-generierten Ressourcen ergänzen.

KI für die nächsten Schritte mit FiveM

• Wie man KI mit FiveM verwendet
• Schreibe FiveM-Skripte mit KI
• ChatGPT-Eingabeaufforderungen für FiveM
• Übersetze FiveM-Skripte mit KI
• FiveM-Entwicklungstools
• FiveM-Skripte, ESX-Skripte, QBCore-Skripte, Und QBOX-Skripte

Gib der KI den richtigen Kontext, ohne Geheimnisse preiszugeben

Gib an, ob die Ressource ESX, QBCore, QBOX, ox_lib, oxmysql, NUI oder eigenständigen Code verwendet, und bitte das Tool, jede Abhängigkeit aufzulisten, die es annimmt. Füge keine Lizenzschlüssel, Datenbankpasswörter, Webhook-URLs, Kundendaten oder privaten Servercode in einen Dienst ein, es sei denn, die Datenverarbeitungsbedingungen und deine Erlaubnis, diesen Code zu teilen, sind klar.

Überprüfe generierte Event-Handler, Callbacks, spielerseitige Werte, Berechtigungsprüfungen, Belohnungslogik und Datenbank-Schreibvorgänge manuell. Teste Änderungen im Staging-Bereich mit normalen Spielerberechtigungen sowie Admin-Berechtigungen, prüfe Client- und Serverprotokolle und behalte eine Rollback-Kopie vor der Produktionsbereitstellung.