--- title: "ShipReal: Vom Vibe-Coder zum echten Software-Engineer" description: "Deine KI hat die App geschrieben. Den Teil, der sie am Laufen hält, hat niemand geschrieben. 11-teiliger Kurs, mit dem du deine mit KI gebaute App absicherst, deployst und skalierst." canonical: "https://shipreal.dev/de" last-updated: "2026-10-13" --- # Vom Vibe-Coder zum echten Software-Engineer > Deine KI hat die App geschrieben. Den Teil, der sie am Laufen hält, hat niemand geschrieben. 11-teiliger Kurs, mit dem du deine mit KI gebaute App absicherst, deployst und skalierst. Ton auf Englisch, Untertitel auf Deutsch. **38 Module, echte Post-Mortems, praktische Aufgaben und Quizze zum Selbsttest.** [YouTube](https://www.youtube.com/watch?v=fyHbx9de3GI&list=PLFEcqBh9-Xwo) · [Teachable](https://shipreal.teachable.com/courses/course/lectures/66619411) ## Kursinhalt ### Einführung Deine Karte für den ganzen Kurs: was jedes Deep-Dive-Modul liefert und wie die elf Teile aufeinander aufbauen. - **Einführung: Der Weg vor dir** (13 Kapitel, ~25 min): Die Karte auf dem Tisch: alle 38 Module, was jeder Deep Dive liefert, und zu welchem Modul du springst, wenn etwas kaputtgeht. ### Teil 1: Das Umdenken Dein Denken über funktionierende Software neu verdrahten: Systeme, State und Trade-offs. Die Urteilsschicht, die KI nicht liefern kann. - **Die Illusion von 'es läuft'** (12 Kapitel, ~28 min): Der Request-Lifecycle, Environments und der Produktions-Eisberg: warum 'läuft auf meinem Laptop' fast nichts bedeutet. - **In Systemen & State denken** (12 Kapitel, ~29 min): State, Seiteneffekte und Idempotenz: warum 'einfach nochmal laufen lassen' es manchmal schlimmer macht. - **Entscheidungen, Komplexität & Abstraktion** (14 Kapitel, ~36 min): Trade-offs, YAGNI und wann eine Abstraktion ihre Miete zahlt: die Urteilsfragen, die KI dir nicht abnehmen kann. ### Teil 2: Das Entwickler-Fundament Das tägliche Handwerk: Git als Denkwerkzeug, ein KI-nativer Workflow, Runtimes, Algorithmen, Frontend-Architektur und das Minenfeld der Dependencies. - **Versionskontrolle als Denkwerkzeug** (13 Kapitel, ~33 min): Git jenseits von commit und push: Branching-Strategie, bisect und blame als Archäologie. - **Der KI-native Engineering-Workflow** (13 Kapitel, ~31 min): Prompting als Spec-Schreiben, Code reviewen, den du nicht geschrieben hast, und die Leitplanken, die KI-Tempo sicher machen. - **Wie Code läuft: Die Runtime-Schicht** (13 Kapitel, ~33 min): Prozesse, Speicher und der Event Loop: warum Node blockiert und warum Pythons GIL zählt. - **Algorithmisches Denken: Komplexität & Datenstrukturen** (13 Kapitel, ~27 min): Big-O-Intuition und Arrays vs. Maps vs. Trees: wann N-Quadrat dich bei 10.000 Usern leise umbringt. - **Frontend-Architektur: Was KI für dich baut (und was sie falsch macht)** (13 Kapitel, ~35 min): Rendering-Modelle, State-Management und die Teile deines Frontends, die KI falsch aufsetzt. - **Dependency-Management: Das versteckte Minenfeld** (12 Kapitel, ~31 min): Lockfiles, Semver-Lügen und Supply-Chain-Angriffe: die left-pad-Geschichte und wie du nicht im Sequel mitspielst. ### Teil 3: Die Datenschicht Datenbanken als mentale Modelle: Tabellen und Indizes vor Queries, SQL ohne Angst und Migrationen, die Produktion nicht lahmlegen. - **Datenbank-Grundlagen: In Daten denken** (13 Kapitel, ~33 min): In Tabellen, Indizes und Constraints denken, bevor du eine einzige Query schreibst. - **SQL & Denken in Queries** (13 Kapitel, ~33 min): Joins ohne Angst, Query-Pläne, die du wirklich lesen kannst, und die Queries, die unter Last schmelzen. - **Daten im großen Stil: Mutationen, Migrationen & mehr** (13 Kapitel, ~34 min): Mutationen, Migrationen und Backfills, die Produktion nicht mit runterreißen. ### Teil 4: Netzwerke & Verträge Wie Systeme miteinander reden: APIs als Verträge, die DNS-zu-HTTP-Kette, auf der jeder Request lebt, und Realtime-Patterns. - **API-Design als Vertrag** (13 Kapitel, ~35 min): REST- vs. RPC-Denken, Versionierung und APIs weiterentwickeln, ohne die zu brechen, die darauf bauen. - **Netzwerk-Grundlagen** (12 Kapitel, ~33 min): DNS, TCP, TLS, HTTP: die Kette, an der jeder Request lebt oder stirbt. - **Realtime & eventgetriebene Patterns** (12 Kapitel, ~33 min): WebSockets, Server-Sent Events und eventgetriebene Flows: für den Moment, wenn Polling nicht mehr reicht. ### Teil 5: Festungsbau Damit es den Kontakt mit der Realität übersteht: Security by Default, robuste Fehlerbehandlung, Tests, die Vertrauen kaufen, und Observability, die 'was ist um 3 Uhr nachts kaputtgegangen' beantwortet. - **Security ab Werk** (12 Kapitel, ~35 min): OWASPs Top-Risiken, Injection und Auth-Fehler: die Angriffe, die dich finden, nicht umgekehrt. - **Fehlerbehandlung & Resilienz** (12 Kapitel, ~32 min): Timeouts, Retries mit Backoff und Circuit Breaker: elegant scheitern statt laut. - **Testing: Vertrauen, nicht Coverage** (12 Kapitel, ~33 min): Tests, die Vertrauen kaufen statt Coverage-Zahlen: was du testest, was du auslässt und warum. - **Observability: Logs, Metriken & Traces** (15 Kapitel, ~33 min): Logs, Metriken und Traces, die 'was ist um 3 Uhr nachts kaputtgegangen' beantworten, bevor es deine User tun. ### Teil 6: Infrastruktur & Deployment Worauf dein Code steht: was Container wirklich lösen, Cloud-Konzepte, die jedes Konsolen-Redesign überleben, und Pipelines, die schlechte Deploys blocken. - **Container: Warum, nicht wie** (12 Kapitel, ~35 min): Was Docker wirklich löst: Images vs. Container und warum 'läuft im Container' endlich etwas bedeutet. - **Cloud-Infrastruktur: Konzepte statt Konsolen-Klicks** (12 Kapitel, ~38 min): Der Entscheidungsbaum für Managed Services: Cloud-Konzepte, die jedes Konsolen-Redesign überleben. - **CI/CD: Die Pipeline, die dich schützt** (12 Kapitel, ~33 min): Die Pipeline, die schlechte Deploys blockt, bevor deine User sie finden. ### Teil 7: Architektur & Skalierung Für Wachstum entwerfen: Monolith-first-Architektur, Queues, Caching, Profiling vor dem Optimieren und Intuition für verteilte Systeme. - **Architektur-Patterns: Monolithen, Services & der Mittelweg** (13 Kapitel, ~34 min): Monolith-first denken, wann Services ihre Komplexität verdienen, und der Mittelweg, den niemand bewirbt. - **Asynchrone Verarbeitung & Queues** (14 Kapitel, ~34 min): Message Queues: warum jedes echte System eine hat, und was passiert, wenn Consumer nicht hinterherkommen. - **Caching-Strategien** (12 Kapitel, ~30 min): Redis, TTLs und Cache-Invalidierung: berühmt als eines der zwei harten Probleme der Informatik. - **Performance, Profiling & Skalierung** (14 Kapitel, ~33 min): Erst profilen, dann optimieren: den echten Flaschenhals finden statt den geratenen. - **Intuition für verteilte Systeme** (12 Kapitel, ~34 min): Die Trugschlüsse des verteilten Rechnens und die Intuition, sie im eigenen Design zu erkennen. ### Teil 8: Die Business-Schicht Der Code, der die Rechnungen bezahlt: Zahlungen und Compliance, Metriken, die Umsatz wirklich vorhersagen, und Attribution, ohne dich selbst zu belügen. - **Zahlungen, Abos & Compliance** (12 Kapitel, ~34 min): Payment-Webhooks, die Retries überleben, Abo-Zustandsmaschinen und die Compliance-Basics, die du nicht überspringen kannst. - **Business-Metriken & Produkt-Analytics** (13 Kapitel, ~35 min): Die Metriken, die Umsatz wirklich vorhersagen, und die Vanity-Metriken, die es nicht tun. - **Nutzergewinnung, Ads & Attribution** (13 Kapitel, ~36 min): UTMs, Attributionsfenster und Werbe-Mathematik, ohne dich selbst zu belügen. ### Teil 9: Produkte mit KI Intelligenz verantwortungsvoll ausliefern: wie Modelle lernen, Embeddings und RAG, und KI-Features in Produktion mit Evals und Kostenbudgets. - **Machine-Learning-Grundlagen: Wie Modelle lernen** (12 Kapitel, ~33 min): Wie Modelle wirklich lernen: genug, um dir von Demos und Anbietern nichts vormachen zu lassen. - **Intelligenz in deine App bringen** (13 Kapitel, ~33 min): Embeddings, RAG und das richtige Modell für die Aufgabe statt das lauteste. - **KI-Features für Produktion bauen** (12 Kapitel, ~33 min): Evals, Kosten- und Latenzbudgets, und LLM-Features, die echte User überstehen. ### Teil 10: Handwerk & Produktionsreife Die Senior-Gewohnheiten: hypothesengetriebenes Debugging und die Go-live-Checkliste, die Launches von Glücksspiel trennt. - **Debugging als Disziplin** (12 Kapitel, ~35 min): Hypothesengetriebenes Debugging: reproduzieren, isolieren, beweisen. Nicht print-Statements und beten. - **Produktionsreife & laufender Betrieb** (14 Kapitel, ~37 min): Die Go-live-Checkliste, Incident Response und der Betriebsrhythmus, der nach dem Launch beginnt. ### Teil 11: Der Sprung auf Mobile Auf dem Handy ändert sich alles: Offline-first-Daten, Netze, die mitten im Request verschwinden, und die Release-Trains der App-Stores. - **Mentale Modelle für Mobile** (13 Kapitel, ~33 min): Warum Mobile keine kleine Website ist: Lifecycles, Berechtigungen und das OS als strenger Vermieter. - **Mobile Daten & Networking** (12 Kapitel, ~37 min): Offline-first-Daten, Sync-Konflikte und Netze, die mitten im Request verschwinden. - **Mobile-Release & Distribution** (12 Kapitel, ~30 min): App-Store-Review, Release-Trains und warum du ein Binary nicht hotfixen kannst. ### Finale: Das Finale Der Schlusspunkt: was sich in deinem Denken verändert hat, und die eine Sache, die du sofort angehst, solange alles frisch ist. - **Das Finale: Jetzt liefere etwas aus, das hält** (7 Kapitel, ~12 min): Was sich in deinem Denken verändert hat, die eine Sache für diese Woche, und wie du das gewonnene Urteilsvermögen behältst. ## Häufige Fragen ### Für wen ist dieser Kurs? Entwickler, die durch Bauen gelernt haben, nicht durch Studieren. Du shippst täglich Apps mit KI-Tools (Copilot, Claude, ChatGPT) und bist schneller als je zuvor. Aber zwischen "es läuft" und "es ist sauber gebaut" liegt eine Lücke, und du spürst sie, wenn um 3 Uhr nachts etwas kaputtgeht oder ein Senior fragt: "Warum hast du das so gebaut?" Du bist kein Anfänger. Du kannst Code schreiben, aber nicht immer erklären, was nach dem Enter passiert. Genau diese Lücke schließt dieser Kurs. ### Was lehrt der Kurs, das ich nicht einfach prompten kann? Urteilsvermögen. KI schreibt inzwischen 80 % deines Codes; die 20 %, auf die es ankommt, sind Architektur, Fehlerbehandlung, das Sicherheitsmodell und Systemdesign. Diese 20 % verlangen ein Gespür für Trade-offs, Kontext und Konsequenzen, und genau das kann KI dir nicht abnehmen. Jedes Modul nimmt etwas, das du schon "kennst" (Datenbanken, APIs, Deployments), und zeigt dir, was dir fehlt: den Request-Lifecycle, Query-Pläne, Retry-Stürme, Cache-Invalidierung, die Go-live-Checkliste. ### Brauche ich ein CS-Studium oder einen bestimmten Tech-Stack? Kein Studium nötig. Der Kurs ist für Leute gebaut, die es übersprungen haben, oder eins hatten und das meiste vergessen haben. Er ist Konzept-first: Die Beispiele nutzen Mainstream-Tools wie PostgreSQL, Redis, Docker und Stripe, aber jedes Modul lehrt das mentale Modell, nicht das Durchklicken von Vendor-Konsolen, und lässt sich damit auf jeden Stack übertragen, mit dem du auslieferst. ### Was sind die Post-Mortems und Aufgaben? Jedes Modul seziert ein echtes, dokumentiertes Engineering-Desaster: echtes Unternehmen, echtes Datum, echte Root Cause, und was es verhindert hätte. Danach wendet die Aufgabe das Modul auf dein eigenes ausgeliefertes Projekt an, nicht auf ein Spielzeug-Repo. So endet jedes Modul damit, dass dein echtes System ein Stück produktionsreifer ist als vorher. ### Wie lange brauche ich dafür? Der Kurs umfasst 38 Lehrmodule von je 25 bis 40 Minuten, plus Aufgaben, und schließt mit einem kurzen Finale. Rechne mit rund 20 Stunden Video und ungefähr dem Doppelten mit den praktischen Aufgaben. Der Kurs besteht aus elf unabhängigen Teilen, du kannst also auch direkt zu dem Teil springen, der gerade brennt: Deploys kaputt? Teil 6. Query langsam? Teil 3. ### Bekomme ich ein Zertifikat? Ja! Und zwar verdient, nicht fürs Zuschauen verschenkt: das ShipReal-Abschlusszertifikat, über Teachable. Jedes Modul schließt mit einem Selbsttest-Quiz aus 10 Fragen und einer offenen Frage, und das Zertifikat gibt es, sobald du alle durchgearbeitet hast. ### Kann mein Unternehmen das fürs ganze Team kaufen? Ja. Plätze werden direkt verkauft, im 10er-Paket mit 20 % Rabatt, auf einer Rechnung, und sie wandern mit dem Team, wenn Leute kommen und gehen. Jeder Engineer bekommt den ganzen Kurs, angewendet auf das eigene Projekt statt auf eine geteilte Sandbox. 10er-Paket kaufen. Bei mehr als 20 Plätzen, oder wenn du eine PO brauchst, Single Sign-on über SAML oder OIDC, oder die Module als SCORM- oder xAPI-Pakete oder über LTI in eurem eigenen LMS, ob Cornerstone, Workday, Moodle oder was auch immer bei euch läuft: schreib mir und wir stecken den Rahmen gemeinsam ab. ### Und wenn es nichts für mich ist? Dann bekommst du dein Geld zurück. Für jeden Kauf gilt eine 30-Tage-Geld-zurück-Garantie ohne Begründung, und wie du sie einlöst, steht in den Erstattungsrichtlinien. ### In welchen Sprachen gibt es den Kurs? Die Tonspur ist vorerst nur auf Englisch. Der Kurs auf Teachable enthält Untertitel auf Englisch, Französisch, Deutsch, Italienisch, Spanisch & Hebräisch. Weitere Sprachen folgen bald. ### Ist das ein Abo? Nein. Du zahlst einmal und dein Zugriff ist unbegrenzt, inklusive aller Updates des Kurses. Wir sperren ihn nie. Nichts verlängert sich, nichts wird erneut abgebucht, und es gibt nichts zu kündigen. ## Legal [Privacy Policy](https://shipreal.dev/privacy) · [Terms of Service](https://shipreal.dev/terms) · [Refund Policy](https://shipreal.dev/refunds)