Prompt Engineering: Iteration Guide Deluxe v2.0

Die 4 Phasen der Iteration

Phase 1: Fundament

Persona-Definition: Hochspezifische Expertenrolle
Constraint-Käfig: Definiere Leitplanken
Struktur: Zero-Shot & Context-Building

Phase 2: Drill-Down

Feedback-Loop: Bewerte beste Ideen
Vektor-Wechsel: Ändere Parameter
Visual Check: Strukturiere das Problem

Phase 3: Devil's Advocate

Red Teaming: Zerstöre deine Ideen
Kritik-Integration: Schwachstellen beheben
Robustness-Check: Validierung

Phase 4: Synthese

Formatierung: Production-Ready Output
Cross-Pollination: Kombiniere beste Elemente
Final Polish: Deluxe-Level

Agentic Workflows & Computer Use Runtime

State-Action-Reflection Framework

Iteration bei autonomen Agenten läuft über den Execution-Loop. Jeder Schritt wird dokumentiert und reflektiert.

Observation

Was siehst du auf Screen/Terminal?

Reasoning

Warum ist Aktion X nächster Step?

Action

Führe X aus & dokumentiere

Reflection

Hat X gewünschtes Ergebnis gebracht?

The Loop of Doom Prevention: Wenn Agent 3x denselben Fehler macht → Error State eintragen → Alternative Pfad wählen

Detaillierte Step-Beschreibungen:

Observation: Parse Bildschirm/Terminal. Was ist die aktuelle State? Constraints? Sichtbare Fehler?
Reasoning: Evaluiere nächste 3-5 mögliche Actions. Wähle die mit höchster Success-Probability.
Action: Execute mit Timeout. Log Output. Check für Exceptions.
Reflection: Vergleiche erwartetes vs. aktuelles Ergebnis. Führe zur nächsten Runde oder Fehlerbehandlung.

Observer-Agent Drill: Multi-Agent Monitoring

Setup: Agent A (Operator) führt aus, Agent B (Observer) watchet.

Agent	Rolle	Responsibility	Trigger
Agent A	Operator	Computer Use, Taskausführung	User-Prompt
Agent B	Observer / Auditor	Analysiere Screenshots, Logs. Gib Korrektiv-Feedback an A	Jeder Step von A
Feedback Loop	Dynamic Injection	Wenn A 3x gleicher Fehler → Re-Prompt A	Failure Pattern erkannt

Resultat: Self-correcting Agent System mit externer Validierung.

Semantic Anchors: Power-Words für Vector Space

Diese "High-Gravity-Words" ziehen das Modell sofort in eine bestimmte semantische Nachbarschaft. Strategisch einstreuen = Drama-freie Vektor-Manipulation.

Cross-Model Validation: The Handover Protocol

Model-Switch Briefing Template

# HANDOVER-BRIEFING: Model A → Model B

## Current State Summary
- Projekt: [Beschreibung]
- Bisherige Entscheidungen: [Constraints, Personas, Prompts]
- Aktuelle Probleme: [Was funktioniert nicht?]
- Semantic Anchors applied: [Liste]

## Context Injection Points
1. Behalte folgende Constraints: [...]
2. Nutze folgende Success-Metriken: [...]
3. Model-specific instructions für B: [...]

## Validation Checklist
- [ ] Output-Qualität beibehalten oder verbessert
- [ ] Neue Perspektive bringt 3+ Alternativen
- [ ] Cross-Check: Model A ≠ Model B → Konflikt-Auflösung durchführen
                                

The Adversarial Model Loop

Schritt	Agent	Aktion	Output
1	Model A	Erstelle Lösung	Code/Design/Konzept
2	Model B	Suche 5 Sicherheitslücken/logische Gaps	Critical Review
3	Model A	Widerlege Kritik ODER integriere Fixes	Verbesserte Lösung v2
Final	Human	Validiere & akzeptiere	Production Release

Der 3-Step Code Review Loop

Step 1: Exploration

„Was kann hier im schlimmsten Fall falsch gehen?"

Edge Cases, Halluzinationen, Sicherheitslücken identifizieren

Step 2: Implementation

„Schreibe die Optimierung, behalte Rückwärtskompatibilität"

Implementiere mit Refactoring Patterns (Strategy, Factory)

Step 3: Test-Generation

„5 radikale Unit-Tests, die den Code zum Absturz bringen"

Boundary Tests, Chaos Monkey, Stress Testing

Hochkomplexe Konzepte & Engine Tuning

Lost in the Middle Phänomen

LLMs wiegen Anfang/Ende stärker als Mitte (-30% Genauigkeit).

Lösung: Kritische Constraints am Anfang UND Ende wiederholen.

[START] CRITICAL: Constraint X
...
[2000 Worte]
...
[END] CRITICAL: Constraint X
                                

Logprobs Analysis & Uncertainty Detection

Was sind Logprobs? Wahrscheinlichkeiten der Token-Vorhersagen.

Wie nutzen? Wenn Logprob < 0.3 → Modell ist unsicher → Iteration setzen.

Nutze logprobs=true um zu sehen, wo die KI rät statt zu wissen.

Semantic Vector Shifting

Manipuliere den Embedding-Raum durch Anker-Wörter (siehe Semantic Anchors unten).

3-Phase Cycling:

Phase 1: Mathematik-Cluster → rigorose Logik
Phase 2: Security-Cluster → exploit-proof Code
Phase 3: Synthesis → kombiniere beide

Temperature-Cycling Strategy

High T (0.7-0.9): Exploration & Brainstorming

Low T (0.1-0.3): Refinement & Precision

Vision mit hoher Temp, Execution mit niedriger → Konvergenz

Self-Correction Thought Blocks

Internal Logic Verification Pattern

Zwinge die KI, ihre Logik vor dem Output zu überprüfen. Das verhindert Halluzinationen und zirkuläre Fehler.

Thought Block Pattern

# Bevor du antwortest, schreib einen internen Thought Block:

<thought>
1. Welche Annahmen mache ich?
2. Gibt es logische Fallstricke?
3. Bin ich konsistent mit bisherigen Constraints?
4. Kann ich das Ergebnis kurz zusammenfassen?
</thought>

[NUR DANACH Output]
                            

Anwendungsbeispiel:

User: "Optimiere diese Datenbankquery"

<thought>
Die Query hatte zuvor N+1 Problem.
Mögliche Lösungen:
- Join-Optimierung: O(n²) → O(n log n)
- Index-Strategie: Cache-Hit verbessern
Prüfung: Verliere ich Lesbarkeit? Nein, mit Kommentar ok.
→ Gehe mit Join-Optimization vor
</thought>

Output:
[Optimierter Code mit Join statt N+1]

Pro-Tipp: Der Thought Block ist intern. User sieht nur den finalen Output. Aber die interne Validierung reduziert Fehler um ~40%.

Iteration Tracking & Prompt Versioning

Prompt Version History Schema

Wie bei Code: Jede Änderung wird dokumentiert. Nur so weißt du, was funktioniert und was nicht.

Version	Change	Impact	Notes
v1.0	Baseline Prompt	-	Initiale Persona Setup
v1.1	Persona "Senior Architect" added	↑ +20%	Struktur verbessert sich
v1.2	Constraints hardened	↑ +15%	Weniger Halluzinationen
v1.3	Meta-Prompting layer added	↑ +10%	Self-Optimization aktiv
v2.0	Cross-Model Validation added	↑ +30%	Robustheit massiv erhöht

Tracking-Template für dein Projekt:

v[X.Y]: [Datum]
- Change: [Was genau wurde geändert?]
- Result: [Was hat sich verbessert/verschlechtert?]
- Next: [Welche Iteration als nächstes?]
- Rollback-Plan: [Falls nötig zur v[X.Y-1] zurück]
                        

Interactive Prompt Generator

Wähle deine Parameter und generiere ein fertiges Prompt-Gerüst basierend auf deinen Anforderungen.

Generator: Build Your Custom Prompt

Wähle deine Expert-Rolle

Primärer Semantic Cluster

Temperature Mode

Output Format

Vector Shift Visualization: Vorher-Nachher

Sehe, wie sich dein Output verändert, wenn du Semantic Anchors einsetzt.

❌ VORHER: Standard-Prompt (No Anchors)

"Schreibe eine Funktion zur Validierung von Benutzerdaten."

def validate_user(data):
    if "@" in data['email']:
        if data['age'] > 18:
            return True
    return False
                                

Probleme: Keine Type-Sicherheit, schwache Edge-Case-Handling, anfällig für Injections

✅ NACHHER: Mit Semantic Anchor (MATHEMATIK)

"Definiere Benutzerdaten als Menge von Invarianten mit Prädikatenlogik. Die Validierungsfunktion ist eine reine Abbildung vom Input in {Valid, Invalid}."

from typing import TypedDict

class User(TypedDict):
    email: str
    age: int

def validate_user(data: User) -> bool:
    """
    INVARIANT: email muss @ enthalten
    INVARIANT: age ∈ [0, 150]
    Pure function: keine Side-Effects
    """
    return "@" in data.get('email', '') and 0 <= data.get('age', -1) <= 150
                                

Improvements: Type-Safe, formale Invarianten, pure function, mathematisch beweisbar

❌ VORHER: Standard (No Security Anchor)

"Parse JSON von Benutzereingabe."

import json

def parse_user_json(user_input: str):
    return json.loads(user_input)
                                

Probleme: No validation, DoS-anfällig bei großem JSON, keine Rate-Limits

✅ NACHHER: Mit SECURITY Anchor (Hardened)

"Parse JSON unter der Annahme jeder Input ist bösartig. Implementiere Boundary Checking und Rate Limiting gegen Exploits."

import json
from typing import Any

MAX_JSON_SIZE = 1_000_000  # 1MB max
MAX_NESTING_DEPTH = 10

def parse_user_json(user_input: str) -> Any:
    """
    THREAT: Attacker kann massive JSON senden
    MITIGATION: Size + Depth Limits
    """
    if len(user_input) > MAX_JSON_SIZE:
        raise ValueError("JSON payload exceeds max size")
    
    data = json.loads(user_input)
    _check_nesting_depth(data, 0)
    return data

def _check_nesting_depth(obj: Any, depth: int) -> None:
    if depth > MAX_NESTING_DEPTH:
        raise ValueError("JSON nesting too deep")
    if isinstance(obj, dict):
        for v in obj.values():
            _check_nesting_depth(v, depth + 1)
                                

Improvements: DoS-proof, Boundary-checked, Exploit-hardened, Production-ready

Der Vector Shift Effect: Nur durch die Wortwahl (Semantic Anchors) ändert sich die gesamte Qualität des Outputs. Das ist keine "magische Formel" – es ist Wahrscheinlichkeits-Manipulation auf Embedding-Ebene.

RAG & CRUD Iteration

RAG-Iteration (Probabilistisch)

Der "Retrieval-Audit" Drill

Chunks optimal klein halten
Parent-Context für Vollständigkeit
RAGAS Metrik: Faithfulness + Relevance + Precision

Self-Check: "Basiert die Antwort WIRKLICH auf dem Kontext, oder halluziniert sie?"

CRUD-Iteration (Deterministisch)

Der "Transaction-Safety" Drill

Error-Handling VOR Logik
Idempotenz (mehrfache Requests = kein Schaden)
Schema-Evolution planen

Human-in-the-Loop: Für Delete/Update brauchst du Bestätigung

Deluxe Dashboard v2.0 Complete

Du hast jetzt ein vollständiges operatives System für hochmodernes Prompt Engineering.

Iteration Guide für Brainstorming & Prompt Engineering