# SWE-agent Code-Fixer

## Überblick

[SWE-agent](https://github.com/SWE-agent/SWE-agent) ist ein KI-gestützter Software-Engineering-Agent, der **GitHub-Issues automatisch löst** indem er ein Sprachmodell über eine Terminal-Schnittstelle mit einem Code-Repository interagieren lässt. Vorgestellt auf **NeurIPS 2024** und mit über **15.000 GitHub-Sternen**, ist SWE-agent zur führenden Open-Source-Lösung für automatisierte Fehlerbehebung und Code-Reparatur geworden.

Im Gegensatz zu den meisten Tools in dieser Dokumentation benötigt SWE-agent **keine GPU** — es ruft externe LLM-APIs (Claude, GPT-4, Gemini oder selbst gehostete Modelle) auf, um über Code nachzudenken und Fixes zu generieren. Was es *braucht* ist eine zuverlässige Docker-Umgebung für sichere, sandboxed Code-Ausführung. Clore.ai's CPU-Server (oder jede gemietete Instanz mit Docker) passen perfekt.

**Hauptfunktionen:**

* 🐛 Automatisches Lösen von GitHub-Issues mit einem einzigen Befehl
* 🔒 Sandbox-Ausführung in Docker-Containern — sicher zum Ausführen beliebigen Codes
* 🤖 Unterstützt Claude, GPT-4, Gemini, OpenAI-kompatible und lokale Modelle
* 🌐 Web-UI zur Überwachung des Agentenfortschritts
* 🛡️ Cybersecurity-Modus für CTF-Herausforderungen und Penetrationstests
* 📊 SWE-bench-kompatibel — getestet an über 300 echten GitHub-Issues
* 🔧 Konfigurierbare Agentenverhalten über YAML-Konfigurationsdateien

***

## Anforderungen

### Hardware-Anforderungen

SWE-agent braucht keine GPU — es nutzt API-basierte LLMs zum Gründen:

| Tier                   | CPU        | RAM   | Speicher   | Clore.ai-Preis |
| ---------------------- | ---------- | ----- | ---------- | -------------- |
| **Minimum**            | 4 Kerne    | 8 GB  | 30 GB SSD  | \~0,03 $/Std.  |
| **Empfohlen**          | 8 Kerne    | 16 GB | 60 GB SSD  | \~0,06 $/Std.  |
| **Hohe Arbeitslasten** | 16 Kerne   | 32 GB | 100 GB SSD | \~0,10 $/Std.  |
| **Mit lokalem LLM**    | GPU-Server | 32 GB | 100 GB SSD | \~$0.20/Stunde |

> 💡 **Kosten-Tipp:** SWE-agent ist ungewöhnlich günstig auf Clore.ai zu betreiben, da keine GPU benötigt wird. Die Hauptkosten sind die LLM-API-Aufrufe (z. B. kostet Claude Sonnet \~0,003 $/1K Tokens). Ein typischer Issue-Fix kostet 0,50–2,00 $ an API-Gebühren.

### Software- & API-Anforderungen

| Anforderung           | Details                                                 |
| --------------------- | ------------------------------------------------------- |
| **Docker**            | Erforderlich für sandboxed Code-Ausführung              |
| **LLM-API-Schlüssel** | Anthropic, OpenAI, Google oder selbst gehostet          |
| **GitHub-Token**      | Zum Zugriff auf private Repos und zum Erstellen von PRs |
| **Python 3.11+**      | Für `pip install sweagent` Methode                      |

### LLM-API-Preisreferenz

| Modell          | Eingabe         | Ausgabe         | Typische Laufkosten       |
| --------------- | --------------- | --------------- | ------------------------- |
| Claude Sonnet 4 | 3 $/M Tokens    | 15 $/M Tokens   | \~1,00–2,00 $             |
| GPT-4o          | 5 $/M Tokens    | 15 $/M Tokens   | \~1,00–3,00 $             |
| GPT-4o mini     | 0,15 $/M Tokens | 0,60 $/M Tokens | \~0,05–0,20 $             |
| Ollama (lokal)  | Kostenlos       | Kostenlos       | Nur Clore.ai-Stundenpreis |

***

## Schnellstart

### Schritt 1 — Server auf Clore.ai mieten

1. Melde dich an bei [clore.ai](https://clore.ai)
2. Filtern: **Docker aktiviert** — GPU ist optional (CPU-Server ist ausreichend)
3. Empfohlenes Image: `ubuntu:22.04` oder jedes Docker-fähige Image
4. Offene Ports: **22** (SSH), **7860** (SWE-agent Web-UI)
5. Mindestens 16 GB RAM empfohlen für das Ausführen von Docker-in-Docker

### Schritt 2 — Verbindung per SSH herstellen

```bash
ssh -p <CLORE_SSH_PORT> root@<CLORE_SERVER_IP>

# Überprüfen, ob Docker verfügbar ist
docker --version
docker run --rm hello-world
```

### Schritt 3 — Das SWE-agent Docker-Image ziehen

```bash
# Ziehe das offizielle SWE-agent Image (vorgebaut, empfohlen)
docker pull sweagent/swe-agent:latest

# Verifizieren
docker images | grep sweagent
```

Alternativ aus dem Quellcode bauen für die neueste Entwicklungsvariante:

```bash
git clone https://github.com/SWE-agent/SWE-agent.git
cd SWE-agent
docker build -t sweagent/swe-agent:local .
```

### Schritt 4 — API-Schlüssel einrichten

```bash
# Erstelle ein Verzeichnis für SWE-agent-Konfiguration
mkdir -p /workspace/sweagent && cd /workspace/sweagent

# Erstelle Umgebungsdatei mit deinen API-Schlüsseln
cat > /workspace/sweagent/.env << 'EOF'
# LLM-API-Schlüssel (füge nur hinzu, was du hast)
ANTHROPIC_API_KEY=sk-ant-...
OPENAI_API_KEY=sk-...
GOOGLE_API_KEY=...

# GitHub-Token zum Zugriff auf Repos und zum Erstellen von PRs
GITHUB_TOKEN=ghp_...

# Optional: selbst gehosteter LLM-Endpunkt
# OPENAI_BASE_URL=http://your-ollama-server:11434/v1
EOF

chmod 600 /workspace/sweagent/.env
```

### Schritt 5 — Dein erstes GitHub-Issue beheben

```bash
# Basisverwendung — behebe ein GitHub-Issue mit Claude Sonnet
docker run --rm \
  --env-file /workspace/sweagent/.env \
  -v /workspace/sweagent/output:/output \
  -v /var/run/docker.sock:/var/run/docker.sock \
  sweagent/swe-agent:latest \
  python run.py \
    --agent.model.name=claude-sonnet-4-20250514 \
    --agent.model.per_instance_cost_limit=2.00 \
    --env.repo.github_url=https://github.com/USER/REPO \
    --problem_statement.github_url=https://github.com/USER/REPO/issues/1 \
    --actions.apply_patch_locally=true \
    --output_dir=/output
```

### Schritt 6 — Die Ausgabe prüfen

```bash
# SWE-agent schreibt Ergebnisse in das Ausgabe-Verzeichnis
ls -la /workspace/sweagent/output/

# Den generierten Patch anzeigen
cat /workspace/sweagent/output/*.patch

# Die vollständige Agenten-Trajektorie anzeigen (was der Agent getan hat)
cat /workspace/sweagent/output/*.traj | python3 -m json.tool | less
```

***

## Konfiguration

### Basis-Konfigurationsdatei

Anstelle langer Kommandozeilen-Flags nutze eine YAML-Konfig:

```bash
cat > /workspace/sweagent/config.yaml << 'EOF'
# SWE-agent Konfiguration
agent:
  model:
    name: claude-sonnet-4-20250514
    per_instance_cost_limit: 2.00
    total_cost_limit: 10.00
    temperature: 0.0
  config:
    # System-Prompt für den Agenten
    system_template: "default"
    # Wie viele Wiederholungen bei API-Fehlern
    retry_with_output_if_run_fails: true

env:
  repo:
    # Wird pro Lauf gesetzt
    github_url: ""
  deployment:
    docker_args:
      - "--memory=4g"
      - "--cpus=2"

problem_statement:
  github_url: ""

actions:
  apply_patch_locally: true
  open_pr: false  # Auf true setzen, um automatisch einen PR zu erstellen

output_dir: /output
EOF
```

```bash
# Mit Konfigurationsdatei ausführen
docker run --rm \
  --env-file /workspace/sweagent/.env \
  -v /workspace/sweagent/output:/output \
  -v /workspace/sweagent/config.yaml:/config.yaml \
  -v /var/run/docker.sock:/var/run/docker.sock \
  sweagent/swe-agent:latest \
  python run.py \
    --config /config.yaml \
    --env.repo.github_url=https://github.com/USER/REPO \
    --problem_statement.github_url=https://github.com/USER/REPO/issues/42
```

### Web-UI-Modus

SWE-agent enthält eine Gradio-basierte Web-Oberfläche für interaktive Nutzung:

```bash
# Starte die Web-UI
docker run -d \
  --name sweagent-ui \
  --env-file /workspace/sweagent/.env \
  -p 7860:7860 \
  -v /workspace/sweagent/output:/output \
  -v /var/run/docker.sock:/var/run/docker.sock \
  sweagent/swe-agent:latest \
  python app.py --port 7860 --host 0.0.0.0

# Auf die UI zugreifen
echo "Öffnen: http://<CLORE_SERVER_IP>:<MAPPED_PORT>"
docker logs -f sweagent-ui
```

### Verwendung verschiedener LLM-Anbieter

```bash
# GPT-4o (OpenAI)
docker run --rm \
  --env-file /workspace/sweagent/.env \
  -v /var/run/docker.sock:/var/run/docker.sock \
  -v /workspace/sweagent/output:/output \
  sweagent/swe-agent:latest \
  python run.py \
    --agent.model.name=gpt-4o-2024-11-20 \
    --agent.model.per_instance_cost_limit=3.00 \
    --env.repo.github_url=https://github.com/USER/REPO \
    --problem_statement.github_url=https://github.com/USER/REPO/issues/1

# GPT-4o Mini (Budget-Option)
docker run --rm \
  --env-file /workspace/sweagent/.env \
  -v /var/run/docker.sock:/var/run/docker.sock \
  -v /workspace/sweagent/output:/output \
  sweagent/swe-agent:latest \
  python run.py \
    --agent.model.name=gpt-4o-mini-2024-07-18 \
    --agent.model.per_instance_cost_limit=0.50 \
    --env.repo.github_url=https://github.com/USER/REPO \
    --problem_statement.github_url=https://github.com/USER/REPO/issues/1

# Lokales Ollama (in Verbindung mit Ollama-Anleitung)
# Zuerst Ollama auf einem GPU-Server bereitstellen (siehe ../language-models/ollama.md)
# Dann als Backend für SWE-agent verwenden:
docker run --rm \
  -e OPENAI_API_KEY=dummy \
  -e OPENAI_BASE_URL=http://<OLLAMA_HOST>:11434/v1 \
  -v /var/run/docker.sock:/var/run/docker.sock \
  -v /workspace/sweagent/output:/output \
  sweagent/swe-agent:latest \
  python run.py \
    --agent.model.name=qwen2.5-coder:32b \
    --agent.model.per_instance_cost_limit=0.00 \
    --env.repo.github_url=https://github.com/USER/REPO \
    --problem_statement.github_url=https://github.com/USER/REPO/issues/1
```

### Stapelverarbeitung mehrerer Issues

```bash
# Verarbeite mehrere Issues im SWE-bench-Format
cat > /workspace/sweagent/batch_issues.json << 'EOF'
[
  {
    "repo": "USER/REPO",
    "issue_number": 1,
    "model": "claude-sonnet-4-20250514"
  },
  {
    "repo": "USER/REPO",
    "issue_number": 2,
    "model": "claude-sonnet-4-20250514"
  }
]
EOF

# Batch-Run-Skript
cat > /workspace/sweagent/run_batch.sh << 'BASH'
#!/bin/bash
set -e

ISSUES_FILE="${1:-/workspace/sweagent/batch_issues.json}"
OUTPUT_DIR="/workspace/sweagent/output"
ENV_FILE="/workspace/sweagent/.env"

echo "Starte batch SWE-agent Lauf..."
python3 -c "
import json
issues = json.load(open('$ISSUES_FILE'))
for i, issue in enumerate(issues):
    print(f'Issue {i+1}/{len(issues)}: {issue[\"repo\"]}#{issue[\"issue_number\"]}')
" 

jq -c '.[]' "$ISSUES_FILE" | while read issue; do
    REPO=$(echo "$issue" | jq -r '.repo')
    ISSUE_NUM=$(echo "$issue" | jq -r '.issue_number')
    MODEL=$(echo "$issue" | jq -r '.model')

    echo "=== Verarbeite: $REPO#$ISSUE_NUM mit $MODEL ==="
    
    docker run --rm \
      --env-file "$ENV_FILE" \
      -v "$OUTPUT_DIR:/output" \
      -v /var/run/docker.sock:/var/run/docker.sock \
      sweagent/swe-agent:latest \
      python run.py \
        --agent.model.name="$MODEL" \
        --agent.model.per_instance_cost_limit=2.00 \
        --env.repo.github_url="https://github.com/$REPO" \
        --problem_statement.github_url="https://github.com/$REPO/issues/$ISSUE_NUM" \
        --output_dir=/output || echo "FEHLGESCHLAGEN: $REPO#$ISSUE_NUM"
done

echo "Batch abgeschlossen. Ergebnisse in $OUTPUT_DIR"
BASH

chmod +x /workspace/sweagent/run_batch.sh
/workspace/sweagent/run_batch.sh
```

***

## Docker-in-Docker Einrichtung

SWE-agent führt Code in verschachtelten Docker-Containern aus für Sicherheit. Dies erfordert Zugriff auf den Docker-Socket:

```bash
# Verifiziere, dass der Docker-Socket zugänglich ist
ls -la /var/run/docker.sock

# Teste, dass Docker-in-Docker funktioniert
docker run --rm \
  -v /var/run/docker.sock:/var/run/docker.sock \
  docker:latest docker run --rm hello-world

# SWE-agent wird automatisch sein Sandbox-Image ziehen
# Standard-Sandbox: sweagent/swe-agent:latest (oder ein spezialisiertes Env-Image)
```

### Sicherheitsüberlegungen

```bash
# SWE-agent Sandbox-Ressourcenlimits (in deiner YAML konfigurieren)
cat >> /workspace/sweagent/config.yaml << 'EOF'
env:
  deployment:
    docker_args:
      - "--memory=4g"          # Sandbox-RAM begrenzen
      - "--cpus=2"             # Sandbox-CPU begrenzen
      - "--network=bridge"     # Isoliertes Netzwerk
      - "--read-only"          # Nur-Lese-Dateisystem (mit Ausnahmen)
      - "--tmpfs=/tmp:size=1g" # Schreibbares /tmp nur
EOF

# Führe SWE-agent niemals direkt auf dem Host aus — immer Docker verwenden
# Der Sandbox-Container isoliert potenziell schädlichen Code
```

### Verwendung eines vorgefertigten Environment-Images

```bash
# SWE-agent unterstützt benutzerdefinierte Environment-Images pro Repository
# Das beschleunigt Läufe durch vorinstallierte Abhängigkeiten
cat > /workspace/sweagent/env-config.yaml << 'EOF'
env:
  deployment:
    image: sweagent/swe-agent:latest
    pre_install:
      - "pip install -e ."
      - "pip install pytest"
    post_clone:
      - "git config --global user.email 'agent@sweagent.ai'"
      - "git config --global user.name 'SWE-agent'"
EOF
```

***

## Tipps & bewährte Methoden

### 🎯 Effektive Problemstellungen schreiben

Die Qualität der Fixes von SWE-agent hängt stark von der Issue-Beschreibung ab:

````bash
# Methode 1: Verwende eine GitHub-Issue-URL (empfohlen)
--problem_statement.github_url=https://github.com/USER/REPO/issues/42

# Methode 2: Stelle eine Textdatei mit detaillierter Beschreibung bereit
cat > /workspace/sweagent/issue.txt << 'EOF'
## Fehlerbeschreibung
Die Funktion `calculate_total()` in `billing/calculator.py` gibt 0 zurück 
wenn der Rabatt genau 100% beträgt. 

## Schritte zum Reproduzieren
```python
total = calculate_total(price=100, discount=100)
assert total == 0  # Das schlägt fehl, gibt stattdessen 100 zurück
````

## Erwartetes Verhalten

Sollte 0 zurückgeben, wenn der Rabatt 100% beträgt.

## Relevanter Code

Siehe `billing/calculator.py` Zeilen 45-67. EOF

docker run --rm\
\--env-file /workspace/sweagent/.env\
-v /workspace/sweagent/output:/output\
-v /workspace/sweagent/issue.txt:/issue.txt\
-v /var/run/docker.sock:/var/run/docker.sock\
sweagent/swe-agent:latest\
python run.py\
\--agent.model.name=claude-sonnet-4-20250514\
\--env.repo.github\_url=<https://github.com/USER/REPO\\>
\--problem\_statement.text\_file=/issue.txt

````

### 💰 Kostenkontrolle

```bash
# Setze stets Per-Instance-Kostenlimits
--agent.model.per_instance_cost_limit=2.00  # Max. 2 $ pro Issue

# Verwende GPT-4o mini für erste Triage, Claude für komplexe Fixes
# Budgetstrategie: ~0,10 $ zum Scannen, ~1,50 $ zum Beheben

# Überwache Kosten in Echtzeit
docker logs -f sweagent-ui | grep -E "(cost|tokens|spent)"

# Setze ein Gesamtbudget für alle Läufe
--agent.model.total_cost_limit=20.00  # Stoppt alle Läufe nach 20 $
````

### 🔄 Auto-PR Erstellung

```bash
# Automatisch einen Pull Request mit dem Fix erstellen
docker run --rm \
  --env-file /workspace/sweagent/.env \
  -v /var/run/docker.sock:/var/run/docker.sock \
  -v /workspace/sweagent/output:/output \
  sweagent/swe-agent:latest \
  python run.py \
    --agent.model.name=claude-sonnet-4-20250514 \
    --agent.model.per_instance_cost_limit=2.00 \
    --env.repo.github_url=https://github.com/USER/REPO \
    --problem_statement.github_url=https://github.com/USER/REPO/issues/42 \
    --actions.open_pr=true \
    --actions.push_gh_repo_url=https://github.com/USER/REPO
```

### 📊 SWE-bench Bewertung

```bash
# Führe SWE-agent gegen das offizielle SWE-bench-Benchmark aus
docker run --rm \
  --env-file /workspace/sweagent/.env \
  -v /var/run/docker.sock:/var/run/docker.sock \
  -v /workspace/sweagent/output:/output \
  sweagent/swe-agent:latest \
  python run_batch.py \
    --agent.model.name=claude-sonnet-4-20250514 \
    --env.repo.github_url=https://github.com/USER/REPO \
    --instances.type=swe_bench \
    --instances.subset=lite \
    --instances.split=test \
    --output_dir=/output \
    --num_workers=4
```

### 🛡️ Cybersecurity-Modus

```bash
# SWE-agent unterstützt CTF- und Cybersecurity-Herausforderungen
docker run --rm \
  --env-file /workspace/sweagent/.env \
  -v /var/run/docker.sock:/var/run/docker.sock \
  -v /workspace/sweagent/output:/output \
  sweagent/swe-agent:latest \
  python run.py \
    --agent.model.name=claude-sonnet-4-20250514 \
    --agent.config=config/default_from_url_ctf.yaml \
    --env.deployment.image=sweagent/ctf-env:latest \
    --problem_statement.text="Finde die Flagge im laufenden Webdienst unter http://challenge.local:8080" \
    --output_dir=/output
```

***

## Fehlerbehebung

### Docker-Socket: Zugriff verweigert

```bash
# Fehler: Zugriff verweigert beim Verbinden mit dem Docker-Daemon
# Lösung: Stelle sicher, dass der Docker-Socket korrekt gemountet ist

docker run --rm \
  -v /var/run/docker.sock:/var/run/docker.sock \
  sweagent/swe-agent:latest \
  docker ps

# Wenn du Berechtigungsfehler siehst, überprüfe die Socket-Berechtigungen
ls -la /var/run/docker.sock
# Sollte sein: srw-rw---- root docker

# Füge den aktuellen Benutzer zur docker-Gruppe hinzu (falls nicht root)
usermod -aG docker $USER
newgrp docker
```

### API-Schlüssel-Fehler

```bash
# Überprüfe, ob dein API-Schlüssel korrekt gesetzt ist
docker run --rm \
  --env-file /workspace/sweagent/.env \
  sweagent/swe-agent:latest \
  python -c "
import os
keys = ['ANTHROPIC_API_KEY', 'OPENAI_API_KEY', 'GITHUB_TOKEN']
for k in keys:
    val = os.environ.get(k, 'NOT SET')
    masked = val[:8] + '...' if len(val) > 8 else val
    print(f'{k}: {masked}')
"

# Anthropic-API-Schlüssel testen
curl https://api.anthropic.com/v1/models \
  -H "x-api-key: $ANTHROPIC_API_KEY" \
  -H "anthropic-version: 2023-06-01"
```

### Agent steckt in einer Schleife fest

```bash
# SWE-agent hat ein eingebautes Schritt-Limit (Standard ~100 Schritte)
# Erhöhe oder verringere es über die Konfiguration:

docker run --rm \
  --env-file /workspace/sweagent/.env \
  -v /var/run/docker.sock:/var/run/docker.sock \
  sweagent/swe-agent:latest \
  python run.py \
    --agent.model.name=claude-sonnet-4-20250514 \
    --agent.model.per_instance_cost_limit=2.00 \
    --agent.max_requeries=5 \
    --env.repo.github_url=https://github.com/USER/REPO \
    --problem_statement.github_url=https://github.com/USER/REPO/issues/1

# Einen feststeckenden Lauf beenden
docker ps | grep sweagent
docker stop <container_id>
```

### Speicher-Fehler während der Code-Ausführung

```bash
# Erhöhe das Sandbox-Speicherlimit
docker run --rm \
  --env-file /workspace/sweagent/.env \
  -v /var/run/docker.sock:/var/run/docker.sock \
  -v /workspace/sweagent/output:/output \
  sweagent/swe-agent:latest \
  python run.py \
    --agent.model.name=claude-sonnet-4-20250514 \
    --env.deployment.docker_args='["--memory=8g", "--cpus=4"]' \
    --env.repo.github_url=https://github.com/USER/REPO \
    --problem_statement.github_url=https://github.com/USER/REPO/issues/1

# Für große Codebasen die Clore.ai-Instanz auf 32 GB RAM erhöhen
```

### GitHub-Ratenbegrenzung

```bash
# Die GitHub-API hat Ratenbegrenzungen — verwende ein Personal Access Token mit repo-Berechtigungen
# Überprüfe deinen aktuellen Ratenlimit-Status
curl -H "Authorization: token $GITHUB_TOKEN" \
  https://api.github.com/rate_limit | jq '.rate'

# Wenn du ratenbegrenzt bist, warte auf das Reset oder verwende ein anderes Token
# Das Ratenlimit setzt sich stündlich zurück
```

***

## Weiterführende Lektüre

* [SWE-agent GitHub](https://github.com/SWE-agent/SWE-agent) — Haupt-Repository und Docs
* [SWE-agent Dokumentation](https://swe-agent.com/docs/) — Offizielle Dokumentation
* [SWE-agent Paper (NeurIPS 2024)](https://arxiv.org/abs/2405.15793) — Forschungspapier
* [SWE-bench Bestenliste](https://www.swebench.com/) — Sieh, wie verschiedene Modelle abschneiden
* [Clore.ai Erste Schritte](https://docs.clore.ai/guides/guides_v2-de/erste-schritte/getting-started) — Plattform-Grundlagen
* [GPU-Vergleichsanleitung](https://docs.clore.ai/guides/guides_v2-de/erste-schritte/gpu-comparison) — Falls du eine GPU für lokale LLMs benötigst
* [Ollama auf Clore.ai ausführen](https://docs.clore.ai/guides/guides_v2-de/sprachmodelle/ollama) — Lokales LLM-Backend für SWE-agent
* [vLLM auf Clore.ai ausführen](https://docs.clore.ai/guides/guides_v2-de/sprachmodelle/vllm) — Hochdurchsatz lokaler LLM-Server
* [Anthropic API Preise](https://www.anthropic.com/pricing) — Claude API-Kosten
* [OpenAI API Preise](https://openai.com/api/pricing/) — GPT-4 API-Kosten

> 💡 **Clore.ai + SWE-agent Sweet Spot:** Miete einen CPU-only Server (4 Kerne, 16 GB RAM) für \~0,05 $/Std., betreibe SWE-agent mit Claude Sonnet 4 und behebe GitHub-Issues für ungefähr **1–2 $ insgesamt pro Issue** (API-Kosten) plus ein paar Cent Clore.ai-Zeit. Für Teams mit vielen Issues ist das gegenüber der Einstellung eines Entwicklers für routinemäßige Fehlerbehebungen um Größenordnungen günstiger.