--- title: "ShipReal: Vom Vibe-Coder zum echten Software-Engineer" description: "Deine AI hat die App geschrieben. Den Teil, der sie am Laufen hält, hat niemand geschrieben. Dieser 20-Stunden-Kurs schließt genau diese Lücke." canonical: "https://shipreal.dev/de" last-updated: "2026-08-31" --- # Vom Vibe-Coder zum echten Software-Engineer > Deine AI hat die App geschrieben. Den Teil, der sie am Laufen hält, hat niemand geschrieben. Dieser 20-Stunden-Kurs schließt genau diese Lücke. Ton auf Englisch, Untertitel auf Deutsch. **38 Module, echte Postmortems, praktische Aufgaben und Quizze zur Selbstkontrolle.** [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 Verdrahte neu, wie du über funktionierende Software denkst: Systeme, State und Trade-offs. Die Urteilsschicht, die AI 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 AI dir nicht abnehmen kann. ### Teil 2: Das Entwickler-Fundament Das tägliche Handwerk: Git als Denkwerkzeug, ein AI-nativer Workflow, Runtimes, Algorithmen, Frontend-Architektur und das Minenfeld der Abhängigkeiten. - **Versionskontrolle als Denkwerkzeug** (13 Kapitel, ~33 min): Git jenseits von commit und push: Branching-Strategie, bisect, und blame als Archäologie. - **Der AI-native Engineering-Workflow** (13 Kapitel, ~31 min): Prompting als Spec-Schreiben, Code reviewen, den du nicht geschrieben hast, und die Leitplanken, die AI-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 AI für dich baut (und was sie falsch macht)** (13 Kapitel, ~35 min): Rendering-Modelle, State-Management und die Teile deines Frontends, die AI 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 in den Abgrund reiß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 & Event-getriebene Patterns** (12 Kapitel, ~33 min): WebSockets, Server-Sent Events und ereignisgetriebene 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, Warteschlangen, 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 & Warteschlangen** (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 AI Intelligenz verantwortungsvoll ausliefern: wie Modelle lernen, Embeddings und RAG, und AI-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. - **AI-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 AI-Tools (Copilot, Claude, ChatGPT) und bist schneller als je zuvor. Aber zwischen "es läuft" und "es ist Engineering" 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. AI 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 AI 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 überträgt sich damit auf jeden Stack, mit dem du auslieferst. ### Was sind die Postmortems und Aufgaben? Jedes Modul in Complete 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? Complete 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 Quiz aus 10 Fragen zur Selbstkontrolle 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, zum Preis pro Platz in den Team-Plänen oben, auf einer Rechnung, und sie wandern mit dem Team, wenn Leute kommen und gehen. Jeder Engineer bekommt den Complete-Kurs, angewendet auf das eigene Projekt statt auf eine geteilte Sandbox. Ab 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? Fang mit den kostenlosen Überblicken auf YouTube an: Da merkst du schnell, ob der Kurs deine Sprache spricht. Darüber hinaus ist die Garantie in der Preistabelle die ganze Antwort, und wie du sie einlöst, steht in den Erstattungsrichtlinien. ### In welchen Sprachen gibt es den Kurs? Die Tonspur ist vorerst nur auf Englisch. Complete auf Teachable enthält Untertitel auf Englisch, Französisch, Deutsch, Italienisch, Spanisch & Hebräisch. Weitere Sprachen folgen bald. ## Legal [Privacy Policy](https://shipreal.dev/privacy) · [Terms of Service](https://shipreal.dev/terms) · [Refund Policy](https://shipreal.dev/refunds)