Vom Junior zum Senior: Lehren, die meinen Code verändert haben

Der Pfad, von dem dir niemand erzählt

Als ich meine Karriere begann, dachte ich, ein Senior Engineer zu werden bedeutete, mehr Frameworks zu lernen und mehr Code zu schreiben. Sieben Jahre später weiß ich, dass die größten Sprünge davon kamen, wie ich über Software denke zu ändern, nicht welche Tools ich verwende.

Lektion 1: Einfachheit ist die schwierigste Fähigkeit

Junior-Ich liebte cleveren Code. Senior-Ich löscht cleveren Code.

// What I wrote at year 1 — "look how smart I am"
const result = data.reduce(
  (a, b) => ({ ...a, [b.type]: [...(a[b.type] || []), b] }),
  {},
);
 
// What I write now — readable, debuggable, maintainable
const grouped = new Map<string, Item[]>();
for (const item of data) {
  const existing = grouped.get(item.type) ?? [];
  existing.push(item);
  grouped.set(item.type, existing);
}

Die zweite Version ist länger, aber jeder Ingenieur kann sie in Sekunden verstehen. Die erste erfordert jedes Mal mentales Parsen, wenn jemand sie liest.

Die Regel: Code wird 10-mal mehr gelesen als geschrieben. Optimiere für den Leser.

Lektion 2: Verstehe das Problem, bevor du Code schreibst

Früh in meiner Karriere habe ich angefangen zu coden, sobald ich die Feature-Anfrage verstanden habe. Jetzt verbringe ich den Großteil meiner Zeit damit:

1. Das eigentliche Problem zu verstehen — nicht nur, was gefragt wurde, sondern warum
2. Den Lösungsraum zu erkunden — es gibt immer mehrere Ansätze
3. Einschränkungen zu identifizieren — Deadlines, bestehende Systeme, Team-Fähigkeiten
4. Ein kurzes Design-Dokument zu schreiben — selbst 5 Bullet Points zwingen zur Klarheit

Der schnellste Code, den du ausliefern kannst, ist der, den du nicht schreibst. Manchmal ist die beste Lösung eine Konfigurationsänderung, eine Prozessverbesserung oder das Zurückweisen einer Anforderung.

Lektion 3: Tests geben um Vertrauen, nicht um Coverage

Ich habe mich früher auf 100% Code-Coverage fixiert. Jetzt schreibe ich Tests, die mir Vertrauen zum Deployen geben.

// ❌ Testing implementation details
test("calls setLoading before fetch", () => {
  // Brittle — breaks on any refactor
});
 
// ✅ Testing behavior
test("shows user profile after successful load", async () => {
  render(<UserProfile userId="123" />);
  expect(await screen.findByText("Jane Doe")).toBeInTheDocument();
  expect(screen.getByText("jane@example.com")).toBeInTheDocument();
});

Fokussiere dich auf:

• Kritische Pfade — Checkout, Authentifizierung, Datenmutationen
• Edge Cases, die dich schon einmal gebissen haben — Zeitzonen-Bugs, leere Zustände, gleichzeitige Updates
• Integrationstests statt Unit Tests — teste die Verträge zwischen Systemen, nicht einzelne Funktionen

Lektion 4: Kommunikation ist ein Multiplikator

Die größte Überraschung in meiner Karriere: Der Unterschied zwischen einem guten und einem großartigen Ingenieur ist vor allem Kommunikation.

Dinge, die ich gelernt habe zu tun:

• Klare PR-Beschreibungen schreiben — erkläre das Warum, nicht nur das Was
• Entscheidungen dokumentieren, nicht nur Code — dein zukünftiges Ich wird deinem jetzigen Ich danken
• Bedenken früh ansprechen — "Ich denke, dieser Zeitplan ist riskant, weil..." ist wertvoller als zu spät zu liefern
• Um Hilfe bitten — die besten Ingenieure, die ich kenne, stellen die meisten Fragen

Ein Senior Engineer, der durchschnittlichen Code schreibt, aber brillant kommuniziert, liefert mehr Wert als ein Genie, das isoliert arbeitet.

Lektion 5: Verantworte das System, nicht nur deinen Code

Junior-Ingenieure beheben Bugs. Senior-Ingenieure beheben die Systeme, die Bugs erzeugen.

Wenn etwas kaputt geht, frage ich:

• Warum ist dieser Bug in Produktion gelandet?
• Welche Prozess- oder Tooling-Änderung würde diese Bug-Klasse verhindern?
• Ist unser Monitoring ausreichend, um das früher zu erkennen?

Das kann bedeuten, bessere Linting-Regeln einzurichten, einen Pre-Commit-Check hinzuzufügen, CI/CD-Pipelines zu verbessern oder ein Runbook für häufige Incidents zu erstellen. Das Ziel ist, das Team schneller zu machen, nicht nur dich selbst.

Lektion 6: Technische Schuld ist eine Geschäftsentscheidung

Nicht alle technische Schuld ist schlecht. Manche ist bewusst — schnell ausliefern, um eine Idee zu validieren, bevor man in eine perfekte Lösung investiert. Die Fähigkeit ist es, zu erkennen:

• Bewusste Schuld — dokumentiert, zeitlich begrenzt, mit einem Plan zur Behebung
• Unbeabsichtigte Schuld — durch Shortcuts entstanden, die niemand verfolgt hat
• Bit rot — einmal guter Code, der mit den sich ändernden Anforderungen nicht Schritt gehalten hat

Wenn ich heute einen Refactor vorschlage, rahme ich ihn geschäftlich ein: "Das wird unsere Deployment-Zeit von 45 Minuten auf 8 Minuten reduzieren und dem Team ermöglichen, drei Releases pro Tag statt einem zu shippen."

Lektion 7: Mentoring macht dich besser

Lehren zwingt dich, Dinge auf einer tieferen Ebene zu verstehen. Jedes Mal, wenn ich einem Junior-Ingenieur ein Konzept erkläre, finde ich Lücken in meinem eigenen Verständnis.

Konkrete Wege, wie ich mentor:

• Pair Programming — nicht Vorlesen halten, sondern gemeinsam laut denken
• Code Review als Lehre — erkläre das Warum hinter Vorschlägen
• Sichere Räume zum Scheitern schaffen — Juniors Stretch-Projekte mit Sicherheitsnetzen überlassen

Die besten Teams, in denen ich war, hatten eine Kultur, in der jeder lehrt und jeder lernt, unabhängig vom Titel.

Was ich meinem Junior-Ich sagen würde

1. Lies mehr Code, als du schreibst — studiere, wie großartige Ingenieure Probleme lösen
2. Investiere in Grundlagen — Datenstrukturen, Netzwerke und OS-Konzepte zahlen sich ewig aus
3. Baue Dinge außerhalb der Arbeit — Side Projects lehren dich, was Enterprise-Arbeit nicht kann
4. Finde früh einen Mentor — ein Gespräch kann dir Monate von Trial and Error ersparen
5. Sei geduldig — Meisterschaft wird in Jahren gemessen, nicht in Sprints

Die Reise vom Junior zum Senior ist keine gerade Linie. Sie ist eine Reihe von Mentalitätswechseln, von denen jeder eine neue Art eröffnet, über Software und Teams nachzudenken. Umarme das Unbehagen des Nichtwissens — dort passiert das Wachstum.