50 praktische Anwendungsmöglichkeiten für Claude Code: Rezepte zur Delegation täglicher Aufgaben

Claude Code ist ein Tool, mit dem du Aufgaben direkt an Claude von deinem Terminal aus delegieren kannst. Es ist nicht nur zum Schreiben von Code gedacht; es kann alles erledigen, von Dateiorganisation und Datenverarbeitung bis hin zu Recherche und Dokumenterstellung und übernimmt deine täglichen, lästigen Aufgaben. Dieser Artikel fasst 50 konkrete Aufgaben zusammen, bei denen du sofort den Wert erkennen kannst, gegliedert nach Szenario → Methode (Anweisungen, die du so eingeben kannst) → Effekt. Probiere noch heute die Aufgaben aus, die dich interessieren.

Inhaltsverzeichnis

1. Datei- und Ordnerorganisation automatisieren (01–05)
2. Daten verarbeiten und konvertieren (06–10)
3. Code schreiben und reparieren (11–18)
4. Codebasen verstehen (19–23)
5. Git / GitHub-Aufgaben delegieren (24–29)
6. Einrichtung der Umgebung, Skripte und Konfiguration (30–34)
7. Recherche und Dokumenterstellung (35–39)
8. Effizienz-Setup (Einstellungen und Automatisierung) (40–45)
9. Integrationen, Bilder und Workflow-Techniken (46–50)

1. Datei- und Ordnerorganisation automatisieren

Claude Code ist hervorragend in Dateioperationen. Du kannst damit überladene Umgebungen auf einmal aufräumen lassen.

01. Downloads automatisch nach Projekt oder Typ klassifizieren

• Szenario: Der Download-Ordner ist ein Chaos, und du findest keine Dateien.
• Methode: "Sieh dir den Inhalt von Downloads an und organisiere sie in Ordner nach Projekt und Dateityp."
• Effekt: Das Sortieren von Hunderten von Dateien ist in Minuten erledigt. Manuelle Organisation entfällt.

02. Dateien stapelweise nach Namenskonventionen umbenennen

• Szenario: Du möchtest inkonsistente Namen wie IMG_0001 vereinheitlichen.
• Methode: "Benenne diese Bilder stapelweise im Format 'Datum_Seriennummer' um."
• Effekt: Auch ohne Kenntnis regulärer Ausdrücke kannst du große Mengen von Dateien auf einmal ordnen.

03. Bilder stapelweise in der Größe anpassen und komprimieren

• Szenario: Du möchtest Bilder für einen Blog leichter machen.
• Methode: "Passe die Größe der Bilder in diesem Ordner auf 1200px Breite an und konvertiere sie in WebP."
• Effekt: Du musst nicht nach Konvertierungstools suchen; du kannst einfach nach Stapelverarbeitung fragen.

04. Doppelte Dateien finden und organisieren

• Szenario: Identische Dateien sind überall verstreut und verschwenden Speicherplatz.
• Methode: "Erkenne doppelte Dateien in diesem Ordner und liste sie auf."
• Effekt: Du siehst auf einen Blick, welche du sicher löschen kannst.

05. Ordnerstruktur visualisieren und Organisationsvorschläge machen

• Szenario: Du bist unsicher, wie du einen unordentlichen Ordner organisieren sollst.
• Methode: "Liste die Struktur dieses Ordners und schlage einen Organisationsplan vor."
• Effekt: Du erhältst einen Überblick und Verbesserungsvorschläge, die dir bei der Entscheidung für eine Aufräumstrategie helfen.

2. Daten verarbeiten und konvertieren

Du kannst mühsame Datenaufgaben mit CSV, JSON, Logs usw. auslagern.

06. Mehrere CSVs kombinieren und zusammenfassen

• Szenario: Monatliche CSVs sind getrennt, und du möchtest Summen berechnen.
• Methode: "Kombiniere diese 12 CSVs und berechne den Gesamtumsatz pro Monat."
• Effekt: Der Aufwand des Kopierens, Einfügens und Zusammenfassens in Excel entfällt.

07. Unordentliche CSV/Excel-Daten bereinigen

• Szenario: Du möchtest Daten mit verschobenen Kopfzeilen oder zu vielen leeren Zeilen korrigieren.
• Methode: "Entferne die überflüssigen Zeilen aus dieser CSV und formatiere sie in eine ordentliche Tabelle."
• Effekt: Es übernimmt die manuelle Arbeit der Datenbereinigung vollständig.

08. Formate konvertieren, z. B. JSON ⇄ CSV

• Szenario: Du möchtest API-JSON in einer Tabellenkalkulation anzeigen.
• Methode: "Konvertiere dieses JSON in CSV."
• Effekt: Du erhältst sofort das gewünschte Format, ohne nach Konvertierungstools suchen zu müssen.

09. Fehler aus großen Logs extrahieren und einen Bericht erstellen

• Szenario: Du weißt nicht, wo das Problem in einer riesigen Logdatei liegt.
• Methode: cat app.log | claude -p "Fasse Fehler nach Typ zusammen und erstelle einen Bericht"
• Effekt: Du kannst in Minuten Kernpunkte aus Zehntausenden von Zeilen extrahieren.

10. Text in Screenshots oder Bildern in Text umwandeln (OCR)

• Szenario: Du möchtest Tabellen oder Code aus einem Bild nicht neu abtippen.
• Methode: Füge den Screenshot ein und sage: "Transkribiere den Text in diesem Bild."
• Effekt: Es wird in kopierbaren Text umgewandelt, ohne manuelle Eingabe.

3. Code schreiben und reparieren

Natürlich übernimmt es auch die Kernprogrammierung. Es ist am effektivsten in Situationen, in denen du nicht weiterkommst.

11. Fehler beheben, indem du einfach Fehlermeldungen einfügst

• Szenario: Du verstehst die Bedeutung des Fehlers nicht oder weißt nicht, wie du ihn beheben kannst.
• Methode: Füge den vollständigen Fehler ein und sage: "Identifiziere die Ursache und behebe sie."
• Effekt: Bevor du überhaupt herumsuchst, werden dir die Ursache und eine Lösung auf einmal geliefert.

12. Automatisierte Tests mit "Write tests" generieren

• Szenario: Du hast Angst, Änderungen vorzunehmen, weil es keine Tests gibt.
• Methode: "Schreibe Tests für diese Funktion, die die Hauptfälle abdecken."
• Effekt: Delegiere die mühsame Testerstellung und refaktoriere mit gutem Gewissen.

13. Funktionen und Klassen gemeinsam refaktorieren

• Szenario: Lange Funktionen sind schwer lesbar oder haben viele Duplikate.
• Methode: "Teile diese Funktion nach Verantwortlichkeiten auf, um sie lesbarer zu machen."
• Effekt: Es räumt die Struktur auf, während die Funktionalität erhalten bleibt.

14. Reguläre Ausdrücke aus deinen Zielen erstellen lassen

• Szenario: Du bist schlecht in Regex und bleibst jedes Mal hängen.
• Methode: "Erstelle einen Regex, der Telefonnummern findet. Füge Testbeispiele hinzu."
• Effekt: Du erhältst sofort einen funktionierenden Regex ohne Ausprobieren.

15. SQL aus Anforderungen in natürlicher Sprache schreiben lassen

• Szenario: Du kannst keine komplexen JOINs oder Aggregationsabfragen schreiben.
• Methode: "Schreibe eine SQL-Abfrage, um die Top-10-Umsätze pro Kunde aus dem letzten Monat zu erhalten."
• Effekt: Wenn du die Tabellenstruktur angibst, gibt es eine ausführbare Abfrage aus.

16. Typdefinitionen/Annotationen zu vorhandenem Code hinzufügen

• Szenario: Du möchsten untypisierten Code sicherer machen.
• Methode: "Füge Typannotationen zu dieser Datei hinzu und behebe alle Typfehler."
• Effekt: Du kannst die Massentypisierung abschließen, die manuell schwierig wäre.

17. Kommentare oder Logmeldungen stapelweise übersetzen

• Szenario: Du möchtest englische Kommentare ins Deutsche vereinheitlichen (oder umgekehrt).
• Methode: "Übersetze die Kommentare in dieser Datei ins Deutsche."
• Effekt: Du kannst Sprachen angleichen, während die Bedeutung erhalten bleibt.

18. Einen Entwurf einer neuen Funktion aus Spezifikationen implementieren

• Szenario: Es ist mühsam, von Grund auf neu zu schreiben.
• Methode: "Erstelle eine Funktion, die X macht. Ein funktionierender Entwurf ist fürs Erste in Ordnung."
• Effekt: Du kannst mit einem Prototyp starten, anstatt mit einer leeren Seite.

4. Codebasen verstehen

Du kannst auch die Aufgabe des "Lesens" von übernommenem Code oder neuen Repositories delegieren.

19. Das gesamte Repository lesen und den Überblick erklären

• Szenario: Du weißt nicht, wofür der übernommene Code ist.
• Methode: claude → "Erkläre das Gesamtbild, was dieses Repository tut."
• Effekt: Du kannst ein neues Projekt in kurzer Zeit erfassen.

20. Fragen: "Wo soll ich anfangen zu lesen?"

• Szenario: Du kennst den Einstiegspunkt einer riesigen Codebasis nicht.
• Methode: "Welcher Datei sollte ich folgen, um die Login-Funktionalität nachzuverfolgen?"
• Effekt: Du kennst die Reihenfolge zum Lesen, anstatt blind zu suchen.

21. Komplexe Prozesse mit Schritten oder Diagrammen erklären

• Szenario: Komplizierte Logik passt nicht in deinen Kopf.
• Methode: "Erkläre den Ablauf dieses Prozesses Schritt für Schritt."
• Effekt: Code wird zu einem Handbuch in einfacher Sprache.

22. Automatisch eine README generieren

• Szenario: Es gibt keine README oder sie ist veraltet.
• Methode: "Erstelle eine README für dieses Projekt (Einführung, Verwendung, Struktur)."
• Effekt: Du bist von der schweren Arbeit der Dokumentation befreit.

23. API-Spezifikationen aus dem Code-Inhalt erstellen

• Szenario: Es ist schwer, manuell eine Liste von Endpunkten zu schreiben.
• Methode: "Erstelle eine Spezifikation für diese API mit Beschreibungen für jeden Endpunkt."
• Effekt: Du kannst die neuesten Spezifikationen direkt aus der Implementierung generieren.

5. Git / GitHub-Aufgaben delegieren

Routineaufgaben wie Commits, PRs und die Verwaltung des Verlaufs sind perfekt zur Delegation geeignet.

24. Änderungen in sinnvolle Einheiten aufteilen und committen

• Szenario: Du hast verschiedene Dinge repariert und kämpfst mit der Aufteilung der Commits.
• Methode: "Teile die Änderungen in sinnvolle Einheiten auf und committe sie."
• Effekt: Du erhältst einen sauberen Verlauf und musst keine Nachrichten selbst schreiben.

25. Automatisch einen PR mit einer Beschreibung erstellen

• Szenario: PR-Beschreibungen zu schreiben ist eine lästige Pflicht.
• Methode: "Erstelle einen PR für die aktuellen Änderungen. Schreibe die Beschreibung auf Deutsch."
• Effekt: Alles vom Push bis zur Beschreibung wird automatisch erledigt.

26. Einen CHANGELOG aus dem Commit-Verlauf generieren

• Szenario: Das manuelle Zusammenfassen von Release-Notizen ist mühsam.
• Methode: "Fasse die Änderungen seit dem letzten Tag in einem CHANGELOG zusammen."
• Effekt: Eine Liste der Änderungen wird ohne erneutes Durchgehen des Verlaufs erstellt.

27. Alte oder gemergte Branches bereinigen

• Szenario: Branches stapeln sich und erschweren die Übersicht.
• Methode: "Liste die gemergten lokalen Branches auf."
• Effekt: Du kannst sie sicher überprüfen und dann auf einmal organisieren.

28. Merge-Konflikte lösen

• Szenario: Ein Konflikt ist aufgetreten und hat deine Arbeit gestoppt.
• Methode: "Löse diesen Konflikt unter Berücksichtigung beider Absichten."
• Effekt: Es übernimmt die mühsame Aufgabe des Abgleichs von Änderungen.

29. Identifizieren: "Wann wurde dieser Fehler eingeführt?"

• Szenario: Du weißt nicht, welcher Commit etwas kaputt gemacht hat.
• Methode: "Identifiziere den Commit, der diesen Fehler aus dem Git-Verlauf eingeführt hat."
• Effekt: Du kannst verdächtige Änderungen genau eingrenzen.

6. Einrichtung der Umgebung, Skripte und Konfiguration

Lasse es Entwürfe für Konfigurationsaufgaben vorbereiten, die mühsam zu recherchieren und zu schreiben sind.

30. Einrichtungsprozeduren oder Skripte erstellen

• Szenario: Neue Teammitglieder haben Probleme bei der Einrichtung der Umgebung.
• Methode: "Erstelle ein Skript zur Einrichtung der Umgebung für dieses Projekt."
• Effekt: Du kannst verbale Anweisungen in ausführbare Schritte umwandeln.

31. Shell-Skripte für Routineaufgaben schreiben lassen

• Szenario: Du tippst jedes Mal dieselben Befehle manuell ein.
• Methode: "Erstelle ein Skript, das den angegebenen Ordner sichert und mit einem Datum komprimiert."
• Effekt: Du kannst mühsame Wiederholungen in einen einzigen Befehl umwandeln.

32. Entwürfe für Dockerfile / CI-Einstellungen erstellen

• Szenario: Du bist mit Docker oder GitHub Actions-Einstellungen nicht vertraut.
• Methode: "Erstelle ein Dockerfile und CI-Einstellungen für diese Node-App."
• Effekt: Du erhältst einen funktionierenden Entwurf, ohne von Grund auf zu recherchieren.

33. Konfigurationsdateien für bestimmte Zwecke generieren

• Szenario: Du möchtest .gitignore oder Lint-Einstellungen nicht von Grund auf neu schreiben.
• Methode: "Erstelle eine .gitignore, die zu diesem Projekt passt."
• Effekt: Einstellungen ohne Lücken sind sofort bereit.

34. Nach Schwachstellen oder veralteten Abhängigkeitspaketen suchen

• Szenario: Du machst dir Sorgen, Bibliotheken ungewartet zu lassen.
• Methode: "Suche nach Schwachstellen in Abhängigkeitspaketen und sieh, welche aktualisiert werden können."
• Effekt: Risiken und Aktualisierungsvorschläge werden aufgelistet, was Entscheidungen über die Reaktion erleichtert.

7. Recherche und Dokumenterstellung

Wenn du die Materialien bereitstellst, kann es Informationen und Dokumente für dich formen.

35. Im Internet recherchieren, um zu vergleichen und zusammenzufassen

• Szenario: Du möchtest Technologieentscheidungen oder neueste Informationen vergleichen.
• Methode: "Vergleiche X und Y und fasse die Auswahlkriterien zusammen."
• Effekt: Du erhältst eine Zusammenfassung über mehrere Quellen hinweg.

36. TODOs aus Besprechungsnotizen oder Protokollen extrahieren

• Szenario: Du möchtest "zu erledigende Dinge" aus langen Notizen ziehen.
• Methode: Füge die Notizen ein und sage: "Extrahiere Entscheidungen und TODOs mit Verantwortlichen."
• Effekt: Nächste Schritte werden klar, ohne erneutes Lesen.

37. Lange Texte oder Dokumente zusammenfassen

• Szenario: Du hast keine Zeit, ein Dokument zu lesen.
• Methode: "Fasse diese Datei in einer 3-Zeilen-Version und einer detaillierten Version zusammen."
• Effekt: Du kannst schnell das Gesamtbild erfassen, bevor du tiefer einsteigst.

38. Designnotizen oder Spezifikationen aus Code erstellen

• Szenario: Es gibt keine Spezifikationen, und die Implementierung ist die einzige Quelle der Wahrheit.
• Methode: "Schreibe die Spezifikationen für diese Funktion basierend auf dem tatsächlichen Verhalten auf."
• Effekt: Spezifikationen, die nur in jemandes Kopf existierten, werden zu einem Dokument.

39. Diagramme (Mermaid) erstellen, um sie in Dokumente einzufügen

• Szenario: Das manuelle Zeichnen von Architektur- oder Flussdiagrammen ist mühsam.
• Methode: "Verwandle den Ablauf dieses Prozesses in ein Mermaid-Flussdiagramm."
• Effekt: Diagramme werden aus Text generiert und können sofort in Dokumenten verwendet werden.

8. Effizienz-Setup (Einstellungen und Automatisierung)

Diese Einrichtungen machen die obigen Aufgaben noch schneller und sicherer.

40. Automatisch Projektregeln mit /init generieren

• Szenario: Du möchtest die ersten Einstellungen einfacher machen.
• Methode: /init
• Effekt: Eine Regeldatei (CLAUDE.md), die die Struktur analysiert, ist in Sekunden erstellt.

41. Regeln mit # spontan merken lassen

• Szenario: Du wiederholst jedes Mal "mach es beim nächsten Mal so".
• Methode: # Schreibe Commit-Nachrichten auf Deutsch
• Effekt: Einmal geschrieben, wird es von da an befolgt.

42. Häufig verwendete Anweisungen in /commands umwandeln

• Szenario: Du tippst dieselbe lange Anweisung viele Male.
• Methode: Speichere die Prozedur in .claude/commands/ → Rufe sie mit /lint-fix auf.
• Effekt: Routineaufgaben können mit einem einzigen Wort aufgerufen werden.

43. Automatisch bei jedem Speichern formatieren (Hooks)

• Szenario: Review-Kommentare nehmen zu, weil du vergisst zu formatieren.
• Methode: Richte einen Hook (PostToolUse) ein, der den Formatierer nach der Bearbeitung ausführt.
• Effekt: Vergessen zu formatieren wird strukturell unmöglich.

44. Unfälle mit "Zuerst nur planen" bei größeren Überholungen verhindern

• Szenario: Die Auswirkungen sind weitreichend, und die sofortige Ausführung ist beängstigend.
• Methode: "Führe die Arbeit noch nicht aus. Gib mir zuerst die Vorgehensweise."
• Effekt: Dies ist die Grundlage für die Unfallverhütung und stoppt übereilte Aktionen am ersten Schritt.

45. Recherche an Unteragenten delegieren

• Szenario: Eine lange Untersuchung ist vor dem Hauptthema erforderlich.
• Methode: "Recherchiere X mit einem Unteragenten und teile mir nur die Kernpunkte mit."
• Effekt: Die Unterhaltung wird nicht in Rechercheprotokollen vergraben, sodass du dich auf das Hauptthema konzentrieren kannst.

9. Integrationen, Bilder und Workflow-Techniken

Integration externer Dienste, Bildeingabe und kleine Tricks, um die tägliche Arbeit zu stabilisieren.

46. Durch Verknüpfung mit Slack oder Drive (MCP) posten oder speichern

• Szenario: Du kopierst und teilst Ergebnisse jedes Mal manuell.
• Methode: Nach MCP-Verbindung: "Poste die Ergebnisse an Slack #development."
• Effekt: Abschluss bis zum Teilen mit einer Anweisung, ohne Apps zu wechseln.

47. UI durch Einfügen von Screenshots implementieren oder reparieren

• Szenario: Du möchtest einen Bildschirm genau wie ein Designbild erstellen.
• Methode: Füge das Bild ein und sage: "Korrigiere das CSS, um diesem Design zu entsprechen."
• Effekt: Du kannst Aussehen, das schwer in Worte zu fassen ist, mit einem einzigen Bild vermitteln.

48. Ursachen durch Anzeigen von Fehlerbildschirmen identifizieren

• Szenario: Du verstehst die Bedeutung eines Browser-Fehlerbildschirms nicht.
• Methode: Füge den Screenshot ein und sage: "Sage mir die Ursache und die Behebung für diesen Fehler."
• Effekt: Du kannst direkt konsultieren, ohne transkribieren zu müssen.

49. Unterbrochene Arbeit sofort mit claude -c fortsetzen

• Szenario: Du möchtest zur Fortsetzung der Arbeit zurückkehren, die du geschlossen hast.
• Methode: claude -c
• Effekt: Setze fort, ohne die Situation neu erklären zu müssen.

50. Mit Esc anhalten, mit /rewind rückgängig machen

• Szenario: Es läuft anders als erwartet, oder du möchtest eine Bearbeitung rückgängig machen.
• Methode: Esc zum Anhalten, /rewind zum Zurücksetzen.
• Effekt: Du kannst jederzeit sicher neu machen, ohne Angst vor Fehlern.

Zusammenfassung

Claude Code ist ein Tool zum Schreiben von Code, aber es ist auch ein vielseitiger Assistent, der alles von der Dateiorganisation über die Datenverarbeitung bis hin zur Recherche und Dokumenterstellung übernehmen kann. Ich empfehle, mit Dingen zu beginnen, die "gerade jetzt nerven", wie 01 (Downloads-Organisation), 09 (Log-Analyse) oder 11 (Fehlerbehebung). Sobald du dich daran gewöhnt hast, baue es mit den Setups aus 40–45 zu deiner eigenen dedizierten Arbeitsumgebung aus.

Funktionen werden in verschiedenen Versionen hinzugefügt oder geändert. Überprüfe daher das aktuelle Verhalten mit /help und der offiziellen Dokumentation (code.claude.com/docs).