Im ersten Artikel dieser Reihe haben wir erklärt, wie man einen Computer für Vibe Coding vorbereitet. Wir haben Linux installiert, Codex und Antigravity eingerichtet, GitHub verbunden und unsere erste Anwendung mit Railway veröffentlicht.
Wir konnten mithilfe künstlicher Intelligenz eine kleine Anwendung entwickeln, ohne selbst Code zu schreiben.
Aber das war ein Test. Wir ließen Codex programmieren, prüften, ob alles funktionierte, und nutzten anschließend Antigravity, um das Ergebnis zu überprüfen. Für den Einstieg ist das in Ordnung, doch für echte Projekte brauchen wir mehr Struktur.
Was passiert, wenn mehrere Funktionen auf ihre Umsetzung warten? Wie verhindern wir, dass die KI Dateien verändert, die sie nicht anfassen sollte? Wer prüft vor dem Programmieren, ob eine Lösung vernünftig geplant ist? Und woher wissen wir, dass die veröffentlichte Version genau der geprüften entspricht?
Um diese Fragen zu beantworten, habe ich nach und nach meine eigene Arbeitsmethode entwickelt. Ich habe nichts Revolutionäres erfunden: Ich habe bewährte Vorgehensweisen der professionellen Softwareentwicklung an eine Umgebung angepasst, in der KI-Agenten einen großen Teil der Arbeit übernehmen.
Ich zeige dir Schritt für Schritt, wie ich das organisiere und anwende. Vielleicht hilft dir das, es selbst nachzumachen.
So organisiere ich die Arbeit mit KI-Agenten
Die Idee ist einfach: Eine KI entwickelt, eine andere prüft ihre Arbeit, und wir behalten die Kontrolle über die wichtigen Entscheidungen.
Ich nutze dafür fünf grundlegende Werkzeuge:
| Werkzeug | Aufgabe |
| Codex | Analysiert, plant, programmiert, testet und dokumentiert. |
| Antigravity | Prüft den Plan und den Code unabhängig. |
| GitHub | Speichert den Code, die Versionen und die Pull Requests. |
| Linear | Organisiert Aufgaben, Tests, Audits und Status. |
| Notion | Hält Anforderungen, Entscheidungen und den Projektverlauf fest. |
Dazu kommen noch zwei: Local WP bei Entwicklungen für WordPress und Convex oder Supabase, wenn eine Webanwendung eine Datenbank benötigt.
Notion ist optional, für mittelgroße Projekte empfehle ich es jedoch. Warum, sehen wir später.
Wir müssen auch nicht genau diese Anwendungen verwenden. Beispielsweise können wir Codex durch Claude Code ersetzen oder einen anderen Agenten als Prüfer einsetzen. Entscheidend ist die Trennung der Zuständigkeiten.
Der gesamte Ablauf sieht so aus:
- Anforderungen.
- Technischer Plan.
- Erstes Audit.
- Entwicklung und Tests.
- Zweites Audit.
- GitHub.
- Bereitstellung.
- Überprüfung.
Die Schritte 2 (Codex) und 3 (Antigravity) lassen sich mehrfach wiederholen: Findet Antigravity ein Problem, behebt Codex es und wir prüfen erneut. Wir arbeiten also in Entwicklungs- und Prüfzyklen und gehen erst zur nächsten Phase über, wenn keine wesentlichen Probleme mehr offen sind.
Bei meiner Arbeitsweise sind zwei Audits Pflicht, auch wenn ihre Tiefe von der Komplexität der Entwicklung abhängt. Das erste prüft, was wir vorhaben, das zweite, was wir tatsächlich umgesetzt haben.
Und etwas ist besonders wichtig: Ein GO des Prüfers ist noch keine Freigabe zur Veröffentlichung. Diese Entscheidung liegt weiterhin bei uns.
Schritt 1. Unsere Arbeitsumgebung mit Codex vorbereiten
Wir gehen von dem im ersten Tutorial eingerichteten Computer aus. Codex, Antigravity und GitHub funktionieren bereits, deshalb wiederholen wir die Installation nicht.
Wir öffnen ein Terminal im Projektordner und starten Codex:
cd ~/Proyectos/mi-proyecto
codex
Jetzt kommt einer meiner Lieblingsaspekte der Arbeit mit Agenten: Wir müssen die gesamte Projektstruktur nicht von Hand einrichten. Das können wir Codex überlassen.
Prompt 1. Die Arbeitsumgebung einrichten
Ich möchte dieses Projekt für einen beaufsichtigten KI-gestützten Entwicklungsprozess vorbereiten.
Du übernimmst die Analyse und Entwicklung. Antigravity ist der unabhängige Prüfer. Für den Code nutzen wir GitHub, für die Aufgaben Linear und optional Notion für die Dokumentation.
Untersuche das Projekt und überprüfe die verfügbaren Verbindungen. Schlage dauerhafte Anweisungen, eine minimale Dokumentation, Berechtigungsregeln und einen Ablauf mit zwei verpflichtenden Audits vor: eines für den technischen Plan und eines für den Code.
Implementierungen, wichtige Git-Vorgänge und Deployments benötigen eine menschliche Freigabe. Aufgaben werden erst nach der Überprüfung in Produktion abgeschlossen.
Lege zuerst einen Konfigurationsplan vor. Erstelle keine Dateien und ändere keine Dienste, bevor du eine Freigabe erhalten hast.
Codex sollte analysieren, was uns zur Verfügung steht, und uns sagen, was fehlt.
Normalerweise müssen wir einige Schritte selbst durchführen:
- Sich bei Linear oder Notion anmelden.
- Eine Integration autorisieren.
- Berechtigungen akzeptieren oder eine Verbindung erstellen, die eine Anmeldung im Browser erfordert.
SEHR WICHTIG: Wir dürfen keine Passwörter oder Tokens direkt in den Chat kopieren.
Wir verwenden die Authentifizierungsmechanismen der jeweiligen Dienste (Github und Claudflare bieten solche an) und erteilen nur die unbedingt nötigen Berechtigungen.
Sobald wir die Konfiguration genehmigt haben, kann Codex die Dateien vorbereiten und die Werkzeuge organisieren.
Allerdings kontrollieren wir, ob das tatsächlich geschehen ist. Deshalb fordern wir Codex auf, es zu überprüfen. Ein Agent kann keine Verbindung zu Linear herstellen, wenn seine Umgebung keine kompatible Integration bietet.
Schritt 2. Die Dokumentation organisieren, ohne das Repository mit Dateien zu überladen
Für die Arbeit mit Agenten brauchen wir etwas, das Gespräche allein nicht bieten: ein dauerhaftes Projektgedächtnis für die Arbeit.
Stell dir vor, wir entwickeln seit mehreren Wochen und starten eine neue Codex-Sitzung. Wir wollen nicht noch einmal die ganze Architektur erklären, welche Werkzeuge wir nutzen, welche Dateien bearbeitet werden dürfen und wie die Bereitstellung funktioniert.
Um das zu vermeiden, verwenden wir zwei grundlegende Dokumente im Repository:
- AGENTS.md: dauerhafte Anweisungen für Codex, Handlungsgrenzen und Entwicklungsregeln.
- PROJECT.md: Projektbeschreibung, grundlegende Architektur, Umgebungen und Links zur Dokumentation.
Codex kann sie anhand unserer Anforderungen erstellen.
Und wozu brauchen wir Notion?
Bei kleinen Projekten reichen Markdown-Dateien möglicherweise aus, um Änderungen und Entscheidungen zu dokumentieren. Sobald jedoch Funktionen, Entscheidungen, Anforderungen und Architekturänderungen dazukommen, sammeln sich zu viele Dokumente im Repository an.
Deshalb empfehle ich Notion für mittelgroße Projekte.
Dort speichern wir vor allem die PRDs (Product Requirements Document), technische Entscheidungen und den Projektverlauf. Linear erfasst Aufgaben, ihren Status, Audits und Tests. GitHub bewahrt den Code auf.
Das Interessante ist: Notion und Linear werden hauptsächlich von den Agenten selbst genutzt. Codex erstellt und aktualisiert die Dokumentation, prüft die Anforderungen vor dem Programmieren und hält Ergebnisse fest. Antigravity benötigt diese Informationen für seine Audits.
Wir müssen nicht selbst seitenweise Dokumentation schreiben. Unsere Aufgabe ist es, sicherzustellen, dass die Anforderungen und wichtigen Entscheidungen unseren Vorstellungen entsprechen.
Schritt 3. Festlegen, was wir entwickeln wollen
Als Beispiel nehmen wir eine echte Entwicklung, die ich für diese Website umgesetzt habe.
In meinem Magazin zeigten die Schlagwortseiten die Beiträge bisher chronologisch an. Ich wollte sie verbessern, damit die interessantesten Inhalte hervorgehoben werden ohne die übliche Liste zu verlieren.
So einen Wunsch können wir Codex in natürlicher Sprache erklären, obwohl eine solche Anfrage viele Fragen offenlässt.
- Wie viele Artikel wollen wir hervorheben?
- Wie entscheiden wir, welche relevant sind?
- Was passiert mit den übrigen?
- Soll es auf allen Seiten funktionieren?
- Welche Elemente wollen wir nicht verändern?
Bevor wir etwas analysieren, sollten wir diese Fragen klären.
Prompt 2. Anforderungen und technischen Plan vorbereiten
Ich möchte folgende Funktion entwickeln: [BESCHREIBUNG].
Lies die Anweisungen und die Projektdokumentation. Überführe den Bedarf in überprüfbare Anforderungen und Akzeptanzkriterien. Erstelle oder aktualisiere das PRD und organisiere die nötigen Aufgaben in Linear.
Untersuche den vorhandenen Code und schlage die einfachste Lösung vor, die die Anforderungen erfüllt. Benenne betroffene Dateien, Risiken, Alternativen und Tests.
Programmiere noch nicht. Frage mich nach funktionalen Entscheidungen, die du anhand der verfügbaren Informationen nicht selbst treffen kannst, und bereite den Plan für ein unabhängiges Audit vor.
Das ist einer der wichtigsten Unterschiede dazu, eine KI einfach irgendetwas programmieren zu lassen.
Codex hilft uns, aus einer Idee eine Spezifikation zu machen. Wir entscheiden, ob diese Spezifikation tatsächlich unseren Bedarf abbildet.
Bei den Schlagwörtern beispielsweise durfte sich das Akzeptanzkriterium nicht darauf beschränken, dass hervorgehobene Artikel erscheinen. Wir mussten auch die Navigation erhalten, unerwünschte Duplikate vermeiden und die korrekte Funktion auf den verschiedenen Seiten gewährleisten.
Sobald wir den Ansatz genehmigt haben, dokumentiert Codex ihn und erstellt den technischen Plan.
Noch haben wir keine einzige Zeile Code geschrieben.
Frontend-Design
In diesem Fall wusste ich genau, welches Design ich wollte, also bat ich nicht um visuelle Vorschläge. Allerdings würde ich sie in anderen Fällen an dieser Stelle anfordern, damit Codex sie berücksichtigt, bevor es die technische Lösung vorschlägt.
Wenn du schon weißt, was du willst, erklärst du es einfach. Und wenn du eine Backend-Funktion statt einer Frontend-Änderung brauchst, benötigst du auch keine Mockups.
Schritt 4. Erstes Audit: den Plan mit Antigravity prüfen
Jetzt kommt unser zweiter Agent ins Spiel.
Wir öffnen ein weiteres Terminal im selben Projektordner und führen Folgendes aus:
agy
In meinem derzeitigen Verfahren arbeitet Antigravity manuell. Wir lassen Codex Antigravity nicht automatisch aufrufen und ohne unsere Prüfung weitermachen.
Antigravity soll als unabhängiger Prüfer handeln, nicht als weiterer Programmierer, der beginnt, Dateien zu ändern.
Prompt 3. Den technischen Plan prüfen
Handle ausschließlich als unabhängiger technischer Prüfer.
Prüfe die Projektanweisungen, die Anforderungen und den von Codex vorgeschlagenen Plan. Beurteile, ob die Lösung umsetzbar, ausreichend einfach, sicher und mit der bestehenden Funktionalität vereinbar ist.
Prüfe Risiken, mögliche Regressionen und ob die geplanten Tests geeignet sind.
Gib ein begründetes Urteil ab: GO, bedingtes GO oder NO-GO. Falls dir ausreichende Belege fehlen, weise ausdrücklich darauf hin.
Benenne konkrete Probleme und notwendige Korrekturen. Verändere keine Dateien.
Warum schon vor der Entwicklung prüfen?
Weil eine Lösung perfekt programmiert sein kann und trotzdem eine schlechte Lösung ist.
Vielleicht führt sie eine unnötige Abhängigkeit ein, dupliziert bereits vorhandene Informationen, führt zu viele Abfragen aus oder erschwert die spätere Wartung.
Bei den Schlagwörtern reichte es beispielsweise nicht, hervorgehobene Beiträge anzuzeigen. Wir mussten auch prüfen, wie ihre Reihenfolge berechnet wird, ohne bei jedem Seitenaufruf langsame Vorgänge auszuführen.
Findet der Prüfer Probleme, geben wir seinen Bericht an Codex weiter. Codex überarbeitet den Plan, und wir prüfen ihn bei Bedarf erneut.
Mit dem Programmieren beginnen wir erst, wenn ein akzeptierter Plan und die menschliche Freigabe für seine Umsetzung vorliegen.
Schritt 5. Codex entwickelt und führt Tests durch
Mit dem genehmigten Plan beginnt die Umsetzung.
Codex arbeitet in einem Branch des Repositorys. Wenn du den ersten Teil gelesen hast, kennst du Git und GitHub bereits. Wir müssen also nicht erneut erklären, wie man sie benutzt.
Neu ist, dass wir nicht direkt an der stabilen Projektversion arbeiten. Wir bereiten Änderungen separat vor, um sie vor der Integration prüfen zu können.
Prompt 4. Die Funktion implementieren
Ich genehmige die Umsetzung des genehmigten und geprüften Plans für [LINEAR-AUFGABE].
Arbeite in einem eigenen Branch und beschränke die Änderungen auf den genehmigten Umfang.
Implementiere die Lösung, führe die relevanten Tests durch und prüfe mögliche Regressionen. Dokumentiere die Ergebnisse in Linear.
Bereite den vollständigen Diff vor, benenne die geänderten Dateien und liefere die Nachweise für das zweite Audit.
Führe weder einen Merge noch ein Deployment durch. Halte an, sobald die Entwicklung zur Prüfung bereitsteht.
Codex kann Dateien ändern, Tests ausführen und Fehler innerhalb des von uns genehmigten Umfangs beheben.
Aber auf eines müssen wir achten: Nur weil die KI behauptet, eine Funktion laufe, ist das noch kein Beweis dafür.
Wir brauchen Nachweise. Je nach Projekt können das automatisierte Tests, Ausführungsergebnisse, Funktionstests oder eine Kombination davon sein.
Außerdem müssen wir unterscheiden, was Codex tatsächlich getestet hat und was es noch nicht überprüfen kann.
Zurück zu unserem Beispiel: Es genügt nicht, dass drei hervorgehobene Artikel erscheinen. Wir müssen auch prüfen, was passiert, wenn weniger Artikel verfügbar sind, wenn man die Seite wechselt oder wenn Inhalte nicht die erwarteten Daten besitzen, etwa ein Artikel, der nicht in alle Sprachen übersetzt wurde.
Der Agent muss diese Prüfungen und etwaige Einschränkungen dokumentieren.
Schritt 6. Zweites Audit: den tatsächlichen Code prüfen
Die Funktion ist jetzt entwickelt, aber noch veröffentlichen wir sie nicht.
Wir kehren zu Antigravity zurück und bitten es, den geänderten Code zu prüfen, nicht einfach nur den von Codex erstellten Bericht.
Prompt 5. Die Implementierung prüfen
Handle als unabhängiger technischer Prüfer für [LINEAR-AUFGABE].
Prüfe den vollständigen Diff, den genehmigten Plan, die Anforderungen und die Testnachweise.
Suche nach Funktionsfehlern, Sicherheitsproblemen, Regressionen, unnötiger Komplexität und Änderungen außerhalb des genehmigten Umfangs.
Gib ein begründetes Urteil ab und benenne die Befunde nach Möglichkeit mit Datei und Position.
Erfasse den SHA-256-Fingerabdruck des geprüften Diffs, um die exakt geprüfte Version zu identifizieren.
Verändere keine Dateien und genehmige keine Commits, Merges oder Deployments.
Zwei Details sind wichtig.
Erstens muss Antigravity dieselben Regeln und Anforderungen einsehen können, die Codex verwendet hat. Sonst besteht die Gefahr, dass es eine technisch korrekte Lösung prüft, die unsere eigentlichen Anforderungen nicht erfüllt.
Zweitens müssen wir die Dokumentation des geprüften Änderungssatzes aufbewahren. So können wir genau feststellen, welche Version ein GO erhalten hat und ob der Code anschließend verändert wurde. Der Fingerabdruck muss reproduzierbar aus demselben Inhalt berechnet werden.
Ich speichere den vollständigen Vorgang in Linear, verknüpft mit der entsprechenden Aufgabe.
Findet Antigravity Fehler, kehren wir zu Codex zurück, lassen sie korrigieren und wiederholen das Audit.
Auch zwei Agenten können sich irren, selbst wenn sie sich einig sind. Deshalb sind Audits zusätzliche Kontrollen, keine absoluten Garantien. Und deshalb können wir optional ein drittes hinzufügen.
Schritt 7. Änderungen in GitHub integrieren
Nach einem GO des Audits können wir die Integration vorbereiten. Der übliche Ablauf lautet:
Branch > Commit > Push > Pull Request > Merge.
Wir müssen diese Befehle nicht selbst ausführen. Codex kann das übernehmen, aber wir müssen verstehen, was wir genehmigen.
Mit einer Pull Request können wir prüfen, welche Änderungen wir mit welchen Tests und Empfehlungen des Prüfers in den Hauptbranch übernehmen wollen.
Außerdem sollten wir kontrollieren, ob die zu integrierende Version noch immer die geprüfte ist. Ändern wir den Code nach einem GO, gilt die Bewertung möglicherweise nicht mehr.
Für wichtige Vorgänge bevorzuge ich ausdrückliche Freigaben. Manche können wir bündeln, wenn der Umfang eindeutig ist, aber wir sollten keine uneingeschränkte Erlaubnis für Integration und Veröffentlichung erteilen.
Es ist eine Sache, dass der Prüfer eine Entwicklung für korrekt hält, und eine andere, dass wir beschließen, sie zu übernehmen.
Hier könnte die dritte KI ins Spiel kommen: Wir können einen zweiten spezialisierten Prüfer wie CodeRabbit hinzufügen.
Anders als Antigravity, das wir zur lokalen Prüfung von Plan und Code einsetzen, kann CodeRabbit die Pull Requests auf GitHub vor dem Zusammenführen automatisch analysieren.
Für wichtige Projekte ist das eine interessante zusätzliche Kontrolle. Sie ist aber nicht zwingend und kostet Geld, auch wenn der Preis angesichts des Nutzens gering ist. Ich selbst bleibe vorerst bei den beiden manuellen Audits und erwäge die dritte Prüfung, wenn das Ganze größer wird.
Schritt 8. Bereitstellen und die Funktion in Produktion prüfen
Dieser Schritt hängt stark davon ab, wo unser Projekt gehostet wird.
Im ersten Teil haben wir Railway genutzt. Wir könnten aber auch über GitHub Actions, die Tools unseres Hosters oder ein anderes Deployment-System veröffentlichen.
Die Besonderheiten von WordPress, LocalWP und Webempresa behandeln wir in einem anderen Artikel.
Hier geht es um eine allgemeine Regel: Ein erfolgreich abgeschlossenes Deployment bedeutet nicht, dass die Funktion korrekt arbeitet.
Nach der Veröffentlichung müssen wir die echte Anwendung überprüfen.
In unserem Beispiel heißt das: die öffentlichen Seiten aufrufen, die hervorgehobenen Artikel prüfen, durch die Liste navigieren und sicherstellen, dass andere Funktionen unverändert geblieben sind.
Wir müssen außerdem bestätigen, dass die neue Version angezeigt wird. Manchmal wird der Code erfolgreich veröffentlicht, aber ein Cache liefert weiterhin alte Inhalte aus. Das ist mir mit WP Rocket passiert.
Bei wichtigen Entwicklungen sollten wir vorab wissen, wie wir bei Problemen zur stabilen Version zurückkehren können.
Erst nach diesen Prüfungen können wir sagen, dass die Funktion fertig ist.
Schritt 9. Die Aufgabe abschließen und die nächste Entwicklung vorbereiten
Nach der Überprüfung bitten wir Codex, Linear und die Projektdokumentation zu aktualisieren.
Es soll festhalten, was entwickelt wurde, welche Version veröffentlicht ist, welche Tests wir durchgeführt haben und ob noch Probleme offen sind.
Die Aufgabe gilt erst als abgeschlossen nach der Prüfung in Produktion, nicht wenn Codex fertig programmiert hat oder Antigravity sein GO erteilt.
Diese Dokumentation hat einen weiteren Vorteil: Wir können die Sitzung beenden und eine neue beginnen, ohne den Kontext zu verlieren.
Ich empfehle das sogar, wenn wir mit einer anderen Funktionbeginnen. Die Agenten können Regeln, Anforderungen und Entscheidungen aus den Projektdokumenten abrufen, statt sich auf endlose Chats zu verlassen.
Mit der Zeit können wir einen Teil der Abstimmung zwischen Codex und Antigravity automatisieren. Im Moment ziehe ich es aber vor, sie manuell zu steuern, den Ablauf zu überprüfen und Vertrauen aufzubauen, bevor ich Aufsichtsschritte weglasse.
Lohnt sich diese Arbeitsweise bei jeder Entwicklung?
Nein.
Wenn wir nur zwanzig Minuten lang etwas ausprobieren, wären Dokumentation, zwei Audits und ein Veröffentlichungsprozess übertrieben.
Wenn wir aber eine echte Website, eine Kundenanwendung oder ein Projekt entwickeln, das wir monatelang pflegen werden, ist der zusätzliche Aufwand absolut sinnvoll.
Der Vorteil dieses Verfahrens besteht nicht darin, Fehler zu beseitigen oder Programmierkenntnisse zu ersetzen. Es ermöglicht uns, strukturierter zu arbeiten, Entscheidungen festzuhalten und Probleme zu finden, bevor sie die Nutzer erreichen. Wir minimieren die typischen Fehler der ersten Vibe-Coding-Versuche.
Da die Agenten den Großteil der operativen Arbeit übernehmen, konzentrieren wir uns auf das Wesentliche: festlegen, was wir wollen, genehmigen, wie wir vorgehen, und kontrollieren, ob das Ergebnis funktioniert.
Fazit
Im ersten Artikel haben wir den Computer vorbereitet. In diesem haben wir unsere Arbeitsweise vorbereitet.
Jetzt wissen wir, wie wir:
- Einen Bedarf in Anforderungen übersetzen.
- Codex um einen Plan bitten.
- Ihn mit Antigravity prüfen.
- Eine Funktion entwickeln.
- Den Code prüfen.
- Sie mit Versionskontrolle veröffentlichen.
- Alles dokumentieren.
Es geht nicht nur darum, mithilfe künstlicher Intelligenz schneller zu programmieren, sondern darum, das Entwickelte langfristig pflegen zu können, zu verstehen, was geändert wurde, und ein Verfahren zu haben, um auftretende Probleme zu beheben.
Im nächsten Teil übertragen wir diese Arbeitsweise auf WordPress: lokale Entwicklung, Tests, versionierte Dateien und Deployments auf einem echten Hosting-Server.
Häufige Fragen
Muss ich programmieren können, um dieses Verfahren zu nutzen?
Selbst Code zu schreiben ist nicht zwingend nötig. Aber man sollte die Grundlagen der Entwicklung verstehen und lernen, Tests und Risiken richtig einzuschätzen. Die KI nimmt uns die Verantwortung für das Ergebnis nicht ab.
Muss ich Codex und Antigravity verwenden?
Nein. Du kannst sie durch andere Entwicklungs- und Prüfagenten ersetzen. Wichtig ist, die Aufgaben zu trennen und zu vermeiden, dass der Entwickler als Einziger seine eigene Arbeit beurteilt.
Brauche ich Notion und Linear?
Linear ist das Aufgabenwerkzeug in diesem Tutorial. Für einfache Projekte ist Notion optional; ich empfehle es aber, wenn sich Anforderungen, Entscheidungen und Dokumentation ansammeln. Alternativ kannst du diese Informationen in Markdown festhalten.
Was mache ich, wenn Antigravity ein NO-GO erteilt?
Gib den Bericht an Codex weiter, lass die Probleme beheben und wiederhole das Audit. Gehe nicht automatisch zur nächsten Phase über.
Warum zweimal prüfen?
Weil das erste Audit Probleme beim Konzept sucht und das zweite die Umsetzung prüft. Wer nur den Code prüft, übersieht womöglich Designfehler, die sich vorher leichter hätten beheben lassen.
Kann ich diese Arbeitsweise mit WordPress oder anderen Technologien nutzen?
Ja. Das Verfahren ist unabhängig von Sprache und Plattform. Nur Tests, Umgebungen und Veröffentlichungsmechanismen unterscheiden sich.
Wann ist eine Aufgabe wirklich abgeschlossen?
Wenn die freigegebene Version veröffentlicht wurde, ihre Funktion in Produktion geprüft ist und Nachweise und Entscheidungen dokumentiert sind.

Schreibe einen Kommentar