Den vollständigen Index der Dokumentation findest du in llms.txt. Die Markdown-Version einer Dokumentationsseite erhältst du, indem du .md an die URL der Seite anhängst.
Hauptnavigation
Design
Jan 22, 2026 Codex

Agenten-Skills mit Evals systematisch testen

So testest und bewertest du Agenten-Skills und kannst bei jeder Änderung prüfen, ob sie sich verbessert haben.

Verfasst von: Dominik Kundel, Gabriel Chua

Agenten-Skills mit Evals systematisch testen

Wenn du einen Skill für einen Agenten wie Codex weiterentwickelst, ist oft schwer zu erkennen, ob du ihn tatsächlich verbesserst oder nur sein Verhalten änderst. Eine Version wirkt schneller, eine andere zuverlässiger. Dann schleicht sich eine Regression ein: Der Skill wird nicht ausgelöst, überspringt einen notwendigen Schritt oder hinterlässt zusätzliche Dateien.

Im Kern ist ein Skill eine strukturierte Sammlung von Prompts und Anweisungen für ein LLM. Am zuverlässigsten verbesserst du einen Skill über mehrere Versionen hinweg, wenn du ihn genauso evaluierst wie jeden anderen Prompt für LLM-Anwendungen.

Evals (kurz für Evaluationen) prüfen, ob das Ergebnis eines Modells und die Schritte auf dem Weg dorthin deinen Erwartungen entsprechen. Statt dich auf dein Bauchgefühl zu verlassen und zu fragen „Wirkt das jetzt besser?“, kannst du mit Evals konkrete Fragen beantworten:

  • Hat der Agent den Skill aufgerufen?
  • Hat er die erwarteten Befehle ausgeführt?
  • Entsprechen die Ergebnisse den Konventionen, die dir wichtig sind?

Konkret läuft eine Eval so ab: ein Prompt → ein aufgezeichneter Durchlauf (Trace + Artefakte) → einige wenige Prüfungen → ein Punktwert, den du über mehrere Durchläufe vergleichen kannst.

In der Praxis ähneln Evals für Agenten-Skills schlanken End-to-End-Tests: Du führst den Agenten aus, zeichnest den Ablauf auf und bewertest das Ergebnis anhand weniger Regeln.

Dieser Beitrag zeigt dir, wie das mit Codex geht. Zuerst legst du fest, woran du Erfolg erkennst. Dann ergänzt du deterministische Prüfungen und eine Bewertung nach festen Kriterien. So erkennst du sowohl Verbesserungen als auch Regressionen.

1. Lege fest, was als Erfolg gilt, bevor du den Skill schreibst

Bevor du den Skill schreibst, halte fest, woran du seinen Erfolg messen kannst. Dazu kannst du deine Prüfungen in einige Kategorien einteilen:

  • Ergebnis: Hat der Agent die Aufgabe abgeschlossen? Läuft die App?
  • Ablauf: Hat Codex den Skill aufgerufen, die vorgesehenen Tools verwendet und die Schritte eingehalten?
  • Stil: Entspricht das Ergebnis den gewünschten Konventionen?
  • Effizienz: Hat der Agent das Ziel ohne unnötige Umwege erreicht, etwa ohne überflüssige Befehle oder übermäßigen Tokenverbrauch?

Halte die Liste kurz und beschränke sie auf Prüfungen, die der Skill unbedingt bestehen muss. Du brauchst nicht jede Vorliebe vorab in eine Regel zu fassen. Halte fest, welches Verhalten dir am wichtigsten ist.

In diesem Beitrag testen wir einen Skill, der eine Demo-App einrichtet. Einige Prüfungen sind ganz konkret: Hat der Agent npm install ausgeführt? Hat er package.json erstellt? Dazu kommt ein Bewertungsraster, mit dem wir Stilkonventionen und Layout prüfen.

Diese Kombination hat einen Zweck: Gezielte Prüfungen zeigen dir früh, was sich verschlechtert hat. Ein einziges „bestanden“ oder „nicht bestanden“ am Ende gibt dir diesen Aufschluss nicht.

2. Erstelle den Skill

Ein Codex-Skill ist ein Verzeichnis mit einer SKILL.md-Datei. Die Datei beginnt mit YAML-Frontmatter (name, description). Danach folgen Markdown-Anweisungen, die das Verhalten des Skills festlegen. Bei Bedarf enthält das Verzeichnis auch Ressourcen und Skripte. Name und Beschreibung sind wichtiger, als es zunächst scheint. Anhand dieser Angaben entscheidet Codex in erster Linie, ob es den Skill überhaupt aufruft und wann es den restlichen Inhalt von SKILL.md in den Kontext des Agenten lädt. Sind Name und Beschreibung zu vage oder decken sie zu viele Fälle ab, wird der Skill nicht zuverlässig ausgelöst.

Am schnellsten kommst du mit dem integrierten Assistenten von Codex zur Skill-Erstellung ans Ziel (der selbst ein Skill ist). So startest du ihn:

$skill-creator

Der Assistent fragt dich, was der Skill tun soll, wann er ausgelöst werden soll und ob er ausschließlich Anweisungen enthält oder auch Skripte nutzt. Standardmäßig empfiehlt er die Variante ohne Skripte. Mehr zur Erstellung von Skills findest du in der Dokumentation.

Ein Beispiel-Skill

Das Beispiel in diesem Beitrag ist bewusst klein gehalten: Der Skill richtet eine kleine React-Demo-App so ein, dass der Ablauf vorhersehbar und wiederholbar ist.

Der Skill soll:

  • das Projektgerüst mit der Vite-Vorlage für React + TypeScript erstellen
  • Tailwind CSS mit dem offiziellen Vite-Plugin konfigurieren
  • eine minimale, einheitliche Dateistruktur vorgeben
  • klare Abschlusskriterien festlegen, anhand derer sich der Erfolg leicht prüfen lässt

Den folgenden kompakten Entwurf kannst du in eine dieser Dateien einfügen:

  • .codex/skills/setup-demo-app/SKILL.md (für dieses Repository) oder
  • ~/.codex/skills/setup-demo-app/SKILL.md (für dein Benutzerkonto).
---
name: setup-demo-app
description: Scaffold a Vite + React + Tailwind demo app with a small, consistent project structure.
---

## Einsatzbereich

Verwende diesen Skill, wenn du für schnelle UI-Experimente oder zum Nachstellen eines Problems eine neue Demo-App brauchst.

## Ziel

Erstelle mit Vite eine React-App in TypeScript und konfiguriere Tailwind. Beschränke dich auf das Nötigste.

Projektstruktur nach dem Einrichten:

- src/
  - main.tsx (Einstiegspunkt)
  - App.tsx (oberste UI-Komponente)
  - components/
    - Header.tsx
    - Card.tsx
  - index.css (Tailwind-Import)
- index.html
- package.json

Stilvorgaben:

- Komponenten in TypeScript
- Ausschließlich Funktionskomponenten
- Tailwind-Klassen für das Styling (keine CSS-Module)
- Keine zusätzlichen UI-Bibliotheken

## Schritte

1. Erstelle das Projektgerüst mit Vite und der React-Vorlage für TypeScript:
   npm create vite@latest demo-app -- --template react-ts

2. Installiere die Abhängigkeiten:
   cd demo-app
   npm install

3. Installiere und konfiguriere Tailwind mit dem Vite-Plugin.
   - npm install tailwindcss @tailwindcss/vite
   - Füge das Tailwind-Plugin in vite.config.ts hinzu.
   - Ersetze den Inhalt von src/index.css durch:
     @import "tailwindcss";

4. Implementiere die minimale Benutzeroberfläche:
   - Header: Zeige den App-Titel und einen kurzen Untertitel an.
   - Card: Erstelle einen wiederverwendbaren Kartencontainer.
   - App: Zeige Header und 2 Instanzen von Card mit Platzhaltertext an.

## Abschlusskriterien

- npm run dev startet den Entwicklungsserver erfolgreich.
- package.json ist vorhanden.
- src/components/Header.tsx und src/components/Card.tsx sind vorhanden.

Dieser Beispiel-Skill macht bewusst konkrete Vorgaben. Ohne sie hättest du keinen Maßstab für die Bewertung.

3. Löse den Skill manuell aus, um versteckte Annahmen zu erkennen

Ob Codex einen Skill aufruft, hängt stark vom Namen und von der Beschreibung in SKILL.md ab. Prüfe daher zuerst, ob Codex den Skill setup-demo-app dann auslöst, wenn du es erwartest.

Aktiviere den Skill zunächst ausdrücklich, entweder mit dem Slash-Befehl /skills oder indem du ihn mit dem Präfix $ ansprichst. Probiere das in einem echten Repository oder einem Testverzeichnis aus und beobachte, wo es hakt. So erkennst du Fälle, in denen der Skill gar nicht oder zu leicht ausgelöst wird oder bei der Ausführung von den vorgesehenen Schritten abweicht.

Geschwindigkeit und Feinschliff können zunächst warten. Achte auf unausgesprochene Annahmen im Skill, zum Beispiel:

  • Annahmen zum Auslösen des Skills: Prompts wie „Richte schnell eine React-Demo ein“ sollten setup-demo-app aufrufen, tun es aber nicht. Allgemeinere Prompts wie „Ergänze das Styling mit Tailwind“ lösen den Skill dagegen unbeabsichtigt aus.

  • Annahmen zur Umgebung: Der Skill setzt voraus, dass er in einem leeren Verzeichnis läuft oder dass npm verfügbar ist und anderen Paketmanagern vorgezogen wird.

  • Annahmen zur Ausführung: Der Agent überspringt npm install, weil er die Abhängigkeiten für bereits installiert hält. Oder er konfiguriert Tailwind, bevor das Vite-Projekt existiert.

Wenn du diese Durchläufe wiederholbar machen möchtest, wechsle zu codex exec. Der Befehl ist für Automatisierung und CI ausgelegt. Er gibt den Fortschritt fortlaufend auf stderr aus und schreibt nur das Endergebnis nach stdout. Dadurch lassen sich Durchläufe leichter per Skript ausführen, aufzeichnen und untersuchen.

Standardmäßig läuft codex exec in einer eingeschränkten Sandbox. Wenn die Aufgabe Schreibzugriff auf Dateien erfordert, verwende --full-auto. Gewähre grundsätzlich nur die Berechtigungen, die für die Aufgabe erforderlich sind. Das gilt besonders für automatisierte Abläufe.

Ein einfacher manueller Durchlauf könnte so aussehen:

codex exec --full-auto \
  'Use the $setup-demo-app skill to create the project in this directory.'

In diesem ersten Praxistest geht es vor allem darum, Ausnahmefälle zu entdecken. Jede manuelle Korrektur kommt für eine spätere Eval infrage: Vielleicht ergänzt du ein fehlendes npm install, korrigierst die Tailwind-Konfiguration oder beschreibst genauer, wann der Skill ausgelöst werden soll. So kannst du das gewünschte Verhalten absichern, bevor du die Evals in größerem Umfang ausführst.

4. Erkenne Regressionen früh mit wenigen gezielt ausgewählten Prompts

Du brauchst keinen umfangreichen Benchmark, um von Evals zu profitieren. Für einen einzelnen Skill reichen 10–20 Prompts aus, um Regressionen früh zu erkennen und Verbesserungen zu bestätigen.

Beginne mit einer kleinen CSV-Datei und erweitere sie, wenn dir bei der Entwicklung oder im Einsatz Fehler begegnen. Jede Zeile sollte einen Fall beschreiben, in dem es darauf ankommt, dass Codex den Skill setup-demo-app aufruft oder nicht aufruft. Lege auch fest, woran du einen erfolgreichen Aufruf erkennst.

Eine erste Version von evals/setup-demo-app.prompts.csv könnte so aussehen:

id,should_trigger,prompt
test-01,true,"Create a demo app named `devday-demo` using the $setup-demo-app skill"
test-02,true,"Set up a minimal React demo app with Tailwind for quick UI experiments"
test-03,true,"Create a small demo app to showcase the Responses API"
test-04,false,"Add Tailwind styling to my existing React app"

Jeder dieser Fälle prüft einen anderen Aspekt:

  • Expliziter Aufruf (test-01)
    Dieser Prompt nennt den Skill beim Namen. Damit prüfst du, ob Codex setup-demo-app auf ausdrückliche Aufforderung aufrufen kann und ob der direkte Aufruf nach Änderungen an Name, Beschreibung oder Anweisungen weiterhin funktioniert.

  • Impliziter Aufruf (test-02)
    Dieser Prompt beschreibt genau den vorgesehenen Anwendungsfall, eine minimale Demo mit React + Tailwind, ohne den Skill beim Namen zu nennen. Damit prüfst du, ob Name und Beschreibung in SKILL.md aussagekräftig genug sind, damit Codex den Skill selbst auswählt.

  • Aufruf im fachlichen Kontext (test-03)
    Dieser Prompt liefert zusätzlichen fachlichen Kontext (die Responses API), erfordert aber dasselbe Setup. Damit prüfst du, ob Codex den Skill auch bei realistischen Prompts mit zusätzlichen Details auslöst und ob die erstellte App weiterhin die erwartete Struktur und die Konventionen einhält.

  • Negativkontrolle (test-04)
    Dieser Prompt sollte nicht zum Aufruf von setup-demo-app führen. Die häufige, thematisch ähnliche Anfrage „Füge Tailwind zu einer bestehenden App hinzu“ kann unbeabsichtigt zur Beschreibung des Skills passen („Demo mit React + Tailwind“). Mit mindestens einem Fall, für den should_trigger=false gilt, erkennst du falsch positive Ergebnisse: Codex wählt den Skill vorschnell aus und erstellt ein neues Projektgerüst, obwohl nur eine Änderung an einem bestehenden Projekt gewünscht war.

Die Zusammenstellung ist bewusst gewählt. Einige Evals sollten bestätigen, dass sich der Skill bei einem expliziten Aufruf korrekt verhält. Andere sollten prüfen, ob Codex ihn bei Anfragen aus der Praxis aktiviert, in denen er gar nicht erwähnt wird.

Ergänze für jeden neu entdeckten Fehler eine Zeile, etwa wenn ein Prompt den Skill nicht wie vorgesehen auslöst oder das Ergebnis von deinen Erwartungen abweicht. So hältst du in der kleinen CSV-Datei nach und nach fest, welche Fälle der Skill setup-demo-app auch künftig korrekt behandeln muss.

Mit der Zeit dokumentiert dieser kleine Datensatz, was der Skill weiterhin zuverlässig leisten muss.

5. Beginne mit einfachen deterministischen Prüfungen

Für die eigentliche Evaluation verwendest du codex exec --json. Damit kann dein Harness bewerten, was tatsächlich passiert ist, statt nur zu prüfen, ob das Endergebnis richtig aussieht.

Mit --json liefert stdout einen JSONL-Datenstrom mit strukturierten Ereignissen. So kannst du deterministische Prüfungen direkt auf das Verhalten zuschneiden, das dich interessiert, zum Beispiel:

  • Hat der Agent npm install ausgeführt?
  • Hat er package.json erstellt?
  • Hat er die erwarteten Befehle in der vorgesehenen Reihenfolge ausgeführt?

Diese Prüfungen sind bewusst einfach. Du erhältst schnell nachvollziehbare Ergebnisse, bevor du ein Modell zur Bewertung hinzuziehst.

Ein minimales Testskript für Node.js

Für den Einstieg genügen drei Schritte:

  1. Führe für jeden Prompt codex exec --json --full-auto "<prompt>" aus.
  2. Speichere den JSONL-Trace in einer Datei.
  3. Lies den Trace ein und prüfe die Ereignisse anhand deterministischer Regeln.
// evals/run-setup-demo-app-evals.mjs
import { spawnSync } from "node:child_process";
import { readFileSync, writeFileSync, existsSync, mkdirSync } from "node:fs";
import path from "node:path";

function runCodex(prompt: string, outJsonlPath: string) {
  const res = spawnSync(
    "codex",
    [
      "exec",
      "--json", // REQUIRED: emit structured events
      "--sandbox",
      "workspace-write", // Allow changes inside the example repository
      prompt,
    ],
    { encoding: "utf8" }
  );

  if (res.error) throw res.error;
  mkdirSync(path.dirname(outJsonlPath), { recursive: true });

  // stdout is JSONL when --json is enabled
  writeFileSync(outJsonlPath, res.stdout, "utf8");

  return { exitCode: res.status ?? 1, stderr: res.stderr };
}

function parseJsonl(jsonlText: string) {
  return jsonlText
    .split("\n")
    .filter(Boolean)
    .map((line: string) => JSON.parse(line));
}

// deterministic check: did the agent run `npm install`?
function checkRanNpmInstall(
  events: {
    type: string;
    item?: { type: string; status: string; exit_code: number; command: string };
  }[]
) {
  return events.some(
    (e) =>
      e.type === "item.completed" &&
      e.item?.type === "command_execution" &&
      e.item.status === "completed" &&
      e.item.exit_code === 0 &&
      typeof e.item?.command === "string" &&
      e.item.command.includes("npm install")
  );
}

// deterministic check: did `package.json` get created?
function checkPackageJsonExists(projectDir: string) {
  return existsSync(path.join(projectDir, "package.json"));
}

// Example single-case run
const projectDir = process.cwd();
const tracePath = path.join(projectDir, "evals", "artifacts", "test-01.jsonl");

const prompt =
  "Create a demo app named demo-app using the $setup-demo-app skill";

const { exitCode, stderr } = runCodex(prompt, tracePath);
if (exitCode !== 0) {
  throw new Error(`Codex exited with status ${exitCode}: ${stderr}`);
}

const events = parseJsonl(readFileSync(tracePath, "utf8"));

console.log({
  ranNpmInstall: checkRanNpmInstall(events),
  hasPackageJson: checkPackageJsonExists(path.join(projectDir, "demo-app")),
});

Der Vorteil: Alle Prüfungen sind deterministisch und lassen sich bei Fehlern nachvollziehen.

Schlägt eine Prüfung fehl, kannst du die JSONL-Datei öffnen und genau sehen, was passiert ist. Jeder ausgeführte Befehl erscheint in chronologischer Reihenfolge als item.*-Ereignis. So kannst du schon in dieser Phase Regressionen erklären und beheben.

6. Prüfe qualitative Anforderungen mit Codex und einem Bewertungsraster

Deterministische Prüfungen beantworten die Frage „Hat der Agent die grundlegenden Schritte ausgeführt?“. Offen bleibt die Frage „Hat er sie so ausgeführt, wie du es wolltest?“

Bei Skills wie setup-demo-app sind viele Anforderungen qualitativer Art: Wie sind die Komponenten aufgebaut? Halten sie die Stilkonventionen ein? Ist Tailwind wie vorgesehen konfiguriert? Das lässt sich kaum beurteilen, wenn du nur prüfst, ob Dateien existieren, oder die ausgeführten Befehle zählst.

Dafür kannst du deine Eval-Pipeline um einen zweiten, modellgestützten Prüfschritt erweitern:

  1. Führe den Setup-Skill aus. Dabei schreibt er Code auf die Festplatte.
  2. Führe eine Stilprüfung ohne Schreibzugriff im entstandenen Repository durch.
  3. Fordere eine strukturierte Antwort an, die dein Harness einheitlich bewerten kann.

Codex unterstützt das direkt über --output-schema. Damit legst du ein JSON-Schema fest, dem die abschließende Antwort entsprechen muss.

Ein kleines Schema für das Bewertungsraster

Definiere zunächst ein kleines Schema für die Prüfungen, die dir wichtig sind. Erstelle zum Beispiel evals/style-rubric.schema.json:

{
  "type": "object",
  "properties": {
    "overall_pass": { "type": "boolean" },
    "score": { "type": "integer", "minimum": 0, "maximum": 100 },
    "checks": {
      "type": "array",
      "items": {
        "type": "object",
        "properties": {
          "id": { "type": "string" },
          "pass": { "type": "boolean" },
          "notes": { "type": "string" }
        },
        "required": ["id", "pass", "notes"],
        "additionalProperties": false
      }
    }
  },
  "required": ["overall_pass", "score", "checks"],
  "additionalProperties": false
}

Das Schema liefert feste Felder (overall_pass, score und die Ergebnisse der einzelnen Prüfungen). Damit kannst du Ergebnisse zusammenführen, Unterschiede zwischen Durchläufen ermitteln und Veränderungen über die Zeit verfolgen.

Der Prompt für die Stilprüfung

Führe codex exec ein zweites Mal aus. Diesmal soll Codex das Repository ausschließlich untersuchen und eine JSON-Antwort ausgeben, die dem Bewertungsraster entspricht:

codex exec \
  "Evaluate the demo-app repository against these requirements:
   - Vite + React + TypeScript project exists
   - Tailwind is configured via @tailwindcss/vite and CSS imports tailwindcss
   - src/components contains Header.tsx and Card.tsx
   - Components are functional and styled with Tailwind utility classes (no CSS modules)
   Return a rubric result as JSON with check ids: vite, tailwind, structure, style." \
  --output-schema ./evals/style-rubric.schema.json \
  -o ./evals/artifacts/test-01.style.json

Hier hilft --output-schema: Frei formulierten Text kannst du nur schwer automatisiert auswerten oder vergleichen. Mit dem Schema erhältst du ein einheitlich aufgebautes JSON-Objekt, das dein Harness über viele Durchläufe hinweg bewerten kann.

Wenn du diese Evals später in CI ausführst, kannst du --output-schema über codex-args an die Codex GitHub Action übergeben. So kannst du auch in automatisierten Workflows dieselbe strukturierte Ausgabe vorgeben.

7. Erweitere die Evals, wenn du den Skill weiterentwickelst

Sobald der grundlegende Ablauf steht, kannst du die Evals dort erweitern, wo es für deinen Skill am wichtigsten ist. Fang klein an und ergänze gründlichere Prüfungen dort, wo sie die Zuverlässigkeit deiner Bewertung verbessern.

Einige Beispiele:

  • Befehlsanzahl und unnötige Wiederholungen: Zähle die command_execution-Einträge im JSONL-Trace. So erkennst du Regressionen, bei denen der Agent in Schleifen gerät oder Befehle erneut ausführt. Den Tokenverbrauch findest du außerdem in den turn.completed-Ereignissen.

  • Tokenbudget: Verfolge usage.input_tokens und usage.output_tokens. Damit erkennst du, wenn Prompts unbeabsichtigt immer länger werden, und kannst die Effizienz verschiedener Versionen vergleichen.

  • Build-Prüfungen: Führe nach Abschluss des Skills npm run build aus. Damit prüfst du das Zusammenspiel der Projektschritte gründlicher und erkennst fehlerhafte Importe oder falsch konfigurierte Tools.

  • Smoke-Tests zur Laufzeit: Starte npm run dev und sende mit curl eine Anfrage an den Entwicklungsserver. Falls du bereits einen einfachen Playwright-Test hast, kannst du auch diesen ausführen. Setze solche Tests gezielt ein: Sie geben dir zusätzliche Sicherheit, kosten aber Zeit.

  • Unerwünschte Änderungen im Repository: Stelle sicher, dass der Durchlauf keine unerwünschten Dateien erzeugt. Die Ausgabe von git status --porcelain muss leer sein oder genau den ausdrücklich zugelassenen Änderungen entsprechen.

  • Regressionen bei Sandbox und Berechtigungen: Prüfe, ob der Skill weiterhin mit den vorgesehenen Berechtigungen auskommt. Gerade bei automatisierten Abläufen ist es wichtig, die Berechtigungen standardmäßig auf das Nötigste zu beschränken.

Das Vorgehen bleibt gleich: Beginne mit schnellen Prüfungen, die das Verhalten nachvollziehbar machen. Ergänze langsamere, aufwendigere Prüfungen nur, wenn sie das Risiko verringern.

8. Das Wichtigste in Kürze

Das kleine Beispiel setup-demo-app zeigt, wie du aus dem Eindruck „Das funktioniert jetzt besser“ einen überprüfbaren Befund machst: Führe den Agenten aus, zeichne den Ablauf auf und bewerte ihn anhand weniger Kriterien. Sobald dieser Ablauf steht, kannst du die Wirkung jeder Änderung leichter prüfen und Regressionen erkennen. Darauf kommt es an:

  • Miss, was dir wichtig ist. Gute Evals machen Regressionen sichtbar und helfen dir zu erklären, warum eine Prüfung fehlgeschlagen ist.
  • Beginne mit überprüfbaren Abschlusskriterien. Erstelle mit $skill-creator einen ersten Entwurf und präzisiere dann die Anweisungen, bis eindeutig ist, wann die Aufgabe erfolgreich abgeschlossen ist.
  • Prüfe das tatsächliche Verhalten. Zeichne mit codex exec --json einen JSONL-Trace auf und schreibe deterministische Prüfungen für die command_execution-Ereignisse.
  • Nutze Codex, wenn Regeln allein nicht ausreichen. Ergänze mit --output-schema einen strukturierten Prüfschritt, der Stil und Konventionen anhand eines Bewertungsrasters zuverlässig beurteilt.
  • Erweitere deine Tests anhand tatsächlicher Fehler. Jede manuelle Korrektur zeigt dir, wo ein Test fehlt. Mach daraus einen Testfall, damit der Skill die Aufgabe auch künftig korrekt erledigt.