Last updated: March 22, 2026

Table of Contents

Redis Lua scripting is non-negotiable for atomic operations, distributed rate limiting, and complex state mutations. But writing Lua correctly—with proper error handling, hash key patterns, and EVALSHA caching—is tedious. AI assistants can scaffold this work reliably, but only certain tools understand Redis semantics well enough to avoid classic mistakes.

Why AI Matters for Redis Lua Scripts

Building scripts without AI means manually handling:

Poor scripts create production incidents: race conditions between script versions, memory leaks from unconsumed keys, or incorrectly scaled rate limits across partitions.

AI Tools Comparison

Claude (Opus 4.6, Haiku 4.5)

Price: $3/month (Claude.ai Pro) or $20 per 1M input tokens (API) Best for: Complex atomic operations, rate limiters, multi-key mutations

Claude produces battle-tested Redis Lua consistently. Its Lua knowledge covers:

Example: You ask Claude to write a distributed rate limiter that:

  1. Tracks request count per user
  2. Implements sliding window with cleanup
  3. Returns remaining quota
  4. Handles key expiration edge cases

Claude will produce:

local key = KEYS[1]
local now = tonumber(ARGV[1])
local window = tonumber(ARGV[2])
local max_requests = tonumber(ARGV[3])

redis.call('ZREMRANGEBYSCORE', key, 0, now - window)

local current = redis.call('ZCARD', key)

if current < max_requests then
  redis.call('ZADD', key, now, now .. '-' .. math.random())
  redis.call('EXPIRE', key, window + 1)
  return {current + 1, max_requests - current - 1}
else
  return {0, 0}
end

The script is correct: uses sorted sets for window, cleans expired entries, handles the boundary case where current == max_requests properly.

Weaknesses: Requires specific prompting around edge cases. Claude won’t warn you unprompted about cluster compatibility if you don’t ask.

Cost per query: $0.08 (API) for full script generation including testing.

OpenAI GPT-4o

Price: $20/month (ChatGPT Plus) or $0.03/$0.15 per 1K input/output tokens (API) Best for: Quick prototypes, simple scripts

GPT-4o handles basic Redis Lua. Effective for:

Example prompt: “Write a Redis Lua script that increments a counter and returns the value after incrementing.”

GPT-4o produces:

local key = KEYS[1]
local current = redis.call('INCR', key)
if current == 1 then
  redis.call('EXPIRE', key, ARGV[1])
end
return current

This is functional but naive: doesn’t handle the case where EXPIRE fails between INCR and EXPIRE calls (though technically atomic in Redis, the pattern is defensive).

Weaknesses:

Cost per query: $0.004 (API) for simple scripts, $0.01 for complex ones.

GitHub Copilot

Price: $10/month or $100/year Best for: Inline script generation, repository-aware context

Copilot shines when you’re working inside your codebase with existing Redis patterns.

Strengths:

Weaknesses:

Best workflow: Use Copilot for 30-line scripts, Claude for scripts over 100 lines.

Cost per query: $0 (already paid for).

Google Gemini (Advanced)

Price: $20/month Best for: Redis module scripts, advanced features

Gemini is comparable to GPT-4o but handles:

Example: Generating a script that atomically updates a JSON document and maintains a search index.

Weaknesses:

Cost per query: $0.004 per 1K input tokens.

Comparison Table

Tool Script Complexity Error Handling Cluster Safe EVALSHA Support Cost/Query Best For
Claude Excellent Excellent Good Yes $0.08 Complex rate limiters, atomics
GPT-4o Good Fair Fair Partial $0.004 Simple scripts, quick iteration
Copilot Fair Fair Fair No $0 Inline generation, team patterns
Gemini Good Good Fair Yes $0.004 Module scripts, JSON ops
Prompt Cache (Claude) Excellent Excellent Good Yes $0.04 (50% discount) Batch script generation

Practical Workflow

For building production rate limiters:

  1. Start with Claude Opus ($3/month or API pay-as-you-go).
  2. Write a detailed prompt including:
    • Expected QPS (queries per second)
    • Window size (5s, 60s, etc.)
    • Behavior when limit exceeded
    • Cluster deployment requirements
  3. Ask Claude explicitly:
    • “Will this work in a Redis cluster?”
    • “What happens if the key expires during execution?”
    • “How do I cache this with EVALSHA?”
  4. Test using redis-cli SCRIPT LOAD and redis-benchmark:
redis-cli SCRIPT LOAD "$(cat rate_limiter.lua)"
# Output: e0e1f9fabfc9d4800c877a703b823ac0578ff8d6

redis-benchmark -n 100000 \
  EVALSHA e0e1f9fabfc9d4800c877a703b823ac0578ff8d6 \
  1 user:123 1678886400000 60000 100

For batch generation:

Use Claude’s Prompt Cache feature:

Real-World Examples

Distributed Rate Limiter (Token Bucket)

Prompt to Claude: “Build a token bucket rate limiter in Redis Lua. User has 100 tokens per minute, refill rate 1.67/sec.”

Claude produces a production-ready script handling:

Leaderboard with Expiring Scores

Use case: Daily gaming leaderboard, reset at midnight UTC.

Prompt: “Write a Redis Lua script that: (1) adds a user score, (2) returns their rank, (3) auto-expires the leaderboard at next UTC midnight.”

Claude handles the edge case of midnight crossing mid-request.

Distributed Lock with Timeout

Prompt: “Implement a Redis lock with timeout in Lua. Lock key is {resource_id}, max lock duration is ARGV[1] ms, allow lock upgrade if same owner.”

Claude generates:

local lock_key = KEYS[1]
local lock_owner = ARGV[1]
local timeout_ms = tonumber(ARGV[2])

local existing_owner = redis.call('GET', lock_key)
if existing_owner == lock_owner then
  redis.call('PEXPIRE', lock_key, timeout_ms)
  return 1
elseif not existing_owner then
  redis.call('PSETEX', lock_key, timeout_ms, lock_owner)
  return 1
else
  return 0
end

Clean, atomic, upgradeable by the owner.

Red Flags to Avoid

When reviewing AI-generated Redis Lua:

  1. Missing EVALSHA caching: Script isn’t prepared with SCRIPT LOAD strategy. Ask: “How do I cache this?”

  2. Cluster-unsafe key patterns: Script uses KEYS[1] but assumes all hash slots are accessible. Clusters need all accessed keys in same slot.

  3. Lua 5.1 incompatibility: Redis 7.0+ uses Lua 5.1; some tools suggest Lua 5.3 syntax like // (floor division). Test with: redis-cli EVAL "return 10 // 3" 0

  4. Unhandled type errors: Script assumes ARGV[1] is a number without tonumber(). One bad input crashes the script server-wide.

  5. No error boundary: Script uses redis.error_reply() inconsistently, making client error handling ambiguous.

Decision Framework

Choose your AI tool based on:

FAQ

Q: Can I use Claude to audit my existing Redis Lua? A: Yes. Paste the script and ask: “What are the failure modes? What happens if X key expires mid-execution? Is this cluster-safe?” Claude catches edge cases in ~30 seconds.

Q: What’s the difference between EVAL and EVALSHA? A: EVAL sends the script every call (network overhead). EVALSHA sends the SHA1 hash after caching (faster, better for high-traffic). AI tools should generate both in production code: try EVALSHA first, fall back to EVAL if SHA1 isn’t cached.

Q: Does Redis 7.0 Lua change everything? A: No major breaking changes. New features: redis.log() for debugging, better JSON support. Ask AI tools explicitly: “Target Redis 7.0+” to get modern patterns.

Q: Can I use async/await in Redis Lua? A: No. Lua in Redis is synchronous-only. All operations block. If you need async, use Lua to issue multiple commands atomically, then handle async at the client level.

Q: How do I version-control Lua scripts? A: Store in .lua files, not inline in application code. Use CI to SCRIPT LOAD on deploy. AI tools should generate modular scripts that live separately.

Built by theluckystrike — More at zovo.one