SOLID-Prinzipien in moderner Webentwicklung: Was funktioniert noch?

SOLID-Prinzipien in moderner Webentwicklung: Was funktioniert noch?

Fünf Regeln aus der Objektorientierung im Praxistest: Was in TypeScript, React und Node.js trägt und was Teams getrost lockerer sehen dürfen

Aktualisiert:

Abstract

SOLID in TypeScript, React und Node.js: welche der fünf Prinzipien heute noch tragen, wo sie überzogen werden und wie Sie sie pragmatisch einsetzen.
  • #SOLID Prinzipien
  • #Software Design
  • #Webentwicklung
  • #TypeScript
  • #React
  • #Clean Code
  • #Architektur
  • #Single Responsibility Principle
  • #Open-Closed Principle
  • #Liskov Substitution Principle
  • #Interface Segregation Principle
  • #Dependency Inversion Principle
  • #Dependency Injection
  • #Moderne Softwareentwicklung
  • #Best Practices
  • #Code Wartbarkeit
  • #Entwurfsmuster

Klassen werden seltener, die Ideen dahinter bleiben: SOLID gilt heute für Komponenten, Module und Funktionen

Ein typisches Frontend-Projekt im Jahr 2026 enthält kaum noch Klassenhierarchien. Komponenten sind Funktionen, Zustand steckt in Hooks oder Signals, das Backend besteht aus ein paar Route-Handlern in Node.js. Wer in so einem Projekt im Code-Review „Das verletzt SOLID“ sagt, erntet schnell ein Stirnrunzeln: Die Prinzipien stammen schließlich aus der Welt von Java und C++, in der Vererbung das zentrale Werkzeug war.

Trotzdem tauchen dieselben Probleme auch in modernen Webanwendungen auf. Eine Komponente, die Daten lädt, Preise formatiert und nebenbei Analytics verschickt, ist schwer zu testen. Ein Service, der seine Datenbank selbst erzeugt, lässt sich nicht austauschen. Die Frage ist also nicht, ob SOLID veraltet ist, sondern welche der fünf Ideen in heutigem TypeScript-Code noch tragen und welche Teams lockerer sehen dürfen.

Woher SOLID kommt und warum die Frage berechtigt ist

Die fünf Prinzipien hat Robert C. Martin um das Jahr 2000 zusammengestellt, das Kürzel SOLID prägte wenig später Michael Feathers. Einzelne Bausteine sind älter: Das Open-Closed Principle geht auf Bertrand Meyer zurück (1988), das Liskov Substitution Principle auf Barbara Liskov (1987). Gemeint waren sie für objektorientierte Systeme mit langen Lebenszyklen und vielen Teams, in denen jede Änderung an einer Basisklasse kostspielig war.

Webentwicklung funktioniert heute anders. TypeScript arbeitet mit strukturellen Typen, also mit Typen, die allein über ihre Form verglichen werden, nicht über eine explizite Vererbungsbeziehung. React, Vue oder Svelte setzen auf Komposition statt auf Unterklassen. Deployments laufen mehrmals am Tag, und ein Refactoring über die ganze Codebasis ist mit einer guten IDE eine Sache von Minuten. Das verschiebt die Gewichte: Manche Prinzipien sind wichtiger geworden, andere haben ihre ursprüngliche Begründung teilweise verloren.

Wer die fünf Prinzipien zuerst Schritt für Schritt kennenlernen möchte, findet die Grundlagen im Beitrag SOLID-Prinzipien in der Praxis. Hier geht es um die Einordnung: Was davon bewährt sich in modernen Web-Projekten?

Single Responsibility: Gilt für Komponenten, Hooks und Module

Das Single Responsibility Principle (SRP) besagt, dass ein Baustein nur einen Grund haben sollte, sich zu ändern. Martin selbst hat später klargestellt, dass mit „Grund“ eher eine Person oder Rolle gemeint ist: die Fachabteilung, die Preise festlegt, das Design-Team, das die Darstellung bestimmt, die IT, die den Datenbankzugriff verantwortet. Wenn zwei dieser Gruppen denselben Code ändern wollen, kollidieren ihre Wünsche.

Dieses Prinzip hat am besten gealtert, weil es nicht an Klassen hängt. Es passt auf Funktionen, Module, React-Komponenten, Hooks und ganze Services. Angenommen, ein Webshop zeigt eine Bestellübersicht an:

// Vorher: Laden, Rechnen und Darstellen in einer Komponente
export function OrderPage({ orderId }: { orderId: string }) {
  const [order, setOrder] = useState<Order | null>(null);

  useEffect(() => {
    fetch(`/api/orders/${orderId}`)
      .then((res) => res.json())
      .then(setOrder);
  }, [orderId]);

  if (!order) return <p>Lädt …</p>;

  const total = order.items.reduce((sum, i) => sum + i.price * i.qty, 0);
  return <p>Summe: {(total / 100).toFixed(2)} €</p>;
}

// Nachher: jede Verantwortung an ihrem Ort
export function orderTotal(order: Order): number {
  return order.items.reduce((sum, i) => sum + i.price * i.qty, 0);
}

export const formatEuro = (cents: number) =>
  new Intl.NumberFormat('de-DE', { style: 'currency', currency: 'EUR' }).format(
    cents / 100,
  );

export function OrderSummary({ order }: { order: Order }) {
  return <p>Summe: {formatEuro(orderTotal(order))}</p>;
}

export function OrderPage({ orderId }: { orderId: string }) {
  const order = useOrder(orderId); // eigener Hook, kapselt das Laden
  if (!order) return <p>Lädt …</p>;
  return <OrderSummary order={order} />;
}

Die Preisberechnung lässt sich jetzt ohne Browser und ohne Netzwerk testen, die Darstellung ohne Server, und wenn das Laden später auf TanStack Query oder Server Components umgestellt wird, ändert sich nur der Hook.

Die Grenze liegt dort, wo die Aufteilung selbst zum Problem wird. Zehn Dateien mit je drei Zeilen sind nicht übersichtlicher als eine Datei mit dreißig Zeilen. Eine brauchbare Faustregel: Aufteilen, wenn sich Teile unabhängig voneinander ändern oder getestet werden sollen, nicht vorsorglich.

Auch auf Architekturebene gilt SRP. Ein API-Gateway ruft viele Dienste auf, hat aber eine einzige Aufgabe: einen einheitlichen Zugang zu bieten. Ein Microservice, der Rechnungen schreibt und nebenbei Newsletter verschickt, ist dagegen ein Kandidat für die Aufteilung.

Open/Closed: Für APIs und Bibliotheken wichtig, im eigenen Code oft überschätzt

„Software-Einheiten sollten offen für Erweiterung, aber geschlossen für Veränderung sein.“ Das Open-Closed Principle (OCP) klingt elegant und ist zugleich das am häufigsten missverstandene der fünf. In vielen Codebasen hat es zu Plugin-Mechanismen, Fabriken und Strategie-Klassen geführt, die nie mehr als eine Implementierung hatten.

Unsere Einschätzung: Innerhalb einer einzelnen Anwendung, deren Code das Team vollständig kontrolliert, ist Veränderung kein Risiko, das man vermeiden muss. Dort zählt, dass Code leicht änderbar ist. Typprüfung, automatisierte Tests und Refactoring-Werkzeuge machen Änderungen sicherer als jede vorab gebaute Erweiterungsschicht. Anforderungen ändern sich ohnehin anders, als man beim Entwurf vermutet.

Anders sieht es aus, wo andere von Ihrem Code abhängen, ohne dass Sie deren Code anpassen können.

Öffentliche Web-APIs

Wer eine API für Partner, Apps oder Kunden betreibt, kann Verträge nicht beliebig ändern. Neue Felder kommen hinzu, bestehende bleiben erhalten:

// Antwort, auf die sich bestehende Clients verlassen
interface UserResponse {
  id: string;
  name: string;
}

// Erweiterung ohne Bruch: neue Felder sind optional
interface UserResponseV2 extends UserResponse {
  email?: string;
  avatarUrl?: string;
}

Das funktioniert nur, wenn Clients unbekannte Felder ignorieren. Umbenennen oder Entfernen eines Felds ist dagegen ein Breaking Change und gehört in eine neue API-Version.

Bibliotheken und Design-Systeme

Ähnlich ist es bei Bibliotheken und internen Komponentenbibliotheken. Wer eine Tabellenkomponente für zehn Produktteams pflegt, sollte Erweiterungspunkte vorsehen, etwa Render-Props, children oder Callback-Optionen für eigene Zellformate. In React ist Komposition die natürliche Form von OCP: Die Komponente bleibt unverändert, das Verhalten kommt von außen.

Liskov: Weniger Vererbung, aber Verträge bleiben

Das Liskov Substitution Principle (LSP) verlangt, dass ein Untertyp überall dort einsetzbar ist, wo der Obertyp erwartet wird, ohne dass sich das Programm anders verhält als zugesagt. Im klassischen Lehrbuchbeispiel erbt ein Quadrat von einem Rechteck und bricht dabei die Erwartung, dass sich Breite und Höhe unabhängig setzen lassen.

Weil moderne Webprojekte Vererbung selten einsetzen, gilt LSP oft als das am wenigsten relevante Prinzip. Das stimmt nur halb. Die Vererbungsfrage hat sich durch „Composition over Inheritance“, also den Grundsatz, Verhalten eher zusammenzusetzen als zu erben, weitgehend erledigt. Der Kern von LSP betrifft aber jede Implementierung einer Schnittstelle, auch ohne extends:

interface KeyValueCache {
  get(key: string): Promise<string | undefined>;
  set(key: string, value: string, ttlSeconds: number): Promise<void>;
}

// Hält den Vertrag ein: speichert nichts, liefert nie einen Treffer
class NoopCache implements KeyValueCache {
  async get() {
    return undefined;
  }
  async set() {}
}

// Verletzt den Vertrag: Aufrufer rechnen nicht mit einer Ausnahme
class ReadOnlyCache implements KeyValueCache {
  constructor(private data: Map<string, string>) {}
  async get(key: string) {
    return this.data.get(key);
  }
  async set(): Promise<void> {
    throw new Error('Schreiben wird nicht unterstützt');
  }
}

TypeScript akzeptiert beide Klassen, denn die Signaturen passen. Der Fehler zeigt sich erst zur Laufzeit, wenn ein Aufrufer den ReadOnlyCache bekommt. Genau davor schützt LSP: Eine Schnittstelle ist mehr als ihre Typen, sie ist ein Versprechen über Verhalten. Das gilt für Adapter zu Zahlungsanbietern, Speicher-Backends oder Mock-Objekte in Tests gleichermaßen.

Wo eine Implementierung eine Methode nicht sinnvoll erfüllen kann, ist meist die Schnittstelle zu breit. Damit ist man beim nächsten Prinzip.

Interface Segregation: Schmale Props und schmale Abhängigkeiten

„Clients sollten nicht von Schnittstellen abhängen, die sie nicht nutzen.“ Das Interface Segregation Principle (ISP) ist in TypeScript besonders leicht umzusetzen, weil strukturelle Typen keine explizite Implementierung verlangen. Eine Funktion kann genau die Form beschreiben, die sie braucht, und jedes Objekt mit dieser Form passt.

// Zu breit: wer nur lesen will, hängt trotzdem an Export und Backup
interface DocumentStore {
  load(id: string): Promise<Doc>;
  save(doc: Doc): Promise<void>;
  remove(id: string): Promise<void>;
  exportAll(): Promise<Blob>;
  backup(): Promise<void>;
}

// Schmal: jede Funktion verlangt nur, was sie aufruft
type DocReader = Pick<DocumentStore, 'load'>;
type DocWriter = Pick<DocumentStore, 'save' | 'remove'>;

async function showPreview(store: DocReader, id: string) {
  const doc = await store.load(id);
  return doc.title;
}

Im Frontend zeigt sich dasselbe Muster bei Props. Eine Komponente UserBadge, die das komplette User-Objekt mit Adresse, Rollen und Einstellungen bekommt, obwohl sie nur Name und Avatar anzeigt, ist schwerer wiederzuverwenden und schwerer zu testen. Mit Pick<User, 'name' | 'avatarUrl'> als Prop-Typ wird die Abhängigkeit sichtbar, und die Komponente lässt sich auch mit Daten aus einer anderen Quelle füllen.

Auf Architekturebene ist ISP eine Spielart der losen Kopplung: Ein Dienst sollte von möglichst wenig Funktionalität anderer Dienste abhängen. Das betrifft auch versteckte Abhängigkeiten wie globale Variablen, Singletons oder Umgebungsvariablen, die tief im Code gelesen werden. Sie tauchen in keiner Signatur auf und überraschen erst, wenn ein Test in einer anderen Umgebung läuft.

Dependency Inversion: Das Prinzip mit der größten Wirkung

Das Dependency Inversion Principle (DIP) besagt, dass fachliche Logik nicht von technischen Details abhängen soll, sondern beide von Abstraktionen. Praktisch heißt das: Der Code, der eine Bestellung abschließt, kennt eine Schnittstelle „Zahlung ausführen“, aber nicht das SDK eines bestimmten Zahlungsanbieters.

Wichtig ist die Abgrenzung zu Dependency Injection. DIP ist das Prinzip, die Richtung der Abhängigkeiten. Dependency Injection ist eine Technik, um es umzusetzen: Abhängigkeiten werden von außen übergeben, statt im Code selbst erzeugt. Frameworks wie Angular oder NestJS bringen dafür einen eigenen Container mit, wie im Beitrag über Angular Services und Dependency Injection beschrieben. In vielen TypeScript-Projekten genügen aber einfache Parameter:

interface PaymentGateway {
  charge(orderId: string, amountCents: number): Promise<{ ok: boolean }>;
}

interface Mailer {
  send(to: string, subject: string, body: string): Promise<void>;
}

// Fachlogik kennt nur die Schnittstellen
export function createCheckout(deps: {
  payments: PaymentGateway;
  mailer: Mailer;
}) {
  return async function checkout(order: Order) {
    const result = await deps.payments.charge(order.id, orderTotal(order));
    if (!result.ok) throw new Error('Zahlung abgelehnt');
    await deps.mailer.send(
      order.email,
      'Bestellbestätigung',
      `Nr. ${order.id}`,
    );
  };
}

// Verdrahtung an einer Stelle, etwa beim Start der Anwendung
// const checkout = createCheckout({ payments: stripeGateway, mailer: smtpMailer });

Der größte Nutzen zeigt sich beim Testen. Statt einen echten Zahlungsanbieter anzusprechen, übergibt der Test eine Attrappe:

import { describe, it, expect, vi } from 'vitest';

describe('checkout', () => {
  it('verschickt nach erfolgreicher Zahlung eine Bestätigung', async () => {
    const payments = { charge: vi.fn().mockResolvedValue({ ok: true }) };
    const mailer = { send: vi.fn().mockResolvedValue(undefined) };
    const checkout = createCheckout({ payments, mailer });

    await checkout({ id: 'A-17', email: 'kunde@example.com', items: [] });

    expect(mailer.send).toHaveBeenCalledWith(
      'kunde@example.com',
      'Bestellbestätigung',
      'Nr. A-17',
    );
  });
});

DIP ist außerdem das Fundament der gängigen Architekturstile. Schichtenarchitektur, Hexagonal- oder Onion-Architektur und Clean Architecture ordnen Code so, dass die Fachlogik innen liegt und Datenbank, HTTP und Frameworks außen. Auch die derzeit oft diskutierte Vertical Slice Architecture, die Code nach Funktionen statt nach technischen Schichten schneidet, nutzt innerhalb jedes Slices dieselbe Idee.

Im Großen findet sich das Prinzip ebenfalls wieder: Anwendungen prüfen Anmeldungen nicht selbst, sondern verlassen sich auf einen Identitätsanbieter über ein Standardprotokoll wie OpenID Connect. Dienste kommunizieren über Warteschlangen oder Event-Broker und kennen nur das Nachrichtenformat, nicht den Empfänger.

Wo SOLID in modernen Projekten überzogen wird

Die Prinzipien selbst sind selten das Problem, wohl aber ihre mechanische Anwendung. Drei Muster begegnen in Code-Reviews immer wieder:

  • Interfaces mit genau einer Implementierung, die nur existieren, „weil man das so macht“. In TypeScript lässt sich eine Schnittstelle jederzeit nachträglich aus einer konkreten Klasse ableiten, wenn eine zweite Implementierung tatsächlich ansteht.
  • Abstraktionen auf Vorrat: Strategie-Muster, Fabriken und Plugin-Registries für Varianten, die es nie geben wird. Sie kosten Lesbarkeit, ohne etwas zu schützen.
  • Zerstückelung im Namen von SRP: Komponenten und Funktionen, die so klein geschnitten sind, dass man für einen einfachen Ablauf durch ein Dutzend Dateien springen muss.

Ein guter Gegencheck ist die Frage, welche konkrete Änderung eine Abstraktion leichter macht. Gibt es darauf keine Antwort, ist der direkte Code meist die bessere Wahl. Daneben gibt es Grundsätze, die in Webprojekten oft schwerer wiegen als SOLID: klare Namen, unveränderliche Daten, reine Funktionen ohne Seiteneffekte und eine durchgängige Typisierung. Wie diese Regeln zusammenspielen, beschreibt der Beitrag zur langfristig wartbaren Frontend-Architektur.

Was das für Ihr Team bedeutet

Unterm Strich hat SOLID besser gealtert, als die Herkunft aus der Java-Welt vermuten lässt, allerdings mit verschobenen Gewichten:

PrinzipBedeutung heuteWo es sich zeigt
Single ResponsibilityhochKomponenten, Hooks, Module, Services
Open/Closedgezieltöffentliche APIs, Bibliotheken, Design-Systeme
Liskov Substitutionals VertragsdenkenAdapter, Implementierungen von Schnittstellen
Interface SegregationhochProps, Funktionsparameter, Service-Grenzen
Dependency Inversionsehr hochTestbarkeit, Architekturschichten

Für die meisten Teams lohnt es sich, bei Single Responsibility und Dependency Inversion anzusetzen. Beide verbessern Testbarkeit und Verständlichkeit sofort und lassen sich ohne neue Werkzeuge umsetzen. Interface Segregation kommt in TypeScript fast nebenbei, sobald Funktionen nur noch die Daten verlangen, die sie tatsächlich nutzen. Open/Closed sollte bewusst an den Stellen eingesetzt werden, an denen andere von Ihrem Code abhängen, und Liskov als Erinnerung, dass jede Implementierung den Vertrag ihrer Schnittstelle einhalten muss.

Überschätzt wird SOLID dort, wo es als Checkliste im Review dient. Die Prinzipien sind Begründungshilfen: Sie erklären, warum ein bestimmter Code schwer zu ändern ist. Sie ersetzen nicht das Urteil, ob sich eine Abstraktion in diesem Projekt lohnt.

Wer Architekturentscheidungen dieser Art für ein konkretes Projekt treffen oder im Team verankern möchte, findet auf unseren Themenseiten zur Frontend-Architektur und zur Codequalität mit TypeScript Angebote für Beratung, Coaching und Seminare.

Häufige Fragen zu SOLID in der Webentwicklung

Sollte man SOLID in jedem Projekt anwenden?

Nicht dogmatisch. In Prototypen und kleinen Werkzeugen ist direkter, gut lesbarer Code meist sinnvoller als eine Schichtenarchitektur. Mit wachsender Codebasis und mehreren Entwickler:innen steigt der Nutzen. Ein guter Einstieg sind klare Zuständigkeiten pro Modul und Abhängigkeiten, die als Parameter übergeben werden.

Wie passt SOLID zu funktionaler Programmierung?

Die Kernideen lassen sich übertragen. Eine Funktion mit einer Aufgabe entspricht SRP, schmale Parametertypen entsprechen ISP, und Abhängigkeiten, die als Argumente hereinkommen, setzen DIP um. Funktionale Stile mit unveränderlichen Daten vermeiden viele Probleme, die LSP ursprünglich adressierte, weil es keine Vererbung und keinen geteilten veränderlichen Zustand gibt.

Braucht man für Dependency Inversion einen DI-Container?

Nein. Ein Container wie in Angular oder NestJS ist praktisch, wenn ein Framework ihn ohnehin mitbringt oder sehr viele Abhängigkeiten verdrahtet werden müssen. In den meisten React- und Node.js-Projekten reichen Funktionsparameter, Factory-Funktionen oder React Context für die wenigen Stellen, an denen Implementierungen getauscht werden.

Was ist wichtiger: SOLID oder Clean Code?

Das ist kein Gegensatz. SOLID ist ein Teil dessen, was unter Clean Code verstanden wird, und betrifft vor allem den Zuschnitt von Modulen und deren Abhängigkeiten. Aussagekräftige Namen, kurze Funktionen und verständliche Tests gehören ebenso dazu. Lesbarer Code im Kleinen ist die Voraussetzung, damit sich gute Struktur im Großen überhaupt auszahlt.

Mehr aus „Softwarearchitektur“

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

Spec-Driven Development mit GitHub Spec Kit erklärt

GitHub Spec Kit führt KI-Coding-Agenten von der Spezifikation über Plan und Aufgaben zum Code. Wie Befehle und Dateien zusammenspielen und wo Grenzen liegen.

mehr erfahren

Modulare Software-Architektur nach dem Blackbox-Prinzip

Modulare Software-Architektur nach dem Blackbox-Prinzip: Kapselung, stabile Schnittstellen, Plugins und klare Formate machen Ihre Systeme langlebig.

mehr erfahren

Software-Architekturmuster: Die wichtigsten Muster im Überblick

Software-Architekturmuster von Schichten über Hexagonal und Event-driven bis Microservices: Sie erfahren, was jedes Muster löst und wann es sich lohnt.

mehr erfahren

Backend for Frontend: Wann sich eigene Backends je Client lohnen

Das Backend-for-Frontend-Muster erklärt: ein Backend je Client-Typ, Abgrenzung zu API-Gateway und GraphQL, BFF als Sicherheitsmuster und seine Kosten.

mehr erfahren

Serverless vs. Container: die richtige Technologie wählen

Serverless-Funktionen oder Container? Wann sich welches Modell eignet, welche Rolle Lastprofil, Latenz und Kosten spielen und warum Mischformen häufig sind.

mehr erfahren

Weitere Blog-Artikel

JavaScript-Frameworks: Zu viele Frameworks, zu wenige Paradigmen

Viele klagen über zu viele JavaScript-Frameworks. Das eigentliche Problem sind wenige Grundmodelle. Was Signals, Server-first und Webstandards daran ändern.

mehr erfahren

npm-Sicherheit: Abhängigkeiten und Pakete gegen Angriffe absichern

npm-Sicherheit in der Praxis: wie Sie mit Lockfiles, npm ci, gesperrten Installationsskripten, 2FA und Trusted Publishing Ihre Lieferkette schützen.

mehr erfahren

Svelte und der Compiler-Ansatz: Was ohne virtuelles DOM anders ist

Svelte übersetzt Komponenten beim Build in gezielte DOM-Updates. Sie erfahren, wie das im Vergleich zu React, Signalen und dem React Compiler funktioniert.

mehr erfahren

Monolithen skalieren: Was Netflix und Prime Video wirklich zeigen

Auch Monolithen skalieren horizontal. Lesen Sie, was die Fälle Netflix und Prime Video wirklich zeigen und wann eine einzelne Anwendung große Last trägt.

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

Warum Google Go schuf, Mozilla Rust nutzte und Banken bei Java bleiben

Google entwickelte Go, Mozilla förderte Rust, Banken bleiben bei Java. Welche Gründe dahinterstehen und welche Kriterien für Ihre eigene Sprachwahl taugen.

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: