diff --git a/README.md b/README.md
index c21e69a..ab00d66 100644
--- a/README.md
+++ b/README.md
@@ -1,2 +1,171 @@
-# blackjack
+# Blackjack Game Design Document
 
+## 1. Flowchart (Spielablauf)
+```mermaid
+flowchart TD
+    A([Start]) --> B[Deck erstellen und mischen]
+    B --> C[Spieler und Dealer erhalten je 2 Karten]
+    C --> D{Blackjack?}
+    D -->|Ja| E[Gewinner sofort ermitteln]
+    D -->|Nein| F[Spielerzug: Hit oder Stand]
+    F --> G{Bust?}
+    G -->|Ja| H[Dealer gewinnt]
+    G -->|Nein| F
+    F --> I[Spieler steht]
+    I --> J[Dealer zieht bis >= 17]
+    J --> K{Bust?}
+    K -->|Ja| L[Spieler gewinnt]
+    K -->|Nein| M[Vergleich der Punkte]
+    M --> N{Wer näher an 21?}
+    N -->|Spieler| O[Spieler gewinnt]
+    N -->|Dealer| P[Dealer gewinnt]
+    N -->|Gleichstand| Q[Push]
+    O --> R[Ergebnis anzeigen]
+    P --> R
+    Q --> R
+    R --> S{Neues Spiel?}
+    S -->|Ja| B
+    S -->|Nein| T([Ende])
+```
+
+## 2. UML-Klassendiagramm
+```mermaid
+classDiagram
+    class Card {
+        - rank: str
+        - suit: str
+        - value: int
+        + __str__(): str
+    }
+
+    class Deck {
+        - cards: List[Card]
+        + shuffle(): void
+        + deal_card(): Card
+    }
+
+    class Hand {
+        - cards: List[Card]
+        - value: int
+        - aces: int
+        + add_card(card: Card): void
+        + calculate_value(): int
+        + adjust_for_ace(): void
+    }
+
+    class Player {
+        - name: str
+        - chips: int
+        - hand: Hand
+        + hit(deck: Deck): void
+        + stand(): void
+    }
+
+    class Dealer {
+        + play(deck: Deck): void
+    }
+
+    class Game {
+        - deck: Deck
+        - player: Player
+        - dealer: Dealer
+        + play_round(): void
+        + compare_hands(): str
+        + show_cards(): void
+    }
+
+    Player <|-- Dealer
+    Game --> Player
+    Game --> Dealer
+    Game --> Deck
+    Player --> Hand
+    Hand --> Card
+    Deck --> Card
+```
+
+## 3. Implementierungs-Roadmap mit Tests
+
+### Phase 1: Grundstruktur
+- **Ziel:** Klassen anlegen, ohne Logik.
+- Dateien: `card.py`, `deck.py`, `hand.py`, `player.py`, `dealer.py`, `game.py`, `main.py`.
+- Methoden-Signaturen definieren.
+
+**Test:** Importiere alle Klassen in `main.py` und prüfe, ob keine Fehler auftreten.
+
+---
+
+### Phase 2: Card
+- `__init__`: Speichert Rang, Farbe, Wert.
+- `__str__`: Gibt z. B. "K♠" zurück.
+
+**Test:**
+```python
+card = Card("A", "♠")
+print(card)  # Erwartet: A♠
+```
+
+---
+
+### Phase 3: Deck
+- `__init__`: Erzeugt 52 Karten.
+- `shuffle()`: Mischt die Karten.
+- `deal_card()`: Gibt eine Karte zurück und entfernt sie.
+
+**Test:**
+- Prüfe, ob `len(deck.cards) == 52` nach Erstellung.
+- Nach `deal_card()`: Länge = 51.
+
+---
+
+### Phase 4: Hand
+- `add_card(card)`: Fügt Karte hinzu.
+- `calculate_value()`: Summiert Werte.
+- `adjust_for_ace()`: Reduziert Ass von 11 auf 1, wenn nötig.
+
+**Test:**
+- Hand mit Ass + 9 → Wert = 20.
+- Hand mit Ass + 9 + 5 → Wert = 15.
+
+---
+
+### Phase 5: Player & Dealer
+- `Player.hit(deck)`: Karte ziehen.
+- `Dealer.play(deck)`: Zieht bis Wert ≥ 17.
+
+**Test:**
+- Spieler zieht Karte → Handgröße +1.
+- Dealer zieht automatisch bis ≥ 17.
+
+---
+
+### Phase 6: Game
+- `play_round()`: Ablauf wie im Flowchart.
+- `compare_hands()`: Gewinner bestimmen.
+- `show_cards()`: Karten anzeigen.
+
+**Test:**
+- Simuliere eine Runde:
+  - Spieler steht sofort.
+  - Dealer spielt.
+  - Ergebnis wird angezeigt.
+
+---
+
+### Phase 7: Erweiterungen
+- Chips & Einsätze.
+- Mehrere Spieler.
+- Features wie Split, Double Down.
+
+**Test:**
+- Chips reduzieren sich nach Einsatz.
+- Gewinn/Verlust korrekt berechnet.
+
+---
+
+### Teststrategie
+- **Unit-Tests** für jede Klasse (z. B. mit `pytest`).
+- **Integrationstest**: Komplette Runde simulieren.
+- **Edge Cases**:
+  - Mehrere Asse.
+  - Spieler oder Dealer hat Blackjack.
+  - Beide haben denselben Wert.