Claude Code Deno: Sichere JavaScript-Laufzeit für moderne Entwicklung mit KI

Node.js ist gut. Aber wer einmal versehentlich eine Datei überschrieben hat, weil ein npm-Paket unbemerkt Dateisystemzugriff hatte, versteht sofort, warum Deno 2 eine andere Richtung einschlägt. Das Permission-Modell, eingebautes TypeScript, eine eigene Standardbibliothek — und seit Deno 2 volle npm-Kompatibilität: Deno ist kein Experiment mehr, sondern eine ernsthafte Alternative für moderne Serveranwendungen.

Claude Code macht Deno zugänglich — nicht nur für neue Projekte, sondern gerade für Teams, die aus Node.js-Codebases migrieren oder schnell Deno-typische Muster lernen wollen. Dieser Artikel zeigt, wie beides zusammenpasst.

1. Was Deno 2 anders macht

Deno wurde von Ryan Dahl entwickelt — dem ursprünglichen Schöpfer von Node.js — mit dem expliziten Ziel, die Fehler von Node.js nicht zu wiederholen. Das Ergebnis ist eine Laufzeitumgebung, die standardmäßig nichts darf. Kein Netzwerkzugriff, kein Dateisystemzugriff, keine Umgebungsvariablen — außer du erlaubst es explizit per Flag.

Deno 2, veröffentlicht Ende 2024, hat die bis dahin größte Lücke geschlossen: npm-Kompatibilität. Du kannst jetzt npm-Pakete direkt importieren, bestehende Node.js-Projekte weitgehend unverändert ausführen und trotzdem alle Vorteile von Deno nutzen. Das macht Deno 2 zum ersten Mal zur realistischen Migration von Node.js.

Weitere Kernmerkmale:

• TypeScript out of the box: kein ts-node, kein Build-Schritt für die Entwicklung
• Eingebautes Tooling: Formatter, Linter, Testrunner, Compiler — alles ohne separate Pakete
• Web-Standard-APIs: fetch, Request, Response, ReadableStream — direkt verfügbar
• JSR als Paketregistry: JavaScript Registry, typsicher und zukunftssicher
• Deno KV: eingebauter Key-Value-Store, kein externes Datenbanksetup nötig
• Deno Deploy: Serverless Edge Functions in Sekunden

2. Die wichtigsten Deno-Befehle im Überblick

Claude Code kennt alle Deno-Befehle und hilft beim Aufbau eines neuen Projekts — oder beim Verstehen einer bestehenden Deno-Codebasis. Ein typischer Einstieg:

claude "Ich möchte ein neues Deno 2 Projekt starten. Zeig mir die
empfohlene Projektstruktur und erkläre die wichtigsten Befehle."

Projekt initialisieren

# Neues Projekt anlegen
deno init mein-projekt

# Ergebnis: deno.json + main.ts + main_test.ts

deno init erzeugt eine minimale Struktur mit einer Konfigurationsdatei (deno.json), einer Hauptdatei und einem passenden Test. Kein package.json, kein node_modules-Verzeichnis.

Ausführen, Testen, Formatieren

# Datei direkt ausführen (ohne vorherigen Build)
deno run main.ts

# Mit expliziten Berechtigungen
deno run --allow-net --allow-read main.ts

# Tests ausführen
deno test

# Code formatieren
deno fmt

# Code auf Fehler prüfen
deno lint

# Zu einem eigenständigen Binary kompilieren
deno compile --output mein-programm main.ts

Das Besondere an deno compile: Das Ergebnis ist eine einzige ausführbare Datei ohne externe Abhängigkeiten — kein Node.js auf dem Zielserver erforderlich. Claude Code hilft beim Konfigurieren der richtigen Compile-Flags, besonders wenn das Binary Netzwerk- oder Dateizugriff benötigt.

3. Das Permission-Modell verstehen

Das Permission-Modell ist Denos wichtigstes Sicherheitsmerkmal. Jedes Skript läuft standardmäßig in einer Sandbox ohne jegliche externe Zugriffe. Wer Netzwerkzugriff braucht, muss ihn explizit anfordern:

# Nur ausgehende Verbindungen erlauben
deno run --allow-net main.ts

# Nur bestimmte Hosts erlauben
deno run --allow-net=api.example.com main.ts

# Dateisystemzugriff auf ein Verzeichnis beschränken
deno run --allow-read=/tmp --allow-write=/tmp main.ts

# Umgebungsvariablen lesen (alle oder spezifische)
deno run --allow-env=PORT,DATABASE_URL main.ts

# Subprozesse starten
deno run --allow-run=git main.ts

# Alle Rechte (für Entwicklung, nicht Produktion)
deno run --allow-all main.ts

Claude Code versteht dieses Modell und schlägt die minimalen nötigen Permissions vor, wenn du ein neues Skript entwickelst. Beschreibe einfach, was dein Skript tun soll:

claude "Schreib ein Deno-Skript, das die GitHub API abfragt und die
Ergebnisse in eine JSON-Datei schreibt. Welche Permissions brauche ich?"

"Du brauchst --allow-net=api.github.com für die API-Anfrage und --allow-write=./output für die Datei. Ich empfehle, den Output-Pfad auf ein bestimmtes Verzeichnis zu beschränken, nicht auf das gesamte Filesystem."

4. npm-Kompatibilität in Deno 2

Deno 2 kann npm-Pakete direkt importieren — mit dem npm:-Präfix. Das bedeutet: du musst nicht auf das gesamte npm-Ökosystem verzichten, während du gleichzeitig von Denos Permission-Modell und TypeScript-Integration profitierst.

// npm-Paket direkt importieren
import express from "npm:express@4";
import { z } from "npm:zod@3";

// JSR-Paket (Deno-native, typsicher)
import { join } from "jsr:@std/path";
import { assertEquals } from "jsr:@std/assert";

Claude Code hilft beim Umschreiben bestehender Node.js-Importe auf das Deno-Format. Ein typischer Auftrag:

claude "Konvertiere diese Node.js-Imports auf Deno-kompatible Syntax.
Verwende JSR wo möglich, npm: nur wo nötig."

Claude Code unterscheidet dabei, welche Pakete bereits in JSR verfügbar sind (und damit besser typisiert), und welche man vorerst über npm: einbinden sollte.

5. Deno Standard Library und JSR

Die Deno Standard Library (kurz @std) ist über JSR verfügbar und deckt die häufigsten Anforderungen ab, ohne externe Abhängigkeiten:

import { join, dirname } from "jsr:@std/path";
import { exists, readTextFile } from "jsr:@std/fs";
import { format } from "jsr:@std/datetime";
import { assertEquals, assertThrows } from "jsr:@std/assert";
import { serve } from "jsr:@std/http";

Claude Code kennt den Umfang der Standardbibliothek und empfiehlt sie aktiv, bevor es externe Pakete vorschlägt. Das reduziert die Abhängigkeitsliste und hält Projekte wartbarer.

6. Deno KV: Eingebauter Key-Value-Store

Deno KV ist eine persistente Schlüssel-Wert-Datenbank, die direkt in die Deno-Laufzeit eingebaut ist — kein externes Datenbanksetup, kein Docker-Container, kein Verbindungsstring:

const kv = await Deno.openKv();

// Schreiben
await kv.set(["users", "42"], { name: "Alice", role: "admin" });

// Lesen
const result = await kv.get(["users", "42"]);
console.log(result.value); // { name: "Alice", role: "admin" }

// Atomic transactions
const res = await kv.atomic()
  .check({ key: ["counter"], versionstamp: null })
  .set(["counter"], 0)
  .commit();

// Iteration
for await (const entry of kv.list({ prefix: ["users"] })) {
  console.log(entry.key, entry.value);
}

Claude Code schreibt KV-Code zuverlässig und kennt die Besonderheiten: atomare Transaktionen, Versionsstempel für optimistisches Locking, und die Grenzen der lokalen vs. der Cloud-KV-Instanz (bei Deno Deploy).

claude "Ich brauche eine einfache Session-Verwaltung mit Deno KV.
Jede Session soll automatisch nach 30 Minuten ablaufen."

7. Deno Deploy: Serverless Edge Functions

Deno Deploy ist die offizielle Cloud-Plattform für Deno — Serverless Functions, die weltweit an Edge-Standorten ausgeführt werden. Der Deployment-Workflow ist minimal:

// server.ts — ein vollständiger HTTP-Server
Deno.serve({ port: parseInt(Deno.env.get("PORT") ?? "8000") }, (req) => {
  const url = new URL(req.url);

  if (url.pathname === "/health") {
    return new Response("ok");
  }

  return new Response("Hello from Deno Deploy!", {
    headers: { "Content-Type": "text/plain" },
  });
});

# Lokal testen
deno run --allow-net --allow-env server.ts

# Mit deployctl deployen (Deno Deploy CLI)
deployctl deploy --project=mein-projekt server.ts

Claude Code hilft beim Aufbau von Deno-Deploy-kompatiblen Servern: Web-Standard-APIs statt Node.js-spezifischer APIs, korrekte Umgebungsvariablen-Nutzung (Deno.env.get()), und Integration mit Deno KV für persistenten State über Edge-Standorte hinweg.

8. Von Node.js zu Deno migrieren — mit Claude Code

Der häufigste Anwendungsfall: ein bestehendes Node.js-Projekt soll auf Deno umgestellt werden. Claude Code übernimmt dabei die mechanischen Aufgaben — Import-Konvertierung, Permission-Analyse, API-Mapping — während du die Architekturentscheidungen triffst.

claude "Analysiere dieses Node.js-Projekt und erstelle einen Migrationsplan für Deno 2.
Welche npm-Pakete haben JSR-Äquivalente? Welche Permissions brauche ich?"

Ein typischer Migrationspfad, den Claude Code vorschlägt:

1. Kompatibilitätscheck: Welche npm-Pakete werden genutzt? Gibt es JSR-Alternativen?
2. Import-Konvertierung: require() durch ES Modules ersetzen, npm:-Präfixe ergänzen
3. Node.js-API-Mapping: fs durch @std/fs, path durch @std/path ersetzen
4. Permission-Analyse: Welche externen Zugriffe macht der Code? Flags definieren
5. Tests anpassen: Jest-Tests auf Denos eingebauten Testrunner umschreiben
6. Konfiguration: package.json durch deno.json ersetzen

Tests in Deno schreiben und generieren

Denos eingebauter Testrunner braucht keine externe Bibliothek:

import { assertEquals } from "jsr:@std/assert";

Deno.test("addiert zwei Zahlen korrekt", () => {
  assertEquals(1 + 1, 2);
});

Deno.test("async Test mit Timeout", async () => {
  const result = await fetch("https://api.example.com/health");
  assertEquals(result.status, 200);
});

claude "Schreib Tests für diese Deno-Funktion. Nutze nur die
Standard-Assert-Bibliothek, keine externen Test-Frameworks."

Claude Code generiert Tests, die direkt mit deno test ausführbar sind — ohne Konfiguration, ohne separate Installation.

• Claude Code TypeScript — typsichere Entwicklung mit KI-Unterstützung
• Claude Code Bun — die schnellste JavaScript-Laufzeit im Vergleich