Edge

Edge — Edge Computing & Serverless

Activate When

• User invokes /godmode:edge
• User says "edge function", "Cloudflare Workers",

"Vercel Edge", "serverless API", "AWS Lambda"

• User says "optimize cold start", "reduce latency"
• User says "edge caching", "Durable Objects", "KV store"

Workflow

Step 1: Discovery & Context

# Detect platform config
ls wrangler.toml vercel.json serverless.yml \
  template.yaml deno.json 2>/dev/null

# Check bundle size (warn if > 1MB)
du -sh dist/ build/ .output/ 2>/dev/null

# Check for platform CLIs
which wrangler vercel serverless sam 2>/dev/null

EDGE DISCOVERY:
Platform: Cloudflare | Vercel | Deno Deploy |
  AWS Lambda | GCP Cloud Functions | Azure Functions
Runtime: V8 isolates (edge) | Node.js | Deno | WASM
Latency target: 
State needs: stateless | KV | durable objects | DB
Budget: 

IF platform not specified: ask user
IF bundle > 1MB: flag cold start risk
IF latency target  200ms: profile with --cpu-prof
- IF bundle > 5MB: audit deps with bundlephobia

THRESHOLDS:
  Target cold start:  80%

Step 5: Distributed State at the Edge

EDGE STATE SOLUTIONS:
| Solution     | Consistency    | Latency   |
|-------------|----------------|-----------|
| KV Store    | Eventually     | 
Functions: , Cold start: ms, Bundle: KB
Caching: , Regions: 

Commit: "edge: — functions, p99 ms"

Key Behaviors

Never ask to continue. Loop autonomously until done.

1. Edge for latency, serverless for scale.
2. Cold starts are architecture constraints.

Design for them: minimize bundles, lazy init.

1. Cache aggressively. Fastest request never

reaches origin.

1. State at edge is hard. Know your consistency

model before choosing.

1. Test locally. Miniflare, sam local, vercel dev.
2. Monitor cost. Set budget alerts before deploying.
3. Keep functions small. One function per concern.
4. Fail gracefully. Fallbacks at every step.

HARD RULES

1. Never put heavy computation in edge functions

(CPU limit: 10-50ms).

1. Never cache authenticated responses in shared cache.
2. Never deploy without local testing first.
3. Never store secrets in source or plain-text env vars.
4. Never use latest tag or unbounded dependencies.

Auto-Detection

1. Platform: wrangler.toml, vercel.json, serverless.yml
2. Runtime: V8 isolate, Node.js, Deno, WASM
3. Functions: src/functions/, api/, workers/
4. Bundle size: warn if > 5MB

Loop Protocol

FOR each function in queue:
  1. Analyze: bundle size, cold start, CPU, cache
  2. Implement or optimize
  3. Test locally with emulator
  4. MEASURE: cold start ms, p99, bundle KB
  5. IF cold start > 200ms: tree-shake, lazy init
  6. IF bundle > 1MB: audit deps, split function

Output Format

Print: Edge: {platform}, {N} functions, p99 {X}ms, bundle {N}KB, cache hit {X}%. Verdict: {verdict}.

TSV Logging

Log to .godmode/edge-results.tsv:

timestamp	platform	functions	cold_start_ms	bundle_kb	status

Keep/Discard Discipline

KEEP if: tests pass AND cold start < 200ms
  AND bundle within limit
DISCARD if: tests fail OR cold start regressed
  OR new errors

Stop Conditions

STOP when ANY of:
  - All functions deployed and validated
  - Cold start < 200ms for all functions
  - User requests stop
  - Max iterations reached

Error Recovery

• Cold start too high: tree-shake, lazy init,

increase Lambda memory, switch to edge runtime.

• Bundle too large: audit deps, use platform-native

APIs, split into multiple functions.

• Function timeout: profile, move work to queue.
• "X is not defined": check runtime compatibility,

edge runtimes lack Node.js globals.

Source & license

This open-source skill is cataloged on AgentStack and links to its original source — we do not rehost the code.

• Author: arbazkhan971
• Source: arbazkhan971/godmode
• License: MIT

Install and usage instructions live in the source repository linked above.