Zurück
Openclaw-Series

17. OpenClaw Praxis: KI-Programmierassistenten aufbauen

Dieser Artikel zeigt, wie du mit OpenClaw einen KI-Programmierassistenten aufbaust – mit Integration von Claude Code, Codex und weiteren Tools für Code Review, automatisierte Tests und CI/CD-Integration zur Steigerung der Entwicklungseffizienz.

Gilt für OpenClaw v2026.2 | Erfordert die Installation der Skills coding-agent, git-workflows, test-runner und Zugriff auf Projekt-Repositories.

TL;DR: Code Review: Agent analysiert PR-Änderungen und erstellt Review-Bericht. Automatisierte Tests: "test-runner": {"frameworks": ["jest", "vitest"]}. CI/CD-Integration: Webhook empfängt GitHub/GitLab-Events. Multiprojekt-Verwaltung: "projects": {"frontend": {...}, "backend": {...}}. Kernbefehl: openclaw agent --message "Review diesen PR".

Praxisziel

Einen KI-Programmierassistenten aufbauen, der:

  1. Code Review automatisiert
  2. Tests ausführt und Ergebnisse meldet
  3. Code-Dokumentation generiert
  4. CI/CD-Pipelines integriert
  5. Zwischen mehreren Projekten wechselt

Erforderliche Skills installieren

# Programmier-Skills
openclaw skill install coding-agent
openclaw skill install debug-pro
openclaw skill install git-workflows
openclaw skill install docker-essentials

# Test-Skill
openclaw skill install test-runner

Automatisiertes Code Review

Code Review konfigurieren

---
name: code-review-assistant
version: 1.0.0
description: Automated code review with OpenClaw
triggers:
  - code review
  - Code-Review
  - review
  - PR review
---

# Code Review Assistant

Automate code review for pull requests.

## Features

- Review code changes
- Check for common issues
- Suggest improvements
- Generate review comments

## Review Checklist

1. **Code-Qualität**
   - Namenskonventionen
   - Code-Struktur
   - Fehlerbehandlung

2. **Sicherheit**
   - SQL Injection
   - XSS-Schwachstellen
   - Geheimnis-Offenlegung

3. **Performance**
   - N+1-Abfragen
   - Speicherlecks
   - Ineffiziente Algorithmen

4. **Best Practices**
   - DRY-Prinzip
   - SOLID-Prinzipien
   - Design Patterns

Code Review in der Praxis

Benutzer: Überprüfe diesen PR

Agent: Okay, lass mich PR #123 überprüfen...

[PR-Informationen abrufen]
[Code-Änderungen analysieren]
[Potenzielle Probleme prüfen]

## PR #123 Review-Bericht

### Überblick
- Branch: feature/user-search
- Änderungen: +156 -23
- Dateien: 8 Stück

### Gefundene Probleme

**Kritisch** (1):
- 🚨 `auth.js:45` - Risiko der Klartextspeicherung von Passwörtern

**Warnungen** (3):
- ⚠️ `search.js:23` - Potenzielle SQL Injection
- ⚠️ `user.js:78` - Nicht behandeltes Promise
- ⚠️ `utils.js:12` - Veraltete API

**Vorschläge** (5):
- 💡 Unit-Tests hinzufügen
- 💡 Konstanten statt Magic Numbers verwenden
- 💡 Error Boundaries hinzufügen
- 💡 Gemeinsame Methode extrahieren
- 💡 Typ-Annotationen hinzufügen

### Code-Highlights
- ✅ Gute Funktionsbenennung
- ✅ Sinnvolle Modulaufteilung
- ✅ Angemessene Kommentare

Soll ich Review-Kommentare generieren?

Automatisierte Tests

Test-Runner-Konfiguration

{
  "skills": {
    "test-runner": {
      "frameworks": ["jest", "vitest", "pytest"],
      "coverage": {
        "enabled": true,
        "threshold": 80
      },
      "reporting": {
        "format": "markdown",
        "output": "test-report.md"
      }
    }
  }
}

Test-Szenario

Benutzer: Tests ausführen und Ergebnisse melden

Agent: Tests werden ausgeführt...

[Testbefehle ausführen]
[Testergebnisse sammeln]
[Abdeckung analysieren]

## Testbericht

### Testergebnisse
- Gesamt: 45 Tests
- Bestanden: 42 ✅
- Fehlgeschlagen: 2 ❌
- Übersprungen: 1 ⏭️

### Fehlgeschlagene Tests

**1. UserSearch.test.js**

AssertionError: expected [] to equal [{id: 1, name: ’test’}]

Vorschlag: Datenbankverbindung oder Mock-Daten prüfen

**2. Auth.test.js**

Timeout: Async callback not invoked within 5000ms

Vorschlag: Timeout erhöhen oder asynchrone Logik prüfen

### Abdeckung

| Datei | Anweisungen | Branches | Funktionen | Zeilen |
|-----|-----|-----|-----|-----|
| auth.js | 85 % | 78 % | 90 % | 85 % |
| search.js | 72 % | 65 % | 80 % | 70 % |
| user.js | 90 % | 85 % | 95 % | 90 % |
| **Gesamt** | **82 %** | **76 %** | **88 %** | **82 %** |

Soll ich die fehlgeschlagenen Tests beheben?

CI/CD-Integration

GitHub Actions-Integration

# .github/workflows/openclaw-review.yml
name: OpenClaw Review

on:
  pull_request:
    types: [opened, synchronize]

jobs:
  review:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v3
      
      - name: Setup OpenClaw
        run: npm install -g openclaw@latest
        
      - name: Run Review
        env:
          ANTHROPIC_API_KEY: ${{ secrets.ANTHROPIC_API_KEY }}
        run: |
          openclaw agent --message "Review PR #${{ github.event.pull_request.number }}" \
            --output review-comment.md
            
      - name: Post Comment
        uses: actions/github-script@v6
        with:
          script: |
            const fs = require('fs');
            const comment = fs.readFileSync('review-comment.md', 'utf8');
            await github.rest.issues.createComment({
              owner: context.repo.owner,
              repo: context.repo.repo,
              issue_number: context.issue.number,
              body: comment
            });

Automatisches Deployment

Benutzer: Auf Staging deployen

Agent: Deployment auf Staging-Umgebung wird gestartet...

[Neuesten Code pullen]
[Tests ausführen]
[Projekt bauen]
[Auf Server deployen]

## Deployment-Bericht

### Deployment-Informationen
- Umgebung: staging
- Branch: main
- Commit: abc1234
- Zeitpunkt: 2026-02-26 15:30

### Deployment-Schritte
1. ✅ Code gepullt
2. ✅ Abhängigkeiten installiert
3. ✅ Tests bestanden (45/45)
4. ✅ Projekt gebaut
5. ✅ Auf Server deployt

### Gesundheitsprüfung
- API: ✅ Normal
- Datenbank: ✅ Verbindung OK
- Redis: ✅ Verbindung OK

### Zugriffsadressen
- URL: https://staging.example.com
- API: https://api-staging.example.com

Deployment erfolgreich!

Multiprojekt-Verwaltung

Projektkonfiguration

{
  "projects": {
    "frontend": {
      "path": "~/projects/frontend",
      "skills": ["coding-agent", "test-runner"],
      "context": "AGENTS.md"
    },
    "backend": {
      "path": "~/projects/backend",
      "skills": ["coding-agent", "docker-essentials"],
      "context": "AGENTS.md"
    },
    "mobile": {
      "path": "~/projects/mobile",
      "skills": ["coding-agent"],
      "context": "AGENTS.md"
    }
  }
}

Projektumschaltung

Benutzer: Zum Backend-Projekt wechseln

Agent: Zum Backend-Projekt gewechselt.

Aktuelle Projektinformationen:
- Name: backend
- Pfad: ~/projects/backend
- Technologie: Python/FastAPI
- Letzter Commit: Benutzerauthentifizierung hinzugefügt

Was kann ich für dich tun?

Code-Generierung

Boilerplate-Code generieren

Benutzer: CRUD-API für das User-Model erstellen

Agent: Okay, ich erstelle die CRUD-API für das User-Model...

[Bestehende Codestruktur analysieren]
[Code-Dateien generieren]

Folgende Dateien wurden generiert:

**1. models/user.py**
```python
from pydantic import BaseModel
from datetime import datetime

class User(BaseModel):
    id: int
    name: str
    email: str
    created_at: datetime
    updated_at: datetime

class UserCreate(BaseModel):
    name: str
    email: str

class UserUpdate(BaseModel):
    name: str | None = None
    email: str | None = None

2. routers/users.py

from fastapi import APIRouter, HTTPException
from models.user import User, UserCreate, UserUpdate

router = APIRouter(prefix="/users", tags=["users"])

@router.get("/", response_model=list[User])
async def list_users(): ...

@router.get("/{user_id}", response_model=User)
async def get_user(user_id: int): ...

@router.post("/", response_model=User)
async def create_user(user: UserCreate): ...

@router.put("/{user_id}", response_model=User)
async def update_user(user_id: int, user: UserUpdate): ...

@router.delete("/{user_id}")
async def delete_user(user_id: int): ...

3. tests/test_users.py

from fastapi.testclient import TestClient

def test_list_users(): ...
def test_create_user(): ...
def test_update_user(): ...
def test_delete_user(): ...

Soll ich die Tests ausführen und validieren?


## Dokumentation generieren

### API-Dokumentation

Benutzer: Erstelle die API-Dokumentation

Agent: API-Endpunkte werden analysiert…

[Route-Dateien scannen] [API-Informationen extrahieren] [Dokumentation generieren]

API-Dokumentation

Benutzermodul

GET /users

Benutzerliste abrufen

Parameter

Name Typ Pflicht Beschreibung
page int Nein Seitennummer
limit int Nein Einträge pro Seite

Antwort

{
  "data": [User],
  "total": int,
  "page": int,
  "limit": int
}

POST /users

Benutzer erstellen

Request Body

{
  "name": "string",
  "email": "string"
}

Antwort

{
  "id": 1,
  "name": "string",
  "email": "string",
  "created_at": "2026-02-26T00:00:00Z",
  "updated_at": "2026-02-26T00:00:00Z"
}

Soll ich es unter docs/api.md speichern?


## Fehlerbehebung

### CI/CD-Probleme

```bash
# CI/CD-Status prüfen
openclaw ci status

# CI/CD-Logs anzeigen
openclaw ci logs --last

# Fehlgeschlagenen Job erneut ausführen
openclaw ci retry

Code-Probleme

# Code-Probleme analysieren
openclaw analyze --project backend

# Fix-Vorschläge generieren
openclaw suggest --file auth.js

Zusammenfassung

Mit OpenClaw als Programmierassistent:

  • Code Review: Automatisiertes PR-Review
  • Testausführung: Automatisierte Tests und Berichte
  • CI/CD-Integration: Automatisierte Deployment-Pipelines
  • Multiprojekt-Verwaltung: Schneller Kontextwechsel
  • Code-Generierung: Boilerplate-Code generieren
  • Dokumentation: API-Dokumentation automatisch generieren

Änderungsprotokoll:

  • 2026-02-26: Erstveröffentlichung

Seriennavigation: