Fähigkeit zur Zeitboxung von Besprechungsagenden

--- name: meeting-agenda-timeboxer description: Verwandelt eine grobe Liste von Besprechungsthemen in eine Zeitbox-Agenda mit Start- und Endzeiten, Verantwortlichen und einem klaren Ergebnis für jeden Punkt (informieren, diskutieren, entscheiden, brainstormen, überprüfen), prüft, ob sie mit Puffer in den Zeitrahmen passt, kennzeichnet Agenda-Probleme wie späte oder überstürzte Entscheidungen, zu viele Status-Updates, zu große Punkte und fehlende Pausen, und schreibt eine versandfertige Agenda und Vorab-Lektüre. Verwenden Sie dies, wenn ein Benutzer fragt "hilf mir, dieses Meeting zu planen", "passt diese Agenda in eine Stunde?", "mach diese Agenda straffer", oder eine Liste von Themen für ein Team-Meeting, einen Workshop, eine Klausurtagung oder ein Review teilt. --- # Meeting-Agenda-Zeitboxer Sie helfen Menschen, Meetings zu führen, die pünktlich enden und Entscheidungen hervorbringen. Sie verwandeln eine Liste von Themen in einen realistischen Zeitplan, geben jedem Punkt einen Verantwortlichen und einen Zweck, verlagern Status-Updates aus dem Raum und machen die Zeitberechnung sichtbar, damit niemand in Minute 55 entdeckt, dass für die Hauptentscheidung keine Zeit mehr bleibt. ## Dateien in dieser Fähigkeit - `scripts/timebox_agenda.py` - plant jeden Punkt ein, prüft die Passung gegen den Zeitrahmen und Puffer, kennzeichnet Agenda-Probleme und kann Punkte in 5-Minuten-Schritten an den Zeitrahmen anpassen (nur Python-3-Standardbibliothek) - `references/timeboxing-principles.md` - wie lange Dinge wirklich dauern, Punkte-Ergebnisse, Reihenfolge, Puffer und Pausen - `references/facilitation-moves.md` - Techniken, um jede Art von Punkt innerhalb seiner Zeitbox zu halten, und was zu tun ist, wenn einer überzieht - `templates/agenda.md` - das Agenda-Eingabeformat und die zu sendende Agenda - `examples/example-roadmap-meeting.md` - eine ausgearbeitete Korrektur eines überladenen einstündigen Planungsmeetings ## Arbeitsablauf ### 1. Fakten sammeln Fragen Sie, oder nehmen Sie an und sagen Sie es: - Zweck des Meetings in einem Satz: Was muss wahr sein, wenn es endet? - Startzeit und Dauer (oder Endzeit), Anzahl der Teilnehmer, persönlich oder remote. - Themen, jeweils mit einem Verantwortlichen und was die Gruppe damit tun muss: informieren, aktualisieren, diskutieren, brainstormen, überprüfen oder entscheiden. - Harte Einschränkungen: Personen, die später kommen oder früher gehen, feste Pausen. ### 2. Entwurf der Agenda schreiben Verwenden Sie das Eingabeformat in `templates/agenda.md` (eine Zeile pro Punkt: `Minuten | Thema | Verantwortlicher | Ergebnis`). Verwenden Sie `?` für eine Dauer, die niemand kennt. Schätzen Sie Dauern mit `references/timeboxing-principles.md`. ### 3. Zeitboxer ausführen ```bash python3 scripts/timebox_agenda.py agenda.txt python3 scripts/timebox_agenda.py agenda.txt --fit # Skalierung auf den Zeitrahmen in 5-Minuten-Schritten python3 scripts/timebox_agenda.py agenda.json --json ``` Es druckt den Zeitplan mit Uhrzeiten, den Puffer und die Ergebnisse: HIGH, wenn die Agenda nicht passt, WARN für Probleme, INFO für ungeplante Zeit und die Meeting-Kosten in Personenstunden. `--fit` kürzt zuerst Status-Punkte, skaliert dann alles andere; es ordnet Punkte nie neu, also überprüfen Sie die Reihenfolge danach selbst. Wenn Sie das Skript nicht ausführen können, machen Sie die Uhrzeitberechnung von Hand, Punkt für Punkt, und sagen Sie es. ### 4. Die Agenda korrigieren, nicht nur die Zahlen Arbeiten Sie die Ergebnisse in dieser Reihenfolge durch: 1. Status-Updates und Ankündigungen entfernen oder verkleinern: Verschieben Sie sie in eine schriftliche Vorab-Lektüre. 2. Entscheidungen früh platzieren (erste Hälfte), und jeder mindestens 10 Minuten plus einen schriftlichen Vorschlag geben, der vorher gesendet wird. 3. Jedem Punkt einen Verantwortlichen und ein Ergebnis geben; "Sonstiges" streichen oder in eine 5-minütige Parkplatz-Überprüfung umwandeln. 4. Punkte über 45 Minuten aufteilen; alle 60 bis 90 Minuten eine Pause einfügen. 5. Wenn es immer noch nicht passt, vorschlagen, was zu streichen oder in ein anderes Meeting oder asynchron zu verschieben ist, und sagen, was verloren geht. Führen Sie das Skript erneut aus, bis es keine HIGH-Ergebnisse gibt und jedes WARN entweder behoben oder erklärt ist. ### 5. Liefern Füllen Sie die zu sendende Agenda aus `templates/agenda.md` aus: Zweck, gewünschte Ergebnisse, der zeitlich geplante Zeitplan, Vorab-Lektüren mit Verantwortlichen und Fristen, und die Parkplatz-Regel. Fügen Sie ein oder zwei Moderations-Tipps pro riskantem Punkt aus `references/facilitation-moves.md` hinzu. Folgen Sie dem Stil von `examples/example-roadmap-meeting.md`. ## Regeln - Lassen Sie die Mathematik nie funktionieren, indem Sie eine Entscheidung unter das schrumpfen, was sie braucht; streichen oder verschieben Sie etwas anderes, oder empfehlen Sie einen längeren Zeitrahmen. - Einen Puffer einhalten: etwa 5 Minuten pro Stunde, 10 Prozent für Workshops. - Klar sagen, wenn ein Meeting nicht stattfinden sollte (keine Entscheidungen, nichts zu diskutieren) und die asynchrone Alternative vorschlagen. - Die Kultur und Einschränkungen des Benutzers respektieren; vorschlagen, nicht belehren. - Zeiten sind lokal für das Meeting; für Remote-Teilnehmer in anderen Zeitzonen erwähnen, aber nicht umrechnen, außer auf Anfrage. ## Zeitbox-Prinzipien ### Jeder Punkt braucht ein Ergebnis | Ergebnis | Was die Gruppe tut | Typische Zeit | Hinweise | |---|---|---|---| | informieren | Etwas hören, eine klärende Frage stellen | 2 bis 5 Min | Besser als schriftliche Vorab-Lektüre. | | aktualisieren | Status von Personen oder Teams | 1 bis 2 Min pro Person | Normalerweise asynchron; nur Blocker live halten. | | diskutieren | Ein Thema erkunden, Ansichten teilen, noch keine Entscheidung | 10 bis 20 Min | Sagen, was die Diskussion speist (eine Entscheidung nächste Woche, ein Dokument). | | brainstormen | Optionen generieren | 15 bis 30 Min | Braucht eine formulierte Frage und eine Methode (zuerst stilles Schreiben). | | überprüfen | Feedback zu einem Entwurf, Design oder Plan geben | 15 bis 40 Min | Material vorher senden; vereinbaren, welche Art von Feedback gewünscht ist. | | entscheiden | Zwischen Optionen wählen und sich festlegen | 10 bis 30 Min | Braucht einen schriftlichen Vorschlag, die Optionen, den Entscheider und die Entscheidungsregel. | | Pause | Erholen | 5 bis 15 Min | Alle 60 bis 90 Minuten. | Wenn ein Punkt kein klares Ergebnis hat, fragen Sie: "Was wird nach diesem Punkt anders sein?" Wenn die Antwort "nichts" ist, streichen Sie ihn. ### Wie lange Dinge wirklich dauern - Vorstellungen: etwa 1 Minute pro Person für eine neue Gruppe, 0 für ein reguläres Team. - Jede Person spricht einmal zu einem Thema: etwa 1,5 bis 2 Minuten pro Person. Acht Personen, eine Runde, sind 15 Minuten. - Bildschirmfreigabe und Start: 2 bis 3 Minuten, mehr bei Remote-Meetings mit neuen Tools. - Eine Entscheidung mit echter Meinungsverschiedenheit: Schätzung verdoppeln, oder in "diskutieren" jetzt und "entscheiden" beim nächsten Mal aufteilen. - Punkte spät in der Agenda laufen schneller, aber schlechter: Leute hetzen oder gehen. ### Reihenfolge 1. Mit einer kurzen Rahmung beginnen: Zweck und gewünschte Ergebnisse (2 bis 5 Min). 2. Entscheidungen und die schwierigsten Themen in der ersten Hälfte, während Energie und Anwesenheit hoch sind. 3. Diskussion und Überprüfung in der Mitte. 4. Informationen und Updates zuletzt oder ganz aus dem Meeting heraus. 5. Mit nächsten Schritten, Verantwortlichen und Terminen enden (5 Min), nie mit "Sonstiges". Punkte gruppieren, die dieselben Leute brauchen, damit andere früher gehen können. ### Puffer und Pausen - Puffer: etwa 5 Minuten pro Stunde, 10 Prozent für Workshops. Der Puffer ist Teil des Zeitrahmens, keine zusätzliche Zeit. - Pausen: 5 bis 10 Minuten alle 60 bis 90 Minuten; 15 für längere Workshops. Remote-Meetings brauchen früher Pausen. - Aufeinanderfolgende Kalender: 5 Minuten früher enden (25- oder 50-minütige Meetings). ### Passungsprüfungen - Mehr als etwa 8 Punkte pro Stunde bedeutet, dass jeder weniger als 7 Minuten bekommt; zusammenlegen oder streichen. - Status und Ankündigungen über etwa einem Drittel der Zeit: In eine Vorab-Lektüre verschieben. - Ein Punkt über 45 Minuten: In Schritte mit eigenen Ergebnissen aufteilen (zum Beispiel "brainstormen 25" dann "clustern und auswählen 20"). ### Die Kosten eines Meetings Personenstunden = Teilnehmer x Dauer in Stunden. Ein einstündiges Meeting mit 9 Personen kostet 9 Arbeitsstunden. Fragen Sie, ob wirklich jeder bei jedem Punkt dabei sein muss. ## Moderations-Moves, die Zeitboxen einhalten ### Vor dem Meeting - Agenda und Vorab-Lektüren 24 bis 48 Stunden vorher senden, mit dem Verantwortlichen für jeden Punkt. - Für jeden Entscheidungspunkt einen einseitigen Vorschlag senden: die Frage, Optionen, Empfehlung und wer entscheidet. - Leute bitten, Fragen zur Vorab-Lektüre schriftlich hinzuzufügen, damit das Meeting mit Fragen beginnt, nicht mit einer Präsentation. ### Am Anfang - Zweck und die Ergebnisse nennen, die Sie bis zum Ende brauchen. - Einen Zeitwächter benennen und das Signal vereinbaren (eine Nachricht im Chat, eine erhobene Hand bei 2 Minuten Restzeit). - Sagen, wie heute entschieden wird: Der Verantwortliche entscheidet nach Input, Mehrheitsvotum oder Zustimmung ("irgendein starker Einwand?"). ### Nach Punkttyp - Informieren: "Zwei Minuten, dann eine klärende Frage pro Person." Detaillierte Fragen gehen auf den Parkplatz oder in einen Folge-Chat. - Aktualisieren: Nur Blocker und Bitten live; alles andere steht in der Vorab-Lektüre. - Diskutieren: Zuerst die Frage formulieren ("Was beunruhigt uns an Option B?"). Eine schnelle Runde nutzen, damit jeder einmal spricht, bevor jemand zweimal spricht. - Brainstormen: 3 bis 5 Minuten stilles Schreiben zuerst, dann teilen, dann clustern. Quantität vor Urteil. - Überprüfen: Die Art des Feedbacks vereinbaren: blockierende Probleme, Fragen oder Politur. Zuerst blockierende Probleme sammeln. - Entscheiden: Den Vorschlag wiederholen, Bedenken auflisten, auf Einwände prüfen, dann entscheiden und laut sagen: "Wir haben X entschieden; Verantwortlicher Y; bis Datum Z." ### Wenn ein Punkt überzieht Die Wahl sichtbar machen, statt still den nächsten Punkt aufzufressen: 1. "Wir haben noch 2 Minuten für diesen Punkt. Verlängern wir um 5 Minuten und streichen etwas anderes, oder parken wir ihn?" 2. Parken: Auf dem Parkplatz mit Verantwortlichem und Datum notieren. 3. Den nächsten Punkt verkleinern, nie die Entscheidungspunkte. 4. Wenn das Meeting-Ziel gefährdet ist, ein kurzes Folge-Meeting nur mit den benötigten Personen planen. ### Remote und hybrid - Alle nehmen auf ihrem eigenen Gerät teil, damit Remote-Personen gleichberechtigt sind. - Den Chat für die Redeliste und schnelle Umfragen nutzen. - Die Agenda auf dem Bildschirm teilen, mit dem aktuellen Punkt hervorgehoben. ### Am Ende - Entscheidungen, Verantwortliche und Termine vorlesen (5 Minuten). - Den Parkplatz überprüfen: jeden Punkt zuweisen oder fallen lassen. - Notizen innerhalb von 24 Stunden senden. ## Agenda-Eingabe (für scripts/timebox_agenda.py) ``` Meeting: <Name> Start: <HH:MM> Length: <Minuten> # oder End: <HH:MM> Buffer: <Minuten oder Prozent, z.B. 5 oder 10%> Attendees: <Anzahl> <Minuten> | <Thema> | <Verantwortlicher> | <informieren | aktualisieren | diskutieren | brainstormen | überprüfen | entscheiden | Pause> ? | <Thema mit unbekannter Dauer> | <Verantwortlicher> | <Ergebnis> ``` Eine Markdown-Tabelle mit den Spalten Min, Thema, Verantwortlicher, Ergebnis funktioniert auch, ebenso wie JSON: `{"meeting": "...", "start": "14:00", "length": 60, "buffer": 5, "attendees": 6, "items": [{"minutes": 10, "topic": "...", "owner": "...", "outcome": "decide"}]}` --- # Zu sendende Agenda **<Meeting-Name>** <Tag, Datum>, <Start>-<Ende> (<Dauer> Min), <Ort oder Video-Link> Teilnehmer: <Namen oder Teams> | Moderator: <Name> | Zeitwächter: <Name> | Notizen: <Name> **Zweck:** <ein Satz: was muss wahr sein, wenn wir fertig sind> **Ergebnisse, die wir brauchen** 1. <Entscheidung oder Ergebnis> 2. <Entscheidung oder Ergebnis> **Vorab-Lektüre (bis <Tag, Uhrzeit>)** - <Dokument> - <Verantwortlicher> - <worauf achten, wie lange das Lesen dauert> **Zeitplan** | Zeit | Min | Punkt | Verantwortlicher | Ergebnis | |---|---|---|---|---| | <HH:MM-HH:MM> | <n> | <Thema> | <Verantwortlicher> | <Ergebnis> | | <HH:MM-HH:MM> | <n> | Puffer und Abschluss: Entscheidungen, Verantwortliche, Termine | <Moderator> | | **Wie wir heute entscheiden:** <Verantwortlicher entscheidet nach Input | Zustimmung | Abstimmung> **Parkplatz:** Off-Topic-Punkte gehen auf den Parkplatz und bekommen am Ende einen Verantwortlichen. **Aus diesem Meeting verschoben** - <Punkt> -> <asynchrones Update, anderes Meeting oder ein Dokument>, Verantwortlicher <Name> ## Beispiel: Korrektur eines überladenen einstündigen Planungsmeetings ### Die Anfrage "Ich habe eine Stunde mit 9 Personen am Donnerstag um 14:00 Uhr, um Q4 zu planen. Hier ist meine Agenda. Passt sie? Die Budgetaufteilung muss in diesem Meeting genehmigt werden, und auch die Top-3-Initiativen." Agenda-Entwurf (`agenda.txt`): ``` Meeting: Q4 Roadmap-Planung Start: 14:00 Length: 60 Buffer: 5 Attendees: 9 10 | Begrüßung und Ziele | Dana | informieren 15 | Team-Statusrunde (jeder Teamleiter) | Leiter | aktualisieren 10 | Kundenservice-Highlights | Priya | informieren 20 | Q4-Prioritäten: Top-3-Initiativen auswählen | Lee | diskutieren 10 | Einstellungsplan für Q4 | | diskutieren 5 | Q4-Budgetaufteilung genehmigen | Dana | entscheiden ? | Sonstiges | | ``` ### Erster Lauf ``` $ python3 scripts/timebox_agenda.py agenda.txt Q4 Roadmap-Planung: 14:00-15:00 (60 Min, Puffer 5 Min, 55 Min für Punkte) Geplant: 70 Min 14:00-14:10 10 Min Begrüßung und Ziele (Dana) [informieren] 14:10-14:25 15 Min Team-Statusrunde (jeder Teamleiter) (Leiter) [aktualisieren] 14:25-14:35 10 Min Kundenservice-Highlights (Priya) [informieren] 14:35-14:55 20 Min Q4-Prioritäten: Top-3-Initiativen auswählen (Lee) [diskutieren] 14:55-15:05 10 Min Einstellungsplan für Q4 [diskutieren] 15:05-15:10 5 Min Q4-Budgetaufteilung genehmigen (Dana) [entscheiden] 15:10-15:10 ? Min Sonstiges [?] 14:55-15:00 5 Min Puffer / Abschluss Ergebnisse: - [HIGH] Agenda braucht 70 Min, aber nur 55 Min sind nach dem 5-Min-Puffer verfügbar: Überziehung von 15 Min (endet 15:10 statt 14:55). Streichen, kürzen oder verschieben Sie Punkte, oder führen Sie mit --fit aus. - [WARN] 1 Punkt(e) ohne Dauer: Sonstiges. Verbleibende Zeit dafür: 0 Min. - [WARN] "Einstellungsplan für Q4" hat keinen Verantwortlichen; benennen Sie, wer ihn vorbereitet und leitet. - [WARN] "Q4-Budgetaufteilung genehmigen" ist eine Entscheidung mit nur 5 Min; planen Sie mindestens 10, oder entscheiden Sie durch einen schriftlichen Vorschlag im Voraus. - [WARN] "Q4-Budgetaufteilung genehmigen" ist eine Entscheidung, die um 15:05 beginnt, im letzten Viertel des Meetings; verschieben Sie sie früher, während Energie und Anwesenheit hoch sind. - [WARN] "Sonstiges" hat keinen Verantwortlichen; benennen Sie, wer es vorbereitet und leitet. - [WARN] "Sonstiges" hat kein Ergebnis; sagen Sie, ob es zu informieren, diskutieren, entscheiden oder brainstormen ist. - [WARN] Status-Updates und Ankündigungen nehmen 50% der Zeit ein; senden Sie sie als Vorab-Lektüre und behalten Sie das Meeting für Diskussion und Entscheidungen. - [INFO] Meeting-Kosten: 9 Personen x 60 Min = 9 Personenstunden. ``` Exit-Code 1: Die Agenda passt nicht. ### Was die Zahlen sagen - 70 Minuten Punkte (plus Sonstiges) in einem 55-Minuten-Fenster: 15 Minuten über, bevor Sonstiges überhaupt beginnt. - Die Hälfte der Zeit sind Updates und Ankündigungen, während die beiden Dinge, die entschieden werden müssen, 5 Minuten (Budget) und ein "diskutieren"-Label (Prioritäten) bekommen, und die Budgetentscheidung um 15:05 beginnen würde, nachdem das Meeting hätte enden sollen. - `--fit` allein würde alles auf 55 Minuten quetschen, aber die Budgetentscheidung zuletzt mit 5 Minuten lassen. Die Zahlen anzupassen reicht nicht; die Reihenfolge und der Zweck der Punkte müssen sich ändern. ### Änderungen 1. Team-Statusrunde (15 Min) und Kundenservice-Highlights (10 Min) werden eine schriftliche Vorab-Lektüre, fällig Mittwoch 12:00; Fragen kommen in die Kommentare. 2. Die Budgetaufteilung rückt an den Anfang mit 10 Minuten und einem Vorschlag, der Montag gesendet wird, damit das Meeting nur bestätigt oder anpasst. 3. "Q4-Prioritäten" wird eine Entscheidung mit 25 Minuten: Das Ergebnis ist eine eingestufte Top 3. 4. Der Einstellungsplan bekommt einen Verantwortlichen (Priya) und eine engere Frage: welche Rollen zu eröffnen sind. 5. "Sonstiges" wird durch einen 5-minütigen "nächste Schritte, Verantwortliche und Parkplatz"-Abschluss ersetzt. 6. Drei Personen, die nur für die Statusrunde gebraucht werden, können das Meeting überspringen: 6 Teilnehmer statt 9. Überarbeitete Agenda: ``` Meeting: Q4 Roadmap-Planung Start: 14:00 Length: 60 Buffer: 5 Attendees: 6 5 | Begrüßung und Ziele für heute | Dana | informieren 10 | Q4-Budgetaufteilung genehmigen (Vorschlag Montag gesendet) | Dana | entscheiden 25 | Q4-Prioritäten: Top-3-Initiativen auswählen | Lee | entscheiden 10 | Einstellungsplan für Q4: zustimmen, welche Rollen zu eröffnen sind | Priya | diskutieren 5 | Nächste Schritte, Verantwortliche und Parkplatz | Dana | informieren ``` ### Zweiter Lauf ``` $ python3 scripts/timebox_agenda.py agenda-revised.txt Q4 Roadmap-Planung: 14:00-15:00 (60 Min, Puffer 5 Min, 55 Min für Punkte) Geplant: 55 Min 14:00-14:05 5 Min Begrüßung und Ziele für heute (Dana) [informieren] 14:05-14:15 10 Min Q4-Budgetaufteilung genehmigen (Vorschlag Montag gesendet) (Dana) [entscheiden] 14:15-14:40 25 Min Q4-Prioritäten: Top-3-Initiativen auswählen (Lee) [entscheiden] 14:40-14:50 10 Min Einstellungsplan für Q4: zustimmen, welche Rollen zu eröffnen sind (Priya) [diskutieren] 14:50-14:55 5 Min Nächste Schritte, Verantwortliche und Parkplatz (Dana) [informieren] 14:55-15:00 5 Min Puffer / Abschluss Ergebnisse: - [INFO] Meeting-Kosten: 6 Personen x 60 Min = 6 Personenstunden. ``` Exit-Code 0, keine Warnungen, und das Meeting kostet 6 Personenstunden statt 9. ### Die zu sendende Agenda (ausgefüllte Vorlage, gekürzt) **Q4 Roadmap-Planung** Donnerstag, 14:00-15:00 (60 Min), Raum 3 und Video-Link Moderator: Dana | Zeitwächter: Lee | Notizen: Priya **Zweck:** Mit einer genehmigten Q4-Budgetaufteilung und einer eingestuften Top 3 der Initiativen gehen. **Vorab-Lektüre (bis Mittwoch 12:00)** - Team-Status-Einseiter - jeder Teamleiter - 5 Min Lesezeit - Kundenservice-Highlights - Priya - 5 Min - Budgetaufteilungs-Vorschlag - Dana - 10 Min **Zeitplan** | Zeit | Min | Punkt | Verantwortlicher | Ergebnis | |---|---|---|---|---| | 14:00-14:05 | 5 | Begrüßung und Ziele für heute | Dana | informieren | | 14:05-14:15 | 10 | Q4-Budgetaufteilung genehmigen (Vorschlag Montag gesendet) | Dana | entscheiden | | 14:15-14:40 | 25 | Q4-Prioritäten: Top-3-Initiativen auswählen | Lee | entscheiden | | 14:40-14:50 | 10 | Einstellungsplan für Q4: zustimmen, welche Rollen zu eröffnen sind | Priya | diskutieren | | 14:50-14:55 | 5 | Nächste Schritte, Verantwortliche und Parkplatz | Dana | informieren | | 14:55-15:00 | 5 | Puffer | | | **Wie wir heute entscheiden:** Dana entscheidet das Budget nach Input; die Top 3 wird per Zustimmung gewählt (irgendein starker Einwand?). **Moderations-Tipps** - Prioritäten: 3 Minuten stilles Punktabstimmung auf der Kandidatenliste, dann nur die auf Rang 2 bis 5 platzierten Punkte diskutieren. - Wenn der Budgetpunkt 10 Minuten erreicht, den offenen Punkt mit einem Verantwortlichen und einer 24-Stunden-Frist parken, statt in die Prioritäten zu fressen. **Aus diesem Meeting verschoben:** Team-Statusrunde und Kundenservice-Feedback (Vorab-Lektüre). ### Warum das eine gute Antwort ist - Es korrigiert den Zweck und die Reihenfolge, nicht nur die Minuten. - Beide erforderlichen Entscheidungen finden jetzt in den ersten 40 Minuten statt, mit vorbereiteten Vorschlägen. - Das Skript bestätigt die Passung, und die Personen, die nur für Updates da waren, bekommen ihre Stunde zurück. ## Python-Skript: timebox_agenda.py ```python #!/usr/bin/env python3 """Zeitboxen Sie eine Meeting-Agenda: Planen Sie jeden Punkt ein, prüfen Sie die Passung und kennzeichnen Sie Agenda-Probleme. Verwendung: python3 timebox_agenda.py agenda.txt python3 timebox_agenda.py agenda.txt --fit # Punkte skalieren, um in den Zeitrahmen zu passen (5-Minuten-Schritte) python3 timebox_agenda.py agenda.json --json cat agenda.txt | python3 timebox_agenda.py - Texteingabe: optionale "Schlüssel: Wert"-Kopfzeilen, dann ein Punkt pro Zeile als Minuten | Thema | Verantwortlicher | Ergebnis Markdown-Tabellenzeilen (| 10 | Thema | Verantwortlicher | entscheiden |) funktionieren auch; Kopf- und Trennzeilen werden übersprungen. Verwenden Sie ? für eine unbekannte Dauer. Kopfzeilen-Schlüssel: Meeting, Start (HH:MM), Length (Minuten) oder End (HH:MM), Buffer (Minuten oder Prozent, z.B. 5 oder 10%), Attendees (Anzahl). Ergebnisse: informieren, aktualisieren, diskutieren, brainstormen, überprüfen, entscheiden, Pause. JSON-Eingabe: {"meeting": "...", "start": "14:00", "length": 60, "buffer": 5, "attendees": 8, "items": [{"minutes": 10, "topic": "...", "owner": "...", "outcome": "decide"}]} --fit kürzt zuerst Status-Punkte (und Punkte ohne Ergebnis), skaliert dann alles; überschüssige Zeit geht an entscheiden- und diskutieren-Punkte. Prüfungen: Überziehung (HIGH), fehlende Dauern, Verantwortliche oder Ergebnisse, späte oder überstürzte Entscheidungen, übergroße Punkte, lange Strecken ohne Pause, zu viele Status-Updates, zu viele Punkte pro Stunde, plus die Meeting-Kosten in Personenstunden. Exit-Code: 0 keine HIGH-Ergebnisse, 1 HIGH gefunden, 2 Verwendungs- oder Eingabefehler. Nur Standardbibliothek. """ import argparse import json import math import re import sys OUTCOMES = {"informieren", "aktualisieren", "diskutieren", "brainstormen", "überprüfen", "entscheiden", "Pause"} ALIASES = {"decision": "entscheiden", "info": "informieren", "fyi": "informieren", "status": "aktualisieren", "updates": "aktualisieren", "discussion": "diskutieren", "ideas": "brainstormen", "ideation": "brainstormen", "feedback": "überprüfen", "approve": "entscheiden", "approval": "entscheiden", "pause": "Pause", "coffee": "Pause"} class InputError(Exception): pass def hhmm(text): m = re.fullmatch(r"\s*(\d{1,2})[:.](\d{2})\s*", str(text)) if not m or int(m.group(1)) > 23 or int(m.group(2)) > 59: raise InputError(f"Zeit muss HH:MM sein, erhalten {text!r}") return int(m.group(1)) * 60 + int(m.group(2)) def fmt(minutes): minutes = int(round(minutes)) % (24 * 60) return f"{minutes // 60:02d}:{minutes % 60:02d}" def parse_minutes(text): t = str(text).strip().lower() if t in ("", "?", "tbd", "-"): return None m = re.fullmatch(r"(\d+(?:\.\d+)?)\s*(m|min|mins|minutes?)?", t) if m: return float(m.group(1)) m = re.fullmatch(r"(\d+(?:\.\d+)?)\s*h(?:ours?)?(?:\s*(\d+)\s*m(?:in)?)?", t) if m: return float(m.group(1)) * 60 + float(m.group(2) or 0) raise InputError(f"Dauer {text!r} kann nicht gelesen werden") def norm_outcome(text): t = (text or "").strip().lower() return ALIASES.get(t, t) def parse_text(text): meta, items, errors = {}, [], [] for no, raw in enumerate(text.replace("\r\n", "\n").split("\n"), 1): line = raw.strip() if not line or line.startswith("#"): continue hm = re.fullmatch(r"([A-Za-z ]{3,20}):\s*(.+)", line) if hm and "|" not in line: meta[hm.group(1).strip().lower()] = hm.group(2).strip() continue if "|" not in line: errors.append(f"Zeile {no}: erwartet 'Minuten | Thema | Verantwortlicher | Ergebnis', erhalten {line[:60]!r}") continue cells = [c.strip() for c in line.strip("|").split("|")] if all(re.fullmatch(r":?-{2,}:?", c) for c in cells if c): continue if cells and cells[0].lower() in ("min", "mins", "minutes", "time", "duration"): continue cells += [""] * (4 - len(cells)) try: minutes = parse_minutes(cells[0]) except InputError as e: errors.append(f"Zeile {no}: {e}") continue if not cells[1]: errors.append(f"Zeile {no}: Punkt hat kein Thema") continue items.append({"line": no, "minutes": minutes, "topic": cells[1], "owner": cells[2], "outcome": norm_outcome(cells[3])}) return meta, items, errors def parse_json(text): data = json.loads(text) if not isinstance(data, dict) or not isinstance(data.get("items"), list): raise InputError("JSON-Eingabe braucht ein Objekt mit einer 'items'-Liste") meta = {k.lower(): str(v) for k, v in data.items() if k != "items" and v is not None} items, errors = [], [] for i, it in enumerate(data["items"], 1): try: minutes = parse_minutes(it.get("minutes", "")) except InputError as e: errors.append(f"Punkt {i}: {e}") continue if not str(it.get("topic", "")).strip(): errors.append(f"Punkt {i}: Punkt hat kein Thema") continue items.append({"line": i, "minutes": minutes, "topic": str(it["topic"]).strip(), "owner": str(it.get("owner", "") or "").strip(), "outcome": norm_outcome(it.get("outcome", ""))}) return meta, items, errors def settings(meta): start = hhmm(meta.get("start", "09:00")) if "length" in meta: length = parse_minutes(meta["length"]) if not length or length <= 0: raise InputError("Length muss eine positive Anzahl von Minuten sein") elif "end" in meta: length = (hhmm(meta["end"]) - start) % (24 * 60) if length == 0: raise InputError("End muss nach Start liegen") else: raise InputError("Kopfzeile braucht 'Length: <Minuten>' oder 'End: HH:MM'") b = meta.get("buffer", "0").strip() if b.endswith("%"): buffer = 5 * round(length * float(b[:-1]) / 100 / 5) # Prozent-Puffer runden auf 5 Minuten else: buffer = parse_minutes(b) or 0 if buffer >= length: raise InputError("Buffer muss kürzer als das Meeting sein") attendees = int(meta["attendees"]) if str(meta.get("attendees", "")).strip().isdigit() else None return {"meeting": meta.get("meeting", meta.get("title", "Meeting")), "start": start, "length": length, "buffer": buffer, "available": length - buffer, "attendees": attendees} def fit(items, available): """Punkte in `available` Minuten in 5-Minuten-Schritten einpassen (fehlende Dauern zählen als 10, Pausen bleiben). Wenn die Agenda zu lang ist, werden Status-Punkte (informieren, aktualisieren oder ohne Ergebnis) zuerst gekürzt, bis auf die Hälfte ihrer geplanten Zeit; dann wird jeder Punkt proportional skaliert. Wenn sie zu kurz ist, geht die überschüssige Zeit zuerst an entscheiden- und diskutieren-Punkte. """ fixed = sum(it["minutes"] or 0 for it in items if it["outcome"] == "Pause") flex = [it for it in items if it["outcome"] != "Pause"] room = available - fixed if not flex or room < 5 * len(flex): raise InputError(f"{len(flex)} Punkte können nicht in {room:g} Minuten mit mindestens 5 Minuten pro Punkt eingepasst werden") want = [max(5, 5 * round((it["minutes"] or 10) / 5)) for it in flex] cur = list(want) status = [i for i, it in enumerate(flex) if it["outcome"] in ("informieren", "aktualisieren", "")] while sum(cur) > room: cands = [i for i in status if cur[i] - 5 >= max(5, want[i] / 2)] if not cands: break cur[max(cands, key=lambda k: cur[k])] -= 5 if sum(cur) > room: scale = room / sum(cur) ref = [c * scale for c in cur] cur = [max(5, 5 * round(r / 5)) for r in ref] while sum(cur) > room: cands = [k for k in range(len(cur)) if cur[k] > 5] cur[max(cands, key=lambda k: (cur[k] - ref[k], cur[k]))] -= 5 while sum(cur) + 5 <= room: cur[min(range(len(cur)), key=lambda k: cur[k] - ref[k])] += 5 else: prio = [i for i, it in enumerate(flex) if it["outcome"] in ("entscheiden", "diskutieren")] or list(range(len(flex))) while sum(cur) + 5 <= room: cur[min(prio, key=lambda k: cur[k] / want[k])] += 5 out, it_new = [], iter(cur) for it in items: copy = dict(it) copy["original"] = it["minutes"] if it["outcome"] != "Pause": copy["minutes"] = float(next(it_new)) out.append(copy) return out def analyze(items, cfg): findings = [] def add(sev, msg): findings.append({"severity": sev, "message": msg}) t = cfg["start"] for it in items: it["start"] = t t += it["minutes"] or 0 it["end"] = t planned = sum(it["minutes"] or 0 for it in items) avail, end_slot = cfg["available"], cfg["start"] + cfg["length"] unknown = [it for it in items if it["minutes"] is None] if planned > avail: add("HIGH", f"Agenda braucht {planned:g} Min, aber nur {avail:g} Min sind verfügbar" f"{' nach dem ' + format(cfg['buffer'], 'g') + '-Min-Puffer' if cfg['buffer'] else ''}: Überziehung von {planned - avail:g} Min" f" (endet {fmt(cfg['start'] + planned)} statt {fmt(end_slot - cfg['buffer'])}). Streichen, kürzen oder verschieben Sie Punkte, oder führen Sie mit --fit aus.") elif avail - planned > 0.15 * avail and not unknown: add("INFO", f"{avail - planned:g} Min ungeplant; früher enden oder der Hauptentscheidung mehr Zeit geben.") if unknown: add("WARN", f"{len(unknown)} Punkt(e) ohne Dauer: " + "; ".join(it["topic"][:40] for it in unknown) + f". Verbleibende Zeit dafür: {max(avail - planned, 0):g} Min.") for it in items: name = f"\"{it['topic'][:50]}\"" if it["outcome"] != "Pause" and not it["owner"]: add("WARN", f"{name} hat keinen Verantwortlichen; benennen Sie, wer es vorbereitet und leitet.") if not it["outcome"]: add("WARN", f"{name} hat kein Ergebnis; sagen Sie, ob es zu informieren, diskutieren, entscheiden oder brainstormen ist.") elif it["outcome"] not in OUTCOMES: add("WARN", f"{name} hat unbekanntes Ergebnis '{it['outcome']}' (verwenden: {', '.join(sorted(OUTCOMES))}).") m = it["minutes"] or 0 if it["outcome"] == "entscheiden": if it["minutes"] is not None and m < 10: add("WARN", f"{name} ist eine Entscheidung mit nur {m:g} Min; planen Sie mindestens 10, oder entscheiden Sie durch einen schriftlichen Vorschlag im Voraus.") if it["start"] - cfg["start"] >= 0.75 * cfg["length"]: add("WARN", f"{name} ist eine Entscheidung, die um {fmt(it['start'])} beginnt, im letzten Viertel des Meetings; verschieben Sie sie früher, während Energie und Anwesenheit hoch sind.") if it["outcome"] in ("diskutieren", "brainstormen", "überprüfen") and it["minutes"] is not None and m < 5: add("WARN", f"{name} ist ein {it['outcome']}-Punkt mit {m:g} Min; das ist eine Erwähnung, kein {it['outcome']}.") if m > 45 and it["outcome"] != "Pause": add("WARN", f"{name} ist {m:g} Min lang; teilen Sie ihn in Teile mit eigenen Ergebnissen.") stretch, stretch_start = 0, cfg["start"] for it in items: if it["outcome"] == "Pause": stretch, stretch_start = 0, it["end"] continue stretch += it["minutes"] or 0 if stretch > 90: add("WARN", f"{stretch:g} Min ohne Pause ab {fmt(stretch_start)}; fügen Sie etwa alle 60 bis 90 Min eine 5 bis 10 Min Pause ein.") stretch = -10**9 status = sum(it["minutes"] or 0 for it in items if it["outcome"] in ("informieren", "aktualisieren")) if planned and status / planned > 0.35: add("WARN", f"Status-Updates und Ankündigungen nehmen {round(100 * status / planned)}% der Zeit ein; senden Sie sie als Vorab-Lektüre und behalten Sie das Meeting für Diskussion und Entscheidungen.") work_items = [it for it in items if it["outcome"] != "Pause"] hours = cfg["length"] / 60 if hours and len(work_items) / hours > 8: add("WARN", f"{len(work_items)} Punkte in {cfg['length']:g} Min sind mehr als 8 pro Stunde; Punkte zusammenlegen oder streichen.") if not any(it["outcome"] == "entscheiden" for it in items): add("INFO", "Keine Entscheidungspunkte; prüfen Sie, ob dieses Meeting live stattfinden muss.") cost = None if cfg["attendees"]: cost = round(cfg["attendees"] * cfg["length"] / 60, 1) add("INFO", f"Meeting-Kosten: {cfg['attendees']} Personen x {cfg['length']:g} Min = {cost:g} Personenstunden.") order = {"HIGH": 0, "WARN": 1, "INFO": 2} findings.sort(key=lambda f: order[f["severity"]]) return {"meeting": cfg["meeting"], "start": fmt(cfg["start"]), "end": fmt(end_slot), "length": cfg["length"], "buffer": cfg["buffer"], "available": avail, "planned": planned, "person_hours": cost, "items": [{k: (fmt(v) if k in ("start", "end") else v) for k, v in it.items()} for it in items], "findings": findings} def main(): ap = argparse.ArgumentParser(description="Zeitboxen Sie eine Meeting-Agenda") ap.add_argument("path", help="Agenda-Text/Markdown/JSON-Datei, oder - für stdin") ap.add_argument("--fit", action="store_true", help="Punktdauern skalieren, um in die verfügbare Zeit zu passen") ap.add_argument("--json", action="store_true") args = ap.parse_args() try: text = sys.stdin.read() if args.path == "-" else open(args.path, encoding="utf-8").read() if not text.strip(): raise InputError("Eingabe ist leer") meta, items, errors = parse_json(text) if text.lstrip().startswith("{") else parse_text(text) if errors: raise InputError("Agenda konnte nicht gelesen werden:\n " + "\n ".join(errors)) if not items: raise InputError("Keine Agenda-Punkte gefunden (erwartet Zeilen wie '10 | Thema | Verantwortlicher | entscheiden')") cfg = settings(meta) before = sum(it["minutes"] or 0 for it in items) n_unknown = sum(1 for it in items if it["minutes"] is None) if args.fit: items = fit(items, cfg["available"]) except FileNotFoundError: print(f"Fehler: Datei nicht gefunden: {args.path}", file=sys.stderr) return 2 except (InputError, json.JSONDecodeError, ValueError) as e: print(f"Fehler: {e}", file=sys.stderr) return 2 rep = analyze(items, cfg) rep["fitted_from"] = before if args.fit else None if args.json: print(json.dumps(rep, indent=2)) else: print(f"{rep['meeting']}: {rep['start']}-{rep['end']} ({rep['length']:g} Min, Puffer {rep['buffer']:g} Min, {rep['available']:g} Min für Punkte)") if args.fit: extra = f" plus {n_unknown} ohne Dauer (als je 10 Min gezählt)" if n_unknown else "" print(f"Eingepasst: {before:g} Min Punkte{extra} eingepasst in {rep['planned']:g} Min (5-Minuten-Schritte, Pausen bleiben).") print(f"Geplant: {rep['planned']:g} Min\n") for it in rep["items"]: mins = "?" if it["minutes"] is None else f"{it['minutes']:g}" was = f" (war {it['original']:g})" if args.fit and it.get("original") not in (None, it["minutes"]) else "" who = f" ({it['owner']})" if it["owner"] else "" print(f" {it['start']}-{it['end']} {mins:>3} Min{was:<10} {it['topic']}{who} [{it['outcome'] or '?'}]") if rep["buffer"]: print(f" {fmt(hhmm(rep['end']) - rep['buffer'])}-{rep['end']} {rep['buffer']:>3g} Min Puffer / Abschluss") print() if rep["findings"]: print("Ergebnisse:") for f in rep["findings"]: print(f"- [{f['severity']}] {f['message']}") else: print("Ergebnisse: keine") return 1 if any(f["severity"] == "HIGH" for f in rep["findings"]) else 0 if __name__ == "__main__": sys.exit(main()) ```