TypeScript: Der Weg zu weniger Fehlern und wartbarem JavaScript-Code

TypeScript: Der Weg zu weniger Fehlern und wartbarem JavaScript-Code

Typsystem, strict-Modus und schrittweise Migration: Was TypeScript gegen Laufzeitfehler leistet und wo seine Grenzen liegen

Aktualisiert:

Abstract

TypeScript ergänzt JavaScript um statische Typen. Wie das Typsystem Fehler früh findet, was der strict-Modus bringt und wie Sie bestehende Projekte umstellen.
  • #TypeScript
  • #JavaScript
  • #Programmierung
  • #Webentwicklung
  • #Frontend
  • #Backend
  • #Statische Typisierung
  • #Compiler
  • #Entwickler-Tools
  • #IDE
  • #Type Definitions
  • #Typisierung
  • #Codequalität
  • #Fehlervermeidung
  • #Migration

Statische Typen finden Fehler, bevor der Code läuft – aber nur so viele, wie Sie zulassen

Ein Webshop zeigt im Warenkorb plötzlich „NaN €“ an. Die Ursache ist schnell gefunden, nachdem ein Kunde sich beschwert hat: Eine Schnittstelle liefert den Preis seit dem letzten Update als Text statt als Zahl, und an einer Stelle wird aus "19.90" + 5 die Zeichenkette "19.905", an einer anderen aus undefined * 2 der Wert NaN. JavaScript beschwert sich über nichts davon. Es rechnet einfach weiter.

Genau für diese Art von Fehlern gibt es TypeScript. Die Sprache legt über JavaScript ein Typsystem, das solche Widersprüche schon im Editor meldet – bevor der Code überhaupt ausgeführt wird. Fehlerfrei wird Software dadurch nicht. Aber eine ganze Klasse von Fehlern, die in reinem JavaScript erst in Produktion auffällt, verschwindet weitgehend. Wie das funktioniert, wo die Grenzen liegen und wie Sie ein bestehendes Projekt umstellen, erklären die folgenden Abschnitte.

Was TypeScript ist – und was nicht

TypeScript ist eine Obermenge von JavaScript: Jedes gültige JavaScript-Programm ist im Prinzip auch gültiges TypeScript. Hinzu kommen Typangaben, also Hinweise darauf, welche Art von Wert eine Variable, ein Funktionsparameter oder ein Rückgabewert haben darf. Microsoft hat die Sprache 2012 veröffentlicht, sie ist quelloffen und wird bis heute von Microsoft gepflegt.

Wichtig für das Verständnis: Browser und Node.js führen kein TypeScript aus, sondern JavaScript. Die Typangaben dienen ausschließlich der Prüfung während der Entwicklung. Vor der Ausführung werden sie entfernt – entweder durch den TypeScript-Compiler tsc, durch ein Build-Werkzeug wie Vite, esbuild oder SWC oder inzwischen auch direkt durch die Laufzeitumgebung. Zur Laufzeit existieren die Typen nicht mehr.

Daraus folgt eine Einschränkung, die viele Einsteiger überrascht: TypeScript prüft nur, was es sehen kann. Daten, die zur Laufzeit von außen kommen – aus einer API, einem Formular oder einer Datenbank –, kennt der Compiler nicht. Behauptet der Code, die Antwort eines Servers habe ein bestimmtes Format, glaubt TypeScript das. Ob es stimmt, muss eine Validierung zur Laufzeit klären. Mehr dazu weiter unten.

Wie das Typsystem Fehler früh sichtbar macht

Typangaben und Typinferenz

Typen lassen sich ausdrücklich angeben oder von TypeScript ableiten. Diese Ableitung heißt Typinferenz: Der Compiler erkennt aus dem zugewiesenen Wert selbst, welchen Typ eine Variable hat.

let kundenname: string = 'Müller GmbH'; // ausdrücklich angegeben
let menge = 3; // abgeleitet: number

menge = 'drei';
// Fehler: Type 'string' is not assignable to type 'number'.

function bruttoPreis(netto: number, steuersatz: number): number {
  return netto * (1 + steuersatz);
}

bruttoPreis('19.90', 0.19);
// Fehler: Argument of type 'string' is not assignable to parameter of type 'number'.

In der Praxis schreiben Sie Typen vor allem an Funktionsgrenzen, also bei Parametern und manchmal bei Rückgabewerten. Innerhalb von Funktionen genügt meist die Inferenz. Wer jede lokale Variable annotiert, macht den Code länger, aber nicht sicherer.

Objekte beschreiben: Interfaces und Typ-Aliase

Für Datenstrukturen gibt es Interfaces und Typ-Aliase. Beide beschreiben, welche Felder ein Objekt hat und welchen Typ diese Felder haben.

interface Bestellung {
  id: string;
  positionen: Position[];
  gutscheincode?: string; // optional
}

interface Position {
  artikelnummer: string;
  menge: number;
  einzelpreis: number;
}

function summe(bestellung: Bestellung): number {
  return bestellung.positionen.reduce(
    (gesamt, p) => gesamt + p.menge * p.einzelpreis,
    0,
  );
}

Der Nutzen zeigt sich nicht beim ersten Schreiben, sondern bei der nächsten Änderung. Benennt jemand im Team das Feld einzelpreis um, markiert der Editor sofort jede Stelle im Projekt, die noch den alten Namen verwendet. In reinem JavaScript fände man diese Stellen nur über eine Textsuche – oder gar nicht.

Union-Typen und Narrowing

Besonders hilfreich sind Union-Typen, also Typen, die mehrere Möglichkeiten zulassen. TypeScript verfolgt dann im Code, welche Möglichkeit an welcher Stelle noch infrage kommt. Dieses Eingrenzen heißt Narrowing.

type Zahlstatus =
  | { status: 'offen' }
  | { status: 'bezahlt'; bezahltAm: Date }
  | { status: 'fehlgeschlagen'; grund: string };

function statusText(z: Zahlstatus): string {
  switch (z.status) {
    case 'offen':
      return 'Zahlung ausstehend';
    case 'bezahlt':
      return `Bezahlt am ${z.bezahltAm.toLocaleDateString('de-DE')}`;
    case 'fehlgeschlagen':
      return `Fehler: ${z.grund}`;
  }
}

Im Zweig 'bezahlt' weiß der Compiler, dass bezahltAm vorhanden ist. Kommt später ein vierter Status hinzu, meldet TypeScript, dass die Funktion nicht mehr für jeden Fall einen Rückgabewert liefert. Solche Hinweise sind es, die große Codebasen über Jahre wartbar halten.

Der strict-Modus: Wo die eigentliche Sicherheit herkommt

Wie streng TypeScript prüft, steuert die Datei tsconfig.json. Die wichtigste Einstellung darin ist strict; seit TypeScript 6.0 ist sie standardmäßig aktiv. Sie schaltet eine Gruppe von Prüfungen ein, ohne die TypeScript nur einen Teil seines Nutzens entfaltet. Die bekannteste davon ist strictNullChecks: Werte, die null oder undefined sein können, müssen vor der Verwendung geprüft werden.

interface Kunde {
  name: string;
  email?: string;
}

function domain(kunde: Kunde): string {
  return kunde.email.split('@')[1];
  // Fehler (strict): 'kunde.email' is possibly 'undefined'.
}

function domainSicher(kunde: Kunde): string | undefined {
  return kunde.email?.split('@')[1];
}

Ohne strict würde der erste Code ohne Meldung kompiliert und zur Laufzeit mit „Cannot read properties of undefined“ abstürzen – einer der häufigsten JavaScript-Fehler überhaupt. Ebenfalls Teil von strict ist noImplicitAny. Es verhindert, dass Parameter ohne Typangabe stillschweigend den Typ any erhalten, mit dem jede Prüfung abgeschaltet ist.

Eine schlanke Konfiguration für ein neues Node.js-Projekt kann so aussehen:

{
  "compilerOptions": {
    "target": "ES2022",
    "module": "NodeNext",
    "strict": true,
    "noUncheckedIndexedAccess": true,
    "skipLibCheck": true,
    "types": ["node"],
    "rootDir": "src",
    "outDir": "dist"
  },
  "include": ["src"]
}

noUncheckedIndexedAccess gehört nicht zu strict, lohnt sich aber: Ein Zugriff wie liste[5] liefert dann den Typ „Element oder undefined“, weil das Element ja fehlen kann. Welche Optionen es sonst gibt und wie sie zusammenspielen, beschreibt ausführlich der Beitrag TypeScript 5 Konfiguration.

Unsere Empfehlung: Neue Projekte starten immer mit strict: true. Die Strenge nachträglich einzuschalten ist deutlich mühsamer als sie von Anfang an zu haben.

Wo TypeScript nicht hilft

TypeScript wird gelegentlich als Garant für fehlerfreien Code verkauft. Das ist es nicht, und es lohnt sich, die Grenzen zu kennen.

  • Logikfehler: Wenn eine Funktion den Rabatt falsch berechnet, aber eine Zahl zurückgibt, ist für TypeScript alles in Ordnung. Dafür braucht es weiterhin Tests.
  • Daten von außen: Eine Typangabe für eine API-Antwort ist eine Behauptung, keine Prüfung. Bibliotheken wie Zod oder Valibot prüfen eingehende Daten zur Laufzeit gegen ein Schema und leiten daraus gleichzeitig den TypeScript-Typ ab. Damit schließen sie diese Lücke.
  • Ausweichmanöver: Mit any, as (einer Typzusicherung, mit der Entwickler dem Compiler widersprechen) oder // @ts-ignore lassen sich Prüfungen umgehen. In einer Codebasis voller solcher Stellen ist TypeScript kaum mehr als Dekoration.

Für Teams heißt das: Die Sprache allein hebt die Qualität nicht. Erst die Kombination aus strenger Konfiguration, Code-Reviews, die auf any und as achten, und Tests bringt den gewünschten Effekt. Wie Teams das im Alltag regeln, beschreibt der Beitrag zu TypeScript Best Practices.

TypeScript ohne Build-Schritt: Type Stripping in Node.js

Lange galt TypeScript als Sprache mit Mehraufwand: Vor jedem Start musste der Code übersetzt werden. Das hat sich geändert. Neuere Node.js-Versionen können TypeScript-Dateien direkt ausführen, indem sie die Typangaben beim Laden einfach entfernen. Dieses Verfahren heißt Type Stripping. Seit Node.js 22.6 gab es das hinter einem experimentellen Schalter, seit Node.js 22.18 und 23.6 ist es standardmäßig aktiv und seit 24.12 als stabil eingestuft.

node src/server.ts

Zwei Einschränkungen gehören dazu. Erstens prüft Node.js dabei keine Typen, es wirft sie nur weg. Die Prüfung übernimmt weiterhin tsc --noEmit im Editor oder in der CI-Pipeline. Zweitens funktioniert das nur mit Syntax, die sich rein durch Löschen entfernen lässt. Sprachmittel, die eigenen JavaScript-Code erzeugen, etwa enum oder Parameter-Eigenschaften im Konstruktor, werden nicht unterstützt. Die Compiler-Option erasableSyntaxOnly meldet solche Stellen schon beim Schreiben. Auch die Laufzeitumgebungen Deno und Bun führen TypeScript direkt aus.

Parallel hat Microsoft den Compiler in der Programmiersprache Go neu implementiert; diese Fassung ist im Juli 2026 als TypeScript 7 erschienen. Laut Microsoft beschleunigt sie vollständige Builds großer Projekte typischerweise um das 8- bis 12-Fache. Für Teams mit großen Codebasen ist das interessant, weil lange Prüfzeiten im Editor und in der CI bisher ein häufiger Kritikpunkt waren.

Bestehende JavaScript-Projekte schrittweise umstellen

Ein großes JavaScript-Projekt muss nicht auf einen Schlag umgeschrieben werden. TypeScript ist ausdrücklich für den schrittweisen Umstieg gebaut. Ein bewährter Weg sieht so aus:

  1. TypeScript einführen, ohne Dateien umzubenennen. Mit allowJs und checkJs in der tsconfig.json prüft der Compiler bereits bestehende .js-Dateien. Typen lassen sich dort über JSDoc-Kommentare angeben.
  2. Dateien einzeln umstellen. Beginnen Sie mit Modulen, die wenige Abhängigkeiten haben, etwa Hilfsfunktionen oder Datenmodelle. Aus .js wird .ts, und die Fehlermeldungen zeigen, wo Typen fehlen.
  3. Grenzen zuerst typisieren. Den größten Nutzen bringen Typen für API-Antworten, Datenbankmodelle und die Schnittstellen zwischen Modulen.
  4. Strenge schrittweise erhöhen. Zuerst noImplicitAny, dann strictNullChecks, am Ende strict insgesamt.

So sieht eine typisierte JavaScript-Datei mit JSDoc aus, die TypeScript bereits prüft:

// @ts-check

/**
 * @param {number} netto
 * @param {number} steuersatz
 * @returns {number}
 */
export function bruttoPreis(netto, steuersatz) {
  return netto * (1 + steuersatz);
}

Angenommen, ein Mittelständler pflegt ein internes Bestellportal mit einigen zehntausend Zeilen JavaScript. Ein realistischer Plan stellt zuerst die Kommunikation mit dem Backend auf Typen um, weil dort die meisten Fehler entstehen, und arbeitet sich dann über Monate in die Oberfläche vor – parallel zur normalen Weiterentwicklung. Für Bibliotheken ohne eigene Typen gibt es die Pakete unter @types, die die Community pflegt. Einen ausführlichen Leitfaden für React, Angular und Vue bietet der Infothek-Artikel JavaScript zu TypeScript migrieren.

Lohnt sich TypeScript für Ihr Projekt?

Für die meisten Projekte, die länger als ein paar Wochen leben und an denen mehr als eine Person arbeitet, lautet die Antwort ja. Der Aufwand für Typangaben ist geringer, als viele erwarten, weil die Inferenz den Großteil erledigt. Der Gewinn zeigt sich vor allem bei Änderungen: beim Umbenennen, beim Erweitern von Datenmodellen, bei der Einarbeitung neuer Teammitglieder, die sich über Typen und Autovervollständigung im Code orientieren.

TypeScript hat sich in der Webentwicklung als Standard etabliert. Angular setzt es seit Jahren voraus, für React, Vue und Svelte bietet etwa der Projektgenerator von Vite TypeScript-Vorlagen an, und Node.js-Frameworks wie NestJS erzeugen neue Projekte direkt in TypeScript. Auch KI-Assistenten beim Programmieren profitieren davon: Typen geben ihnen Kontext, und der Compiler fängt einen Teil ihrer Fehler ab.

Weniger klar ist der Nutzen bei kleinen Skripten, Prototypen für einen Nachmittag oder Projekten, deren Team TypeScript nur widerwillig einsetzt und es mit any umgeht. Dort kann JavaScript mit JSDoc-Typen und @ts-check ein guter Kompromiss sein.

Wer die Sprache von Grund auf lernen möchte, findet im Beitrag TypeScript 5 Grundlagen einen systematischen Einstieg in Typen, Funktionen und Klassen. Für die Umstellung bestehender Anwendungen bietet MARTINSFELD Beratung, Coaching und Seminare zur Migration nach TypeScript an.

Häufige Fragen zu TypeScript

Macht TypeScript die Anwendung langsamer?

Nein. Die Typen werden vor der Ausführung entfernt, im Browser oder auf dem Server läuft ganz normales JavaScript. Zeit kostet allenfalls die Typprüfung während der Entwicklung, nicht die Anwendung selbst.

Muss das ganze Projekt auf einmal umgestellt werden?

Nein. JavaScript- und TypeScript-Dateien können im selben Projekt nebeneinander bestehen. Viele Teams stellen über Monate Datei für Datei um und erhöhen die Strenge schrittweise.

Sind mit TypeScript noch Tests nötig?

Ja. Typen verhindern Fehler wie falsche Datentypen oder fehlende Felder, aber keine falsche Geschäftslogik. Tests und Typen ergänzen sich: Weil Typfehler schon vom Compiler abgefangen werden, können sich Tests auf das fachliche Verhalten konzentrieren.

Was ist der Unterschied zwischen interface und type?

Für Objekttypen sind beide weitgehend austauschbar. Interfaces lassen sich nachträglich erweitern und erscheinen in Fehlermeldungen stets unter ihrem Namen, Typ-Aliase können zusätzlich Union-Typen und andere zusammengesetzte Typen beschreiben. Wichtiger als die Wahl ist, dass ein Team sie einheitlich trifft.

Mehr aus „Programmiersprachen“

PHP-Migration nach PHP2Shell: Upgrade oder Sprachwechsel?

PHP2Shell und das Support-Ende von PHP 8.2: Was Sie jetzt patchen sollten, wie ein Upgrade auf 8.4 oder 8.5 gelingt und wann ein Sprachwechsel sinnvoll ist.

mehr erfahren

Rusts Lieferkette unter Beschuss: Warum ein Angriff nur der Anfang war

Ein Angriff auf Rust-Pakete war im August 2026 schnell gestoppt, das Grundproblem bleibt. Wie crates.io angreifbar ist und was Sie heute dagegen tun können.

mehr erfahren

Programmiersprachen und KI: Warum Rust für Code-Agenten so gut passt

KI-Agenten schreiben in Rust oft verlässlicheren Code, weil der Compiler viele Fehler sofort meldet. Was dahinter steckt und wo das Argument endet.

mehr erfahren

Microsoft und Rust: Was hinter dem Ziel „C und C++ bis 2030“ steckt

Microsoft nutzt Rust im Windows-Kernel, der Ersatz von C und C++ bis 2030 ist aber ein Forschungsziel. Was belegt ist und was es für Entwickler bedeutet.

mehr erfahren

Warum Python, Go und Rust die Zukunft der Softwareentwicklung prägen

Python, Go und Rust teilen sich die Arbeit: Daten und KI, Cloud-Dienste, sichere Systeme. Wo jede Sprache passt, wie sie zusammenwirken und was KI daran ändert.

mehr erfahren

Facebook und PHP: Vom Abschied über HHVM zu Hack

Ein Rückblick von 2025: Wie Facebook PHP mit HipHop, HHVM und Hack umbaute, warum es sich von PHP löste und was davon in PHP selbst ankam.

mehr erfahren

Weitere Blog-Artikel

REST APIs mit JavaScript: Grundlagen von Ressourcen bis Statuscodes

REST APIs mit JavaScript verstehen: Ressourcen, HTTP-Methoden, Idempotenz und Statuscodes erklärt, mit fetch im Browser und einem Server in Node.js.

mehr erfahren

Dateiupload mit JavaScript: FormData, Fortschritt und sichere Server

Dateiupload mit JavaScript: Wie Sie Dateien per FormData und fetch senden, Fortschritt zeigen, große Dateien teilen und mit Express und multer sicher annehmen.

mehr erfahren

Agile Verträge verstehen: Modelle, Risiken und Vertragsgestaltung

Agile Verträge verbinden flexiblen Umfang mit klaren Regeln für Budget, Abnahme und Ausstieg. Sie erfahren, welche Modelle es gibt und wann sie passen.

mehr erfahren

Chatbots im Unternehmen: Was KI-Assistenten im Kundenservice leisten

Chatbots im Kundenservice: wie regelbasierte Bots und LLM-Assistenten mit RAG funktionieren, wo sie sich lohnen und was Sie bei Datenschutz und AI Act beachten.

mehr erfahren

WebAssembly: Wie C++ und Rust die Grenzen des Browsers verschieben

WebAssembly bringt Code aus C++, Rust oder C# in den Browser. Sie erfahren, wie Wasm funktioniert, wo es glänzt, wo seine Grenzen liegen und wie Sie einsteigen.

mehr erfahren

Nginx erklärt: Warum große Websites auf diesen Webserver setzen

Nginx liefert Websites aus, verteilt Last und terminiert TLS. Sie erfahren, wie die Architektur funktioniert und wie Sie Nginx sicher und schnell konfigurieren.

mehr erfahren

Aktuelle Blog-Artikel

PHP-Migration nach PHP2Shell: Upgrade oder Sprachwechsel?

PHP2Shell und das Support-Ende von PHP 8.2: Was Sie jetzt patchen sollten, wie ein Upgrade auf 8.4 oder 8.5 gelingt und wann ein Sprachwechsel sinnvoll ist.

mehr erfahren

Jev: Was ein KI-Modell für schnelles Denken anders macht als ChatGPT

Das System-1-KI-Modell Jev schreibt keinen Text, sondern beantwortet Fragen mit kalibrierten Wahrscheinlichkeiten. Wie das funktioniert und wofür es taugt.

mehr erfahren

Node.js ohne Ballast: 12 Bordmittel, die npm-Pakete ersetzen

Von fetch() über node:test bis Type Stripping: zwölf Node.js-Funktionen, die axios, dotenv, Jest und Co. ersetzen, mit Status in Node 24 und 26 und Grenzen.

mehr erfahren

KI-Agenten verstehen: MCP, A2A, AG-UI und A2UI einfach erklärt

MCP, A2A, AG-UI und A2UI verständlich erklärt: Wie KI-Agenten Werkzeuge nutzen, miteinander arbeiten und Oberflächen erzeugen – und wer die Standards betreut.

mehr erfahren

Rusts Lieferkette unter Beschuss: Warum ein Angriff nur der Anfang war

Ein Angriff auf Rust-Pakete war im August 2026 schnell gestoppt, das Grundproblem bleibt. Wie crates.io angreifbar ist und was Sie heute dagegen tun können.

mehr erfahren

Webentwicklung ohne SPA: Eine Web-App mit V, Veb, SQLite und htmx

Am Beispiel der Meetup-Plattform Clash zeigt sich, wie eine Web-App mit V, Veb, SQLite und htmx ohne SPA-Framework entsteht und wo der Ansatz an Grenzen stößt.

mehr erfahren

React-Performance: Warum weniger Optimierung mehr Tempo bringt

React-Performance heute: Wie Sie mit State am richtigen Ort, dem React Compiler, Transitions, Virtualisierung und Messung Ihre Anwendung spürbar beschleunigen.

mehr erfahren

React-Komponenten verbinden: Welcher Weg passt wann?

Props, Context, Zustand, TanStack Query, URL-Parameter oder Ereignisse: So wählen Sie den passenden Weg, damit zwei React-Komponenten Daten austauschen.

mehr erfahren

KI-Agenten in der Schleife: Loops in Claude Code und Codex

Was ein Loop bei KI-Agenten ist, welche Auslöser es gibt und wie Sie geplante Aufgaben in Claude Code und Codex mit Kostenkontrolle einrichten.

mehr erfahren

JavaScript 2026: Bun, Deno und TypeScript 7 läuten eine neue Ära ein

Node.js, Bun und Deno im Wettbewerb, TypeScript 7 mit Compiler in Go, Build-Werkzeuge in Rust: Was sich 2026 bei JavaScript ändert und was Sie davon übernehmen.

mehr erfahren

npm-Pakete sicher prüfen: So bewerten Sie ein Paket vor dem Einbau

npm-Pakete sicher prüfen: wie Sie Name, Wartung, Provenance, Install-Skripte, bekannte Lücken und Lizenz bewerten, bevor ein Paket in Ihr Projekt kommt.

mehr erfahren

npm install unter der Lupe: Wie Angreifer die Lieferkette kapern

Was npm install technisch tut, welche Angriffsmuster von Typosquatting bis Dependency Confusion es ausnutzen und wie Sie das Installieren absichern.

mehr erfahren

Programmiersprachen und KI: Warum Rust für Code-Agenten so gut passt

KI-Agenten schreiben in Rust oft verlässlicheren Code, weil der Compiler viele Fehler sofort meldet. Was dahinter steckt und wo das Argument endet.

mehr erfahren

Pi Agent vs. Claude Code: minimaler Open-Source-Agent im Vergleich

Pi Agent und Claude Code im Vergleich: Architektur, Erweiterungen, Modellwahl, Lizenz, Kosten und Sicherheit. Für wen sich der Open-Source-Agent lohnt.

mehr erfahren

Agentic Engine Optimization: Websites für KI-Agenten lesbar machen

Agentic Engine Optimization: Wie KI-Assistenten Ihre Website abrufen, welche Rolle robots.txt, llms.txt und strukturierte Daten spielen – und was belegt ist.

mehr erfahren

Claude Skills für Einsteiger: eigene KI-Workflows aufbauen

Claude Skills bündeln wiederkehrende Anweisungen in einer SKILL.md-Datei. So bauen Sie Skills auf und installieren sie in Claude und Claude Code.

mehr erfahren

Claude Code richtig nutzen: 15 Funktionen, die Profis kennen sollten

Claude Code kann mehr als chatten: So setzen Sie CLAUDE.md, Subagenten, Hooks, Skills, MCP und den Headless-Modus gezielt im Entwickleralltag ein.

mehr erfahren

Claude Code für Einsteiger: vom Terminal zur fertigen Anwendung

Claude Code arbeitet im Terminal direkt mit Ihren Dateien. So gelingen Installation, erste Aufträge, Planmodus, Skills und MCP auch ohne Programmiererfahrung.

mehr erfahren

OpenClaw im Praxistest: vom Chatbot zum digitalen Assistenten

OpenClaw macht ein Sprachmodell zum selbst gehosteten Agenten mit Zugriff auf Rechner und Messenger. Aufbau, Einrichtung, Skills und Sicherheitsregeln.

mehr erfahren

Das Ende der Menüs: Wie KI die digitale Arbeitsumgebung verändert

Seit Jahrzehnten bedienen wir Computer über Fenster, Menüs und Ordner. KI-Agenten verschieben das zu Aufträgen in Alltagssprache. Was sich ändert und was nicht.

mehr erfahren

Microsoft und Rust: Was hinter dem Ziel „C und C++ bis 2030“ steckt

Microsoft nutzt Rust im Windows-Kernel, der Ersatz von C und C++ bis 2030 ist aber ein Forschungsziel. Was belegt ist und was es für Entwickler bedeutet.

mehr erfahren

TanStack Start: Das React-Framework als Alternative zu Next.js

TanStack Start ist ein Fullstack-Framework für React auf Basis von TanStack Router und Vite. Was es kann und wann es eine Alternative zu Next.js ist.

mehr erfahren

Die Ralph-Wiggum-Technik: KI-Coding-Agenten, die nicht aufgeben

Die Ralph-Wiggum-Technik lässt einen Coding-Agenten denselben Auftrag wiederholen, bis die Tests bestehen. Wie sie funktioniert und worauf Sie achten sollten.

mehr erfahren

Warum KI Entwickler nicht ersetzt, aber ihre Rolle verändert

KI-Assistenten schreiben heute viel Code. Warum Fachwissen trotzdem wichtiger wird und welche Fähigkeiten Entwickler:innen jetzt gezielt ausbauen sollten.

mehr erfahren

Von Node.js zu Bun: Next.js-Projekte schrittweise umstellen

Wie Sie Bun in Next.js einsetzen: von bun install über bun --bun next dev bis zum Deployment. Was dabei schneller wird, was nicht und was Sie vorher prüfen.

mehr erfahren

Bun erklärt: JavaScript-Laufzeit, Paketmanager und Bundler in einem

Bun ist Laufzeitumgebung, Paketmanager, Bundler und Testrunner in einem. Wie es funktioniert, wie kompatibel es zu Node.js ist und für wen es sich lohnt.

mehr erfahren

KI-Agenten richtig anleiten: Spezifikationen, die funktionieren

Spezifikationen für KI-Coding-Agenten wie Claude Code oder GitHub Copilot: welche Angaben hineingehören, wie Sie Aufgaben aufteilen und Grenzen setzen.

mehr erfahren

Was ist .NET? Die Microsoft-Plattform einfach erklärt

.NET ist Microsofts quelloffene Entwicklungsplattform für Web, Cloud, Desktop und Apps. Sie erfahren, wie Laufzeit, SDK und Versionen zusammenhängen.

mehr erfahren

Künstliche Intelligenz 2026: Vom Chatbot zum digitalen Kollegen

Rückblick auf den KI-Ausblick vom Januar 2026: acht erwartete Trends von Multi-Agenten-Systemen über physische KI und EU AI Act bis zu Quanten-Utility.

mehr erfahren

KI-Jahr 2025: Vier Erkenntnisse und ein Ausblick auf 2026

Rückblick vom Januar 2026 auf das KI-Jahr 2025: vier Entwicklungen von unauffälligen Agenten bis zum Chipmangel und was sie damals für 2026 erwarten ließen.

mehr erfahren

REST und Event-Streams: Wann sich ereignisbasierte Backends lohnen

REST oder Event-Streams? Wie sich Request/Response und Publish/Subscribe unterscheiden, wann Kafka, SSE oder WebSockets passen und wo REST richtig bleibt.

mehr erfahren

Shai-Hulud 2.0: Wie sich ein Wurm im November 2025 durch npm fraß

Shai-Hulud 2.0 einfach erklärt: Rückblick auf den npm-Wurm vom November 2025, wie er Zugangsdaten stahl, sich selbst verbreitete und wie Sie sich schützten.

mehr erfahren

HTMX: Moderne Webanwendungen ohne JavaScript-Framework bauen

HTMX lädt Inhalte nach, sendet Formulare und tauscht Seitenteile per HTML-Attribut aus. Die Anleitung zeigt Browser- und Serverseite und den Stand von HTMX 4.

mehr erfahren

Electron vs. Tauri: Desktop-Apps mit Webtechnik im Vergleich

Electron bringt Chromium und Node.js mit, Tauri nutzt den Webview des Systems und einen Kern in Rust. Der Vergleich zeigt, wann sich welches Framework eignet.

mehr erfahren

Architekturkompetenz im KI-Zeitalter: Was Full-Stack heute heißt

Wenn KI-Werkzeuge Code schreiben, verschiebt sich die Arbeit zu Architekturentscheidungen. Welche Fähigkeiten zählen und wie Sie sie gezielt aufbauen.

mehr erfahren

Omarchy im Test: So macht Linux endlich wieder Spaß

Unser Test von Omarchy aus dem November 2025: Das Linux auf Basis von Arch und Hyprland setzt auf Tastatur, Kachelfenster und abgestimmte Themes.

mehr erfahren

JWT-Probleme: Warum Entwickler vor JSON Web Tokens warnen

JWT-Probleme im Überblick: Warum sich Tokens schwer widerrufen lassen, welche Prüffehler gefährlich sind und wann klassische Sessions die bessere Wahl sind.

mehr erfahren

7 KI-Begriffe erklärt: Von KI-Agenten bis Superintelligenz

Sieben KI-Begriffe von KI-Agenten über RAG und MCP bis Superintelligenz: was sie bedeuten, wie sie zusammenhängen und was davon für Unternehmen zählt.

mehr erfahren

Machine Learning verstehen: von den Grundlagen bis zu moderner KI

Machine Learning verständlich erklärt: welche Lernverfahren es gibt, wie Training mit Daten abläuft und wie Sie prüfen, ob ein Modell wirklich etwas taugt.

mehr erfahren

Scrum-Master-Rolle auf dem Prüfstand: ein Blick aus Architektursicht

Lohnt sich ein Scrum Master noch? Wir betrachten die Rolle aus Sicht der Softwarearchitektur, gleichen sie mit dem Scrum Guide 2020 ab und zeigen Alternativen.

mehr erfahren

Was dürfen wir für Sie tun?

So sind wir zu erreichen: