Eines der besten Features unserer neuesten Claude-Modelle ist, wie sie auf „Effort“ (Aufwand) reagieren, ohne den Prompt-Cache in Claude Code zu sprengen. Trotzdem habe ich dazu viele Fragen von Nutzern bekommen. Was genau ist Effort eigentlich und wann nutzt man welchen Level? Warum brauchen wir das überhaupt?
Um das zu beantworten, habe ich mich tief in die Evals eingearbeitet und eigene Tests mit verschiedenen Effort-Leveln bei ganz normaler Arbeit durchgeführt.
Hinweis: Weitere interaktive Diagramme und Erklärungen zu diesem Beitrag findest du unter https://claude.dev/blog/spending-your-effort/
Grob gesagt habe ich festgestellt, dass sich über den Effort hervorragend steuern lässt, wie viel Verifizierung und Edgecase-Testing Claude betreibt und wie stark es auf sein eigenes Urteilsvermögen setzt.
Mehr Aufwand lieferte bessere Ergebnisse in Bereichen, in denen Verifizierung und das Testen von Randfällen besonders wichtig sind – etwa bei Hardware, Code Reviews und Security.
Niedriger und mittlerer Aufwand hingegen waren perfekt, um Dinge schnell zu erledigen und dabei eng mit Claude im Loop zu bleiben.
Für normale Softwareentwicklung nutze ich jetzt folgenden Ablauf: Ich lasse mich vom Modell interviewen, setze dann mit niedrigem/mittlerem Aufwand um, prüfe das Ergebnis und lasse anschließend mit hohem Aufwand verifizieren.
Was ist Effort?
Im Grunde gibt der Effort dem Modell einen Richtwert dafür, wie viel Rechenleistung es für eine Aufgabe verwenden soll. Das hängt ein Stück weit damit zusammen, wie schwierig du die Aufgabe selbst einschätzt.
Stell dir das so vor: Wenn dich jemand bittet, 12 Stunden am Stück an etwas zu arbeiten, gehst du davon aus, dass einfach maximale Power gefragt ist. Soll dieselbe Aufgabe in einer Stunde fertig sein, lieferst du die beste Version ab, die in der Zeit machbar ist, und planst danach weitere Iterationen ein.
Oder du hältst dagegen und sagst, dass die Aufgabe mindestens drei Stunden braucht – und arbeitest dann eben diese drei Stunden daran.
Genau so solltest du auch den Effort sehen. Claude wird immer versuchen, deine Aufgabe solide zu lösen, aber bei höherem Aufwand handelt das Modell eigenständiger, trifft mehr eigene Entscheidungen und prüft genauer nach.
Effort-Kurven
Die Effort-Kurven von Fable 5.1 und Opus 5.5 sind unsere bisher besten: Auf jedem Level steigen sowohl die Benchmark-Scores als auch der Token-Verbrauch. Unten siehst du ein Diagramm der Terminal Bench 3.0 Scores nach Effort, gemessen während meiner Eval-Läufe für diesen Artikel.
Aber was heißt das in der Praxis? Um das herauszufinden, habe ich mehrere Aufgaben mit unterschiedlichen Effort-Leveln getestet und mich intensiv mit den Benchmarks beschäftigt.
Entwickeln mit Effort
Am besten versteht man die Arbeitsweise der Modelle durch eigene Experimente. Ich habe dieselben Aufgaben mit verschiedenen Effort-Leveln in Opus 5.5 ausgeführt, um zu sehen, wie sich der Arbeitsaufwand unterscheidet. Das habe ich bei vielen verschiedenen Tätigkeiten gemacht, zeige es hier aber an ein paar einfachen Beispielen.
Vage definierte Entwicklungsaufgabe
Wenn ich Claude bitte, „eine App zum Tracken von Fitness und Workouts zu bauen“, verändert der Effort massiv, wie ausgereift die App wird – und führt dazu, dass Claude unterwegs mehr eigene Entscheidungen trifft. Bei niedrigem Aufwand ist die Fitness-App nur ein Logbuch mit einem simplen Graphen. Bei höheren Stufen wird die App komplexer und detaillierter. Beim maximalen Aufwand gibt es sogar eine Heatmap.
Wenn ich eine einfache Basis zum Weiterentwickeln brauche, reicht niedriger Aufwand völlig. Maximaler Aufwand ist ideal, wenn ich direkt Claudes bestmögliches Ergebnis auf Anhieb haben will.
Leicht spezifizierte Design-Aufgabe
Was passiert, wenn die Aufgabe schon recht klar umrissen ist, ich aber trotzdem noch Raum für Exploration mit Claude lassen möchte? Als Beispiel habe ich gebeten, das /config-Menü in Claude Code neu zu gestalten. Jeder Durchlauf kam auf ungefähr dieselbe Grundidee: Untermenüs und eine bessere Suche.
Bei niedrigem Aufwand (dauerte 1 Minute) bekam ich einen interaktiven Entwurf, der die Idee vermittelte, aber kaum wie Claude Code aussah.
Bei maximalem Aufwand (dauerte 28 Minuten) erhielt ich ein Mockup, das stark an Claude Code erinnerte, plus eine Reihe von Walkthroughs für verschiedene Abläufe.
Wenn mein Ziel Iteration und Feedback war, kam ich mit niedrigem Aufwand viel schneller ans Ziel. Maximaler Aufwand liefert mir aber sofort etwas deutlich Ausgefeilteres. Für genau diese Aufgabe bevorzuge ich niedrigen Aufwand, um Claudes Vision besser zu verstehen.
Sehr detailliert spezifizierte Entwicklungsaufgabe
Und wenn ich Claude extrem viele Details gebe? Ich habe Claude gebeten, mich ausführlich zur Fitness-App zu interviewen, und dieses Spec dann von verschiedenen Modellen mit unterschiedlichem Aufwand umsetzen lassen.
Dabei fiel auf: Mit diesem Spec verhielten sich die Modelle viel ähnlicher. Die Designs sahen vergleichbar aus und hatten ähnliche Implementierungen, nur mit anderen Details. Bei maximalem Aufwand nahm sich Claude zusätzlich Zeit, um einige Details zu vereinfachen.
Fazit
Bei normaler Softwareentwicklung, besonders bei neuen Features, hängt der richtige Effort stark davon ab, wie sehr ich selbst im Loop bleiben möchte. Niedriger Aufwand sorgt dafür, dass Claude schnell einen Startpunkt liefert. Höhere Stufen schaffen mehr weg, allerdings trifft Claude dabei auch mehr Annahmen für mich.
Ein besonders ergiebiger Loop für die Feature-Entwicklung, den ich aktuell nutze, sieht so aus:
- Gib Claude ein Spec und bitte es, dich zu fehlenden Details zu interviewen
- Setze es mit niedrigem Aufwand um
- Prüfe, ob der Kern richtig getroffen wurde, und iteriere bei Bedarf mit niedrigem Aufwand
- Verifiziere und teste mit hohem Aufwand
Wie sich der Effort bei schwierigen Aufgaben auf das Ergebnis auswirkt
Das waren natürlich einfache Beispiele, die Claude problemlos meistert. Aber was passiert, wenn der Unterschied darüber entscheidet, ob Claude die Aufgabe schafft oder nicht?
Solche harten Nüsse findet man in den Benchmarks, also habe ich mir einen meiner Favoriten vorgenommen: Terminal Bench 3, einen Community-Benchmark.
Die Probleme in Terminal-Bench 3.0 lassen sich grob in Kategorien wie Security, Hardware, ML, Wissenschaft, Software, Operations und Media einteilen. Alle Aufgaben findest du hier: https://github.com/harbor-framework/terminal-bench/releases/tag/v3.0.0. Sie stammen aus der Community, jeder kann also beitragen.
Es lohnt sich, da mal reinzulesen, um ein Gefühl für die Art von Problemen zu bekommen, mit denen diese Modelle konfrontiert werden. Mich hat der Umfang und Ehrgeiz vieler dieser Aufgaben echt überrascht. Sie sind deutlich komplexer als das, was mir im Alltag normalerweise begegnet.
Ein paar Beispiele:
- Hardware (retro-console-soc): Baue eine 8-Bit-Spielekonsole in Verilog, die auf ein kleines FPGA passt und ein Test-ROM rendert.
- Wissenschaft (takens-embedding-lean): Beweise formal den Einbettungssatz von Takens in Lean 4.
- ML (mp-checkpoint-consolidation): Führe 16 Shards eines Mixture-of-Experts-Checkpoints zu einer Datei zusammen, die die Referenz-Logits reproduziert.
- Operations (intrastat-meldung): Wickle die monatliche EU-Handelsstatistik-Meldung eines Unternehmens komplett End-to-End ab.
- Media (layout-config-recreation): Baue ein Posterbild als bearbeitbare Layoutdatei nach.
Höherer Aufwand hilft, wenn es viele Randfälle gibt
Meine wichtigste Erkenntnis aus den Terminal Bench 3 Ergebnissen: Höherer Aufwand ist ideal für Aufgaben mit vielen versteckten Edgecases.
Ein klares Beispiel ist html-js-filter, eine Terminal-Bench 3.0 Aufgabe, die einen HTML-Sanitizer verlangt, der jede Möglichkeit blockiert, JavaScript in eine Seite einzuschleusen. Fable 5.1 sprang von 1/5 bei niedrigem auf 5/5 bei xhigh Aufwand.
Ein typischer Versuch mit niedrigem Aufwand dauert etwa 2 Minuten. Dabei wurde der Filter in grob einem Durchgang geschrieben und gegen eine einzige, manuell erstellte Seite getestet.
Ein Lauf mit hohem Aufwand dauert rund 33 Minuten. In dem Lauf, den ich nachvollzogen habe, wurde der erste Entwurf adversarial geprüft, dann der Quellcode des installierten Parsers auf Fehler untersucht, zahlreiche saubere Testfälle ausgeführt, bis Input und Output identisch waren, eine Standard-XSS-Testsuite durchlaufen und schließlich ein Random-Document-Fuzzer geschrieben.
Bei etwas so anfälligem für Randfälle wie einem HTML-Sanitizer lohnt sich dieser Mehraufwand absolut. Mehr Tokens für Gründlichkeit auszugeben ergibt auch bei komplexen Aufgaben mit hohen Produktionsanforderungen Sinn, etwa bei Performance-Optimierungen oder Security-Reviews.
Aber du brauchst dieses Level nicht für jede Aufgabe.
Das folgende Diagramm zeigt alle Terminal-Bench 3.0 Ergebnisse und wie sie gescheitert sind – aufgeteilt nach Modellen und Effort-Leveln. Insgesamt reduziert mehr Aufwand Fehler durch übersehene Randfälle (lila Blöcke), hilft aber nicht, wenn das Modell den falschen Ansatz wählt (blaue Blöcke).
Problembereiche, in denen Aufwand wirklich hilft
Eine der spannendsten Erkenntnisse aus meinen Tests mit TerminalBench war, dass manche Problembereiche deutlich stärker vom Effort profitierten als andere. Die Aufteilung siehst du in diesem Diagramm:
Um das zu verdeutlichen, habe ich ein paar Aufgaben aus verschiedenen Bereichen von Terminal Bench 3.0 ausgewählt, bei denen Opus 5.5 mit niedrigem Aufwand scheiterte, aber mit hohem Erfolg hatte – meistens, weil es Randfälle testete und berücksichtigte:
mvcc-lsm-compaction: Eine Terminal-Bench 3.0 Aufgabe, die einen Fix für einen Storage-Engine-Bug anhand eines Crash-Reports verlangt, ohne die Compaction zu brechen. Opus 5.5 verbesserte sich von 0/5 bei low auf 4/5 bei xhigh.
Bei niedrigem Aufwand (ca. eine Minute pro Versuch) bearbeitete Claude den Code, bevor es ihn baute oder den Reproducer startete, und prüfte nicht, ob der neue Test den ursprünglichen Bug überhaupt gefunden hätte.
Bei xhigh (ca. 11 Minuten) reproduzierte Claude zuerst den Crash, schrieb einen randomisierten Test gegen eine Referenz ohne Compaction und stellte sicher, dass seine Tests bei halb fertigen Fixes anschlugen.
cli-2ph-simple: Eine Terminal-Bench 3.0 Aufgabe, die einen CLI-Solver für lineare Programmierung in Python verlangt. Opus 5.5 ging von 0/5 bei low auf 5/5 bei high.
Bei den Low-Versuchen wurde der Solver in einem Rutsch geschrieben, mit ein paar kleinen Problemen getestet und nach rund 10k Tokens gestoppt. In der letzten Nachricht warnte Claude, dass es bei großen Problemen langsam sein könnte – geprüft hat es das aber nicht.
Bei den High-Versuchen testete Claude seinen Solver mit Zufallsproblemen gegen einen separaten Brute-Force-Solver, stoppte die Zeiten bei größeren Fällen, stieß auf Läufe, die viel zu lange dauerten oder abstürzten, und überarbeitete daraufhin seine Suchlogik.
gsea-proteomics: Eine Terminal-Bench 3.0 Aufgabe, die eine Gene Set Enrichment Analysis (GSEA) auf Proteomik-Daten verlangt, um herauszufinden, welche von acht Behandlungen einem Zielgewebe ähneln. Opus 5.5 stieg von 0/5 bei low auf 4/5 bei high.
Bei niedrigem Aufwand wählte Claude einen plausibel klingenden Weg zur Datenaufbereitung, führte die Analyse genau so durch und meldete das Ergebnis.
Bei hohem Aufwand probierte Claude zwei Methoden zur Datenaufbereitung aus, bemerkte, dass sich die Liste der signifikanten Behandlungen änderte, und ging der Ursache auf den Grund, bevor es die richtige Methode wählte.
Wäre ein Mensch im Loop gewesen, hätte Claude vermutlich nachgefragt, wie das Problem aufzusetzen ist. Ohne menschliches Feedback liefert hoher Aufwand aber das bessere Ergebnis.
Wann du welchen Effort in Claude Code nutzen solltest
Hier meine Faustregel für die Wahl des richtigen Levels:
- Low: Wenn ich schnelle Antworten brauche und eng im Loop bleiben will, z. B. beim Brainstorming, für Skizzen oder einfache Änderungen.
- Medium: Für den Großteil meiner normalen Softwareentwicklung, z. B. beim Umsetzen neuer Features.
- High: Für Aufgaben, bei denen Verifizierung entscheidend ist oder viele Randfälle lauern, z. B. beim Beheben eines Bugs in einer gewachsenen Codebase.
- Max: Wenn Claude völlig autonom knifflige Probleme lösen soll, z. B. beim kompletten Bauen und Verifizieren einer App oder beim Finden von Sicherheitslücken in kritischer Software.
Probier aus, den Effort für Opus 5.5 und Fable 5.1 je nach Aufgabe anzupassen – oder sogar mitten im Gespräch über den Befehl /effort in Claude Code. Sag mir gerne Bescheid, ob das deiner Intuition entspricht.
