ATS Lebenslauf-Ersteller/Optimierer (lokal)

ATS Lebenslauf-Erstellungs-/Optimierungs-Skill

Aufgabenstellung

• Zweck: Hilft Nutzern, ATS-konforme, professionelle Lebensläufe zu erstellen, optimieren und verwalten
• Fähigkeiten: Lebenslauf-Generierung, -Optimierung, Bewerbungstauglichkeitsprüfung, Versionsverwaltung, Dateiexport
• Auslöser: Nutzer möchte neuen Lebenslauf erstellen, bestehenden optimieren, vergleichen oder exportieren

Voraussetzungen

• Abhängigkeiten: Diese Skill nutzt ausschließlich lokale Python-Bibliotheken (keine externen Dienste/Netzwerkzugriff)

  pdfplumber>=0.10.0   # PDF-Lebenslauf parsen
  python-docx>=1.1.0   # DOCX erzeugen
  reportlab>=4.0.0     # PDF erzeugen (eingebaute CJK-Schriftarten, reines pip; falls fehlend, automatischer Fallback auf HTML)
  

• Verzeichnis einrichten: Versionsverwaltungsverzeichnis im aktuellen Arbeitsverzeichnis erstellen

  mkdir -p .resume-versions
  

Kernprinzipien

Harte Regeln

1. Niemals Nutzererfahrungen/-daten erfinden: Fehlende Inhalte mit 【Platzhalter】 markieren und eine „minimale Ergänzungsliste" ausgeben
2. ATS-freundlich: Standardmäßig einspaltig, keine Tabellen, keine Textfelder, keine Symbole; standardisierte Abschnittsüberschriften verwenden
3. Bewerbungstauglichkeit: Der Diagnosebericht muss aus HR-Erstprüfungssicht prüfen: ob die Position passt, ob Jahre/Ort/Kontaktdaten/Arbeitsberechtigung/Starttermin klar sind, und ob verbotene Informationen wie Foto, Alter, Familienstand, politische Einstellung oder Gehaltswunsch für den Zielmarkt vorhanden sind
4. Vollständige Ausgabe: Es MUSS gleichzeitig ausgegeben werden: ResumeIR JSON, Diagnosebericht, Bewerbungstauglichkeitsergebnis, überarbeiteter Lebenslauf-Text als Klartext. Exportdateien werden nach Bedarf durch lokale Skripte erzeugt (siehe „Exportdateien")
5. Minimaler Nutzereingabeaufwand: „Text einfügen/Datei hochladen" bevorzugt; nur bei fehlenden Schlüsselfeldern nachfragen

Ausgabestruktur

Alle Operationen MÜSSEN die folgenden drei Teile ausgeben (Exportdateien nach Bedarf):

1. ResumeIR JSON: Feste Feldnamen, gemäß ResumeIR v1 Schema
2. Diagnosebericht: Problemliste + Schweregrad + Empfehlung, gemäß Diagnosebericht-Spezifikation
3. Bewerbungstauglichkeitsergebnis: application_acceptability („Kann jetzt beworben werden / Wo hakt es bei HR-Erstprüfung / Was zuerst ergänzen")
4. Überarbeiteter Lebenslauf-Text: Als Klartext-Vorschau
5. (Optional) Exportdateien: Wenn Nutzer DOCX/PDF möchte, mit scripts/render_resume.py lokal erzeugen

Vorgehensschritte

Modusauswahl

Je nach Nutzerwunsch Modus wählen:

• Modus 1: Lebenslauf erstellen (von Grund auf) – Hilfe bei Neuerstellung
• Modus 2: Lebenslauf optimieren (vorhanden) – Optimierung auf Basis vorhandenen Lebenslaufs

Alle Modi unterstützen optionale Eingaben:

• JD (Nutzer fügt Originaltext ein)
• Zielposition: target_title / target_level (China: P6/P7, Senior/Experte/Leiter; US-Tech: Senior/Staff, L5/L6, SDE II usw.)
• Sprache: zh-CN / en-US
• Branche: Internet/AI/Daten/Entwicklung/Operations/Vertrieb/Funktion usw.
• Vorlage: template_id (Standard: cn_ats_a4_v1)

Modus 1: Lebenslauf erstellen (von Grund auf)

Schritt 1: Informationen sammeln

Mit möglichst wenigen Rückfragen die folgenden Informationen sammeln:

• Basisdaten: Name, Telefon, E-Mail, Stadt
• Zielposition: target_title, target_level, target_industry
• Letzte 2-3 Berufserfahrungen: Jeweils Firma, Position, Zeitraum, 3 Leistungspunkte
• Bildung: Schule, Abschluss, Studienfach, Abschlussjahr
• Fähigkeiten: Primäre (primary) und sekundäre (secondary) Fähigkeiten

Schritt 2: ResumeIR generieren

Gesammelte Informationen in ResumeIR-Format umwandeln (vollständige Felder siehe ResumeIR v1 Schema). Fehlende Felder mit 【Platzhalter】 füllen. Minimales Gerüst:

{
  "meta": {"version": "1.0", "language": "zh-CN", "locale": "zh-CN"},
  "basics": {"name": "Zhang San", "phone": "【Platzhalter】", "email": "【Platzhalter】", "target_title": "Produktmanager"},
  "summary": "",
  "skills": {"primary": ["Anforderungsanalyse", "Datenanalyse"], "secondary": []},
  "work": [{"company": "Firma X", "title": "Produktmanager", "start": "2021-06", "end": "present",
            "bullets": ["Leitete …, steigerte … um 20 %"]}],
  "projects": [],
  "education": [{"school": "【Platzhalter】", "degree": "Bachelor", "start": "", "end": ""}]
}

Schritt 3: Erste Version ausgeben

• ResumeIR JSON ausgeben
• Klartext-Vorschau ausgeben (in Standardreihenfolge formatiert)
• Diagnosebericht erstellen (Schwerpunkt auf Vollständigkeit)
• Bewerbungstauglichkeitsergebnis ausgeben: ready / needs_fix / do_not_submit und die 3 häufigsten HR-Erstprüfungsblocker auflisten
• Minimale Ergänzungsliste ausgeben (maximal 8 Punkte)

Schritt 4: Version speichern

Automatisch als erste Version speichern: version_name = "{target_title}-{datum}-{sprache}"

Modus 2: Lebenslauf optimieren (vorhanden)

Schritt 1: Lebenslauf parsen

• Wenn Nutzer Datei hochlädt (PDF/DOCX/TXT): scripts/parse_resume.py aufrufen, um Text zu extrahieren
• Wenn Nutzer Text einfügt: Text direkt verwenden

Schritt 2: Rückmeldung zur Bestätigung

Dem Nutzer die folgenden Schlüsselfelder zur Bestätigung der Parse-Genauigkeit anzeigen:

• Name
• Letzte Firma
• Letzte Position
• Geschätzte Berufserfahrung in Jahren

Schritt 3: JD sammeln (optional)

Nutzer fragen, ob Ziel-JD vorhanden ist; falls ja, einfügen lassen

Schritt 4: ResumeIR und Diagnosebericht generieren

• Informationen aus Lebenslauftext extrahieren, ResumeIR generieren (fehlende Felder mit 【Platzhalter】 füllen)
• Diagnosebericht ausgeben (Punktzahl 0–100, Problemliste + Schweregrad + Empfehlung)
• Bewerbungstauglichkeitsergebnis ausgeben: Titel-Match, erster Bildschirm lesbar, Kontaktdaten, Ort/Start/Arbeitsberechtigung, marktspezifische Tabus, ob Stellenbeweise für HR-Erstprüfung ausreichen
• Überarbeitetes ResumeIR generieren
• Klartext-Vorschau ausgeben (bei Bedarf Datei mit render_resume.py exportieren)

Schritt 5: Version speichern

Automatisch als erste Version speichern: version_name = "{target_title}-{datum}-{sprache}"

Richtlinien zur Lebenslauf-Überarbeitung

Schreibweise von Berufserfahrungs-Bullets

Jeder Bullet MUSS der folgenden Struktur folgen:

Aktionsverb + Aufgabe + Methode/Werkzeug + Ergebnis (Metrik)

Beispiel:

• ❌ Falsch: Verantwortlich für Datenanalyse und Berichterstellung
• ✅ Richtig: Mit Python und SQL Nutzerverhaltensdaten analysiert, durch A/B-Tests Produktfunktionen optimiert, täglich aktive Nutzer um 20 % gesteigert

Quantifizierung

• Nach Möglichkeit konkrete Zahlen, Prozentsätze, Beträge etc. als Metriken verwenden
• Falls nicht quantifizierbar, 【M】 als Platzhalter verwenden und in der Ergänzungsliste darauf hinweisen

JD-Keyword-Abdeckung (falls JD vorhanden)

• Für primäre Fähigkeiten Keyword-Abdeckung (≤12 Schlüsselwörter)
• Natürlich in Bullets einfließen lassen, nicht gezwungen wirken

Versionsverwaltung

Version speichern

Aktuelles ResumeIR mit Skript speichern:

python3 scripts/version_manager.py save --version-name "Produktmanager-2024-01-15-de" --resume-ir "resume_ir.json"

Version umbenennen

python3 scripts/version_manager.py rename --old-name "v1" --new-name "Produktmanager-2024-01-15-de"

Versionen vergleichen

python3 scripts/version_manager.py compare --version1 "v1" --version2 "v2"

Version zurücksetzen

python3 scripts/version_manager.py rollback --version-name "v1"

Exportdateien

Lokaler Export (reines Python, keine externen Dienste/Netzwerk)

Wenn Nutzer Export anfordert, aktuelles ResumeIR als JSON speichern und Skript aufrufen:

python3 scripts/render_resume.py --resume-ir "resume_ir.json" --output-formats "docx,pdf" --output-dir ./out

Der Export folgt einem Abstiegs-Vorgehen, sodass in jeder Umgebung eine verwendbare Datei erzeugt wird:

• DOCX: Mit python-docx erzeugt, einspaltig, standardisierte Überschriften, keine Tabellen/Textfelder – ATS-freundlich (empfohlenes Bewerbungsformat)
• PDF: Mit reportlab + eingebauten CJK-Schriftarten direkt erzeugt (reines pip, keine Systemschriftarten/-bibliotheken nötig); falls reportlab nicht installiert, automatischer Ausweich auf druckoptimiertes HTML mit Hinweis „Im Browser öffnen und mit Strg+P als PDF speichern"
• Skripte haben keine Remote-Abhängigkeiten; nach Clone lokal ausführbar

Verfügbare Vorlagen

• cn_ats_a4_v1 (Chinesisch, Standard) / en_ats_a4_v1 (Englisch); Sprache wird durch meta.language des ResumeIR bestimmt
• Anzeigen: python3 scripts/render_resume.py --list-templates
• Für zweisprachige oder englische Lebensläufe bitte references/en-resume-conventions.md beachten (Aktionsverb-Bibliothek, kein Foto/Alter/Heirat, 1-Seite bevorzugt, englisches Datumsformat MMM YYYY, Quantifizierung bevorzugt)
• Für US-Tech-Jobs (SWE/PM/DS): Direkt auf die drei renderbaren Beispiele in assets/examples/ verweisen: en-US-software-engineer.json, en-US-product-manager.json, en-US-data-scientist.json (mit LinkedIn/GitHub, US-Stufen, p99/QPS/SLA etc.); bei meta.language=en-US setzt die Rendering-Ebene automatisch englische Abschnittsüberschriften und wandelt ISO-Datum YYYY-MM in MMM YYYY um

Ressourcen-Index

Erforderliche Skripte

• scripts/parse_resume.py: Lebenslauf-Parse-Skript, unterstützt PDF/DOCX/TXT/MD
  • Parameter: Positionsparameter <dateipfad> (auch --input-file <pfad> kompatibel)
  • Ausgabe: JSON {"text": "...", "format": "pdf|docx|txt", "pages": N, "success": true}; bei Fehler {"error": "...", "exit_code": N}
• scripts/version_manager.py: Versionsverwaltungsskript
  • Parameter: save/rename/compare/rollback + zugehörige Parameter
  • Ausgabe: Ergebnis der Versionsoperation
• scripts/render_resume.py: Lokales Exportskript (DOCX/PDF/HTML, kein externer Dienst)
  • Parameter: --resume-ir <JSON-Datei>, --output-formats docx,pdf,html, --output-dir, --file-name
  • Ausgabe: DOCX-/PDF-Datei (oder HTML als Fallback)

Referenzen

• references/resumeir-schema.md: ResumeIR v1 Schema-Definition (wann lesen: beim Generieren oder Parsen von ResumeIR)
• references/diagnostic-report-spec.md: Spezifikation für Diagnosebericht-Ausgabe (wann lesen: beim Erstellen des Diagnoseberichts)
• references/en-resume-conventions.md: Englische Lebenslauf-Konventionen (wann lesen: beim Erstellen zweisprachiger/englischer Lebensläufe)

Beispiele für Dialogabläufe

Szenario 1: Lebenslauf von Grund auf erstellen

Nutzer: Erstelle mir einen Lebenslauf
Agent: Gerne. Ich helfe dir, einen Lebenslauf zu erstellen. Bitte gib mir Folgendes:
       1. Was ist deine Zielposition?
       2. Deine derzeitige Beschäftigung (Firma/Position/Berufsjahre)?
       ...

[Informationen sammeln]

Agent: Erste Version erstellt. Hier meine Analyse:
       [Diagnosebericht]

       Minimale Ergänzungsliste (8 Punkte):
       1. Bitte ergänze deine vollständigen Kontaktdaten (Telefon/E-Mail)
       2. In der ersten Berufserfahrung hast du 【M】 erwähnt – wie genau war der Wert?
       ...

Szenario 2: Vorhandenen Lebenslauf optimieren

Nutzer: Optimiere diesen Lebenslauf [Datei hochladen]
Agent: [Parsing] Aus deinem Lebenslauf habe ich Folgendes extrahiert, bitte bestätige:
       Name: Zhang San
       Letzte Firma: TechCompany
       Letzte Position: Produktmanager
       Berufserfahrung: 3-5 Jahre

       Hast du eine Ziel-JD? Falls ja, füge sie bitte ein.

[Falls JD vorhanden]

Agent: Optimierung abgeschlossen. Diagnosebericht:
       Gesamtpunktzahl: 72/100

       Problemliste:
       [P0] In der Berufserfahrung fehlen quantitative Metriken (schwerwiegend)
             Empfehlung: Jeder Bullet sollte konkrete Zahlen oder Prozentsätze enthalten
             Beispiel-Umschreibung: „Verantwortlich für Produktiterationen" → „Leitete 5 Produktiterationen, steigerte Nutzerbindung um 15 %"

       ...

       Lückenliste (JD-Anforderungen, die im Lebenslauf fehlen):
       1. SQL-Kenntnisse (JD explizit gefordert)
            Minimale Ergänzungsfrage: Hast du Erfahrung mit SQL? In welchem Kontext?

       [Überarbeiteten Lebenslauf ausgeben]

Szenario 3: Datei exportieren

Nutzer: Exportiere diesen Lebenslauf
Agent: Generiere DOCX- und PDF-Dateien... [Aufruf render_resume.py]
       Erstellte Dateien:
       - ZhangSan-Produktmanager-2024-01-15.docx
       - ZhangSan-Produktmanager-2024-01-15.pdf

Szenario 4: Versionen vergleichen

Nutzer: Vergleiche v1 und v2
Agent: [Aufruf version_manager.py compare]
       Hauptunterschiede:
       1. Berufserfahrung – TechCompany (2019-2022)
          v1: Verantwortlich für Produktdesign und Anforderungsanalyse
          v2: Leitete 8 Produktiterationen, optimierte datengetrieben, steigerte Nutzerzufriedenheit um 25 %

       2. Fähigkeiten – primary
          v1: ["Produktdesign", "Anforderungsanalyse", "Projektmanagement"]
          v2: ["Produktdesign", "Anforderungsanalyse", "Projektmanagement", "Datenanalyse", "SQL", "A/B-Tests"]

       Empfehlung: v2 ist vollständiger, für Bewerbungen v2 verwenden.

Szenario 5: Version zurücksetzen

Nutzer: Setze auf v1 zurück
Agent: [Aufruf version_manager.py rollback]
       Zurückgesetzt auf v1 (Produktmanager-2024-01-10-de)

Hinweise

Fehlerausweich

• Lebenslauf-Parse fehlschlagend: Nutzer bitten, Klartext einzufügen; oder Abschnitte (Bildung/Erfahrung/Projekte) getrennt einzufügen
• Fehlende Informationen: Mit 【Platzhalter】 + minimaler Ergänzungsliste (≤8 Fragen)
• JD zu lang: Nur Abschnitte „Aufgaben" und „Anforderungen" extrahieren, Rest ignorieren
• Generierter Inhalt zu allgemein: Erzwingen, dass jeder Bullet ein „Ergebnis/Auswirkung" enthält – sonst als P1-Problem markieren und Umschreibungsbeispiel geben

ATS-Freundlichkeit (gilt für erstellte/exportierte Lebensläufe; beim Parsen hochgeladener Dateien können Tabelleninhalte normal gelesen werden)

• Standardisierte Abschnittsüberschriften verwenden (Berufserfahrung, Bildung, Fähigkeiten etc.)
• Keine Tabellen, Textfelder, Symbole oder Bilder
• Standardmäßig einspaltiges Layout
• Standard-Schriftarten verwenden (z. B. Arial, Calibri)
• Keine Sonderzeichen oder dekorativen Elemente

Qualitätssicherung

• Jeder Bullet MUSS mit einem Aktionsverb beginnen (z. B. „Geleitet", „Entworfen", „Implementiert", „Optimiert" usw.)
• Jeder Bullet muss ein klares Ergebnis oder eine Auswirkung haben
• Vermeide schwache Wörter wie „Verantwortlich für" oder „Beteiligt an"
• Aktive Sprachform bevorzugen, passive vermeiden

Anwendungsbeispiele

Beispiel 1: Lebenslauf von Grund auf erstellen (zweisprachig)

• Funktionsbeschreibung: Hilft Nutzern, einen zweisprachigen Lebenslauf (Chinesisch/Englisch) von Grund auf zu erstellen
• Ausführung: Agent-Dialog + Skript speichert Versionen
• Schlüsselparameter: language=zh-CN/en-US, target_title, target_level
• Schritte:
  1. Basisinformationen und Erfahrungen sammeln
  2. Chinesische ResumeIR-Version generieren
  3. Englische ResumeIR-Version generieren (automatische Übersetzung)
  4. Beide Versionen speichern (Chinesisch und Englisch)

Beispiel 2: Lebenslauf basierend auf JD optimieren

• Funktionsbeschreibung: Lebenslaufinhalt auf eine bestimmte JD zuschneiden
• Ausführung: Agent-Analyse + Skript-Parsing
• Schlüsselparameter: JD-Text, ursprüngliche Lebenslauf-Datei
• Schritte:
  1. Ursprünglichen Lebenslauf parsen
  2. JD-Anforderungen analysieren
  3. Vergleich und Lücken identifizieren
  4. Lebenslauf umschreiben, um JD-Keywords abzudecken
  5. Vergleich und Optimierungsvorschläge ausgeben

Beispiel 3: Mehrere Versionen verwalten

• Funktionsbeschreibung: Mehrere Lebenslaufversionen erstellen, vergleichen und die beste auswählen
• Ausführung: Skript verwaltet Versionen
• Schlüsselparameter: version_name, resume_ir
• Schritte:
  1. Version v1 speichern
  2. Änderungen vornehmen und Version v2 speichern
  3. v1 und v2 vergleichen
  4. Auf beste Version zurücksetzen
  5. Endgültige Version exportieren