samber/dev-event-organizer-skills / skills/event-registration-forecast
event-registration-forecast
VerifiedForecast final registrations for a technical event from its sign-up pace curve, with a bundled Python 3 script, while registration is still open - prior-edition or generic reference curves aligned on days-out, a low/mid/high band, milestone tripwires declared in advance, the commit figure at each contract lock date, when the forecast crosses capacity, and attendance by ticket type. Use whenever asked how many people will end up registering or attending, to project this year from last year's curve, what headcount to commit before sign-ups close, or when registration will hit its cap. Do NOT use for the demand verdict - use samber/dev-event-organizer-skills@event-market-fit - or overbooking ratios and food counts once sign-ups close - use samber/dev-event-organizer-skills@event-no-show-management.
| File | Kind | Size |
|---|---|---|
| SKILL.md | skill md | 20.2 KB |
| assets/curve-free-hackathon-target.csv | other | 63 B |
| assets/curve-pooled-lead-time.csv | other | 80 B |
| assets/ticket-types-example.csv | other | 183 B |
| evals/evals.json | config | 49.0 KB |
| references/attendance-by-ticket-type.md | markdown | 2.6 KB |
| references/lock-dates-and-commit-rules.md | markdown | 5.0 KB |
| references/reference-curves.md | markdown | 4.6 KB |
| references/worked-forecast.md | markdown | 4.4 KB |
| scripts/forecast-registrations.py | script | 17.4 KB |
evals/evals.json
View on GitHub{
"skill_name": "event-registration-forecast",
"evals": [
{
"id": 1,
"prompt": "Gearshift Conf is a paid two-day conference, second edition, in a 450-seat hall, 40 days from now. Our ticketing export this morning says 210 registrations, but that includes the 35 speaker and sponsor codes we issued. Last year's weekly export (days out: cumulative, already net of codes) reads 120:18, 90:40, 60:105, 50:150, 42:175, 30:250, 14:370, 7:420, 0:480. This year so far: 120:22, 90:50, 60:118, 40:210 (the 210 includes the 35 codes). Early-bird closed at 50 days out last year; this year we closed it at 42 days out. Ticket mix is about 85% standard and 15% student. Comps this year: 40 speakers, 30 sponsor staff. The caterer wants our headcount guarantee at 7 days out and can add up to 10% until 48 hours before. My co-organizer did the maths: 210 tickets in 80 days of sales, 40 days left, so roughly 105 more, call it 315, and wants to give the caterer 315 tomorrow so it's off the list. Can you confirm that number or give me a better one?",
"expected_output": "A forecast sheet that nets the 35 codes out to 175 registrations, rejects the 315 straight line, aligns both editions on days-out, runs last edition unshifted and shifted eight days plus the pooled generic curve through the bundled script with multiplicative pickup, reports a low / mid / high band built from single-reference extremes (roughly 375 / 450 / 540), and gives the caterer a provisional high-end attendance figure divided by 1.10 with the reason written beside it, to be re-run on the lock date rather than handed over tomorrow.",
"files": [],
"expectations": [
"The straight-line projection (210 in 80 days, 105 more, 315 final) is rejected as a method, with the reason that registration curves are back-loaded toward doors",
"The 35 speaker and sponsor codes are removed from the 210 before any projection; the working count is 175 registrations net of comps",
"This year and last year are aligned on days-out, never on calendar dates",
"Last edition is run twice as a reference: unshifted and shifted so its early-bird spike sits on this year's 42-days-out close (a shift of 8 days)",
"The pooled lead-time generic curve is run as an additional reference, so at least two distinct references feed the band",
"Multiplicative pickup is named as the projection method, justified by more than 15% of the reference curve being in at 40 days out",
"The band's low and high ends are each a single reference's projection (the lowest and the highest); no average across references is used as a band end",
"The mid is stated to be the median across references, with a note that the shifted and unshifted runs of last edition count twice in that median",
"The catering commit is taken from the high end of the band, with the written reason that running short costs more than spare covers",
"The catering commit is high-end expected attendance divided by 1.10, with the 10% flex explicitly kept back for a late surge",
"The catering figure is labelled provisional, the forecast is to be re-run on the 7-day lock date itself with that run's figure as the commitment, and the request to hand a number over tomorrow is declined",
"The catering figure is expressed as expected attendance (registrations times a show rate per ticket type, plus comps expected to attend), never as a registration count",
"The 40 speaker and 30 sponsor comps re-enter only at the attendance stage, as count-basis ticket types with their own labelled show rates",
"The method is named as booking-curve (pickup) forecasting borrowed from hotel and airline revenue management, with the note that no event-specific forecasting method is established",
"The forecast is produced by running the bundled script (a command with --actuals, at least two --reference inputs, a --checkpoint for the 7-day catering lock and --types is shown), not by hand arithmetic"
]
},
{
"id": 2,
"prompt": "Lumen Devs Day is a free one-day community conference, first edition, in a 350-seat auditorium 32 days from now. We opened sign-ups seven weeks ago and have 80 registrations. We told sponsors to expect 400 attendees. My co-organizer read an organizer guide saying a conference should have 40-50% of its final sales a month out; we're at 20% of target, so she wants to either cancel or move the whole thing online this week. The venue's cancellation fee rises to 60% from 21 days out. The caterer's headcount guarantee is due 5 days out. We know the organizer of a free DevOps day in a neighbouring city who finished at 500 last spring and would probably share their numbers if asked. What's our realistic final, and what do we tell the venue and caterer?",
"expected_output": "A forecast that refuses to apply the paid-conference one-month checkpoint to a free event, explains that free registrants sign up late so the pooled curve forms the low end, labels the single-reference result a point guess, recommends obtaining the neighbouring organizer's curve as a comparable-event reference before the catering lock, converts to attendance with sourced free show rates and their scope, declares the next milestone's expected count now, and hands the cancel and move-online questions to the demand and go/no-go skills instead of answering them.",
"files": [],
"expectations": [
"The 40-50%-at-one-month checkpoint is identified as a paid-conference ladder and is not applied as the benchmark for this free event",
"States that free-event registrants sign up late (median lead time about 16 days, against about 41 days for paid events), so a free event looks behind a pooled or paid curve until the last two weeks",
"No go, hold, pivot, stop or cancel verdict is issued; the demand question is routed to event-market-fit with the forecast as its input",
"The move-online decision is not made here; the go/no-go review is routed to event-risk-management with the forecast and a registration threshold fixed before the review",
"The pooled lead-time curve is used as a reference and is placed as the low end for this free event, with the reason that it expects more on hand early than a free event delivers",
"The free-hackathon target timeline is not used as a reference for this non-hackathon event",
"With a single usable reference and no past forecast error, the projection is labelled a point guess with no band, and a second reference is called for before the catering lock",
"Obtaining the neighbouring free DevOps day's curve is recommended as a comparable-event reference, justified by the first-edition, imminent-lock-date, peer-reachable condition",
"Free show rates are given with their scope (an attributed industry band of 40-60% and a platform median of about 72%) and are either run as band ends or chosen by population match; no single unsourced free show rate is applied",
"Capacity is read on expected attendance against the 350 seats, not on registrations",
"An expected on-hand registration figure or range is declared now for a named upcoming milestone such as 14 days out, before that reading arrives",
"The default tripwire response is a push brief handed to event-marketing-plan carrying the registration gap, the milestone to close it by, and the segment furthest behind",
"The catering number is given as provisional expected attendance to be re-run on the 5-day lock date, not committed from today's reading",
"Today's forecast is recorded unedited so the final can be compared against it for next edition's error band"
]
},
{
"id": 3,
"prompt": "ByteForge Hack is a free 36-hour student hackathon, first edition, 20 days out. 310 registered so far, our goal is 500 participants on site, the venue holds 600 people, and registration closes 7 days before the start because our partner network requires it. We have 40 mentors and 15 organizers on top of participants. Food for every meal slot has to be ordered 4 days before. I found a hotel-booking-style chart that says events should be at roughly 65-70% of final sign-ups 20 days out, which would put us around 450 final, well under goal. My co-organizer says students are keen and 90% of registrants will show, so we only need about 550 registrations. When do we open a waitlist, and how much food do we order?",
"expected_output": "A forecast that runs the free-hackathon target timeline (labelled target-shaped) and the pooled curve as two separate references, rejects the 90% show assumption in favour of the roughly 50% free-hackathon show rate, distinguishes registrations at close (about double the attendance goal) from attendance, takes the registration ceiling from the no-show skill and passes it as --ceiling to get the waitlist date per reference, reads the 600 capacity on attendance including mentors and organizers, commits food at the high end in attendance terms, and notes that once registration closes the food count belongs to the no-show skill.",
"files": [],
"expectations": [
"The free-hackathon target timeline is used as a reference and explicitly labelled target-shaped (an organizer-guide plan, not observed sign-up data)",
"The pooled lead-time curve is also run as the observed reference; the target timeline is never used alone",
"The two generic curves are not averaged into one; each is its own reference and their spread forms the band",
"The 90% show assumption is rejected; a free-hackathon show rate of about 50% is cited with its scope (an organizer-guide trendline across several hundred events)",
"Registrations are converted to attendance with a free show rate, never a paid one",
"Registrations at close are distinguished from the attendance goal and sized at roughly double it under a 50% show rate (about 1,000 registrations for 500 on site)",
"The registration ceiling is not set here; it is taken from event-no-show-management and passed to the script as --ceiling",
"The waitlist opening date is given as the days-out at which each reference reaches the ceiling, not as the moment registrations hit 600",
"Capacity (600) is compared against expected attendance including mentors and organizers as count-basis comps, not against registrations",
"Once the ceiling binds, the response says to stop forecasting registrations and forecast the waitlist instead",
"The food commit at 4 days out is taken from the high end in attendance terms, with the written reason that running short costs more than spare food",
"Notes that the target curve reaches 100% at 7 days out because registration closes then, so the 20-day reading is read against that compressed timeline",
"The script is invoked with both the target-timeline CSV and the pooled-curve CSV as --reference inputs",
"States that once registration closes the count is known and the final food number belongs to event-no-show-management"
]
},
{
"id": 4,
"prompt": "Kernelwright Summit, third edition, two days, 38 days out. We release tickets in batches of 50 to create urgency and every batch has sold out within a day. Last week we announced the keynote and sold 95 tickets in seven days against roughly 20 a week before that; we're now at 260 net of comps. My co-organizer wants to project 95 a week forward and tell the board we'll pass 700. Marketing wants to extend the early-bird by two weeks and push a secret 20% code to our newsletter to keep the momentum, because this week is already slower. We have both prior editions' daily exports: 2024 finished at 410 with the keynote announced 50 days out, 2025 finished at 480 with the keynote announced 45 days out. The hotel block rate code expires at 30 days out, carries an 80% usage guarantee, two nights offered, and the hotel said they can probably add rooms if we need. About 45% of last year's attendees came from out of town. What do we tell the board and the hotel?",
"expected_output": "A forecast that refuses to extrapolate the keynote spike, re-runs as-of the last pre-spike reading, annotates the spike and the batch releases, refuses the early-bird extension and the secret code as price moves owned elsewhere, runs both prior editions as separate references shifted onto this year's announcement date with the older one flagged for drift, commits the hotel block at the low end as room-nights from attendance with two nights and no post-event night, conditions later growth on written confirmation, and routes demand and push questions to their owners.",
"files": [],
"expectations": [
"The 95-a-week keynote spike is not projected forward; the forecast is also run --as-of the last reading before the spike and reported beside the latest reading",
"The keynote announcement week is annotated on the readings as an event, not treated as a new run rate",
"Warns that the quieter week after the spike will read as collapse if the spike is taken as the baseline",
"The batch-of-50 releases are flagged as manufacturing sellouts and distorting the real curve",
"Extending the early-bird is refused here, with price dates assigned to event-ticket-pricing",
"The secret 20% code is refused as a forecast rescue, with the reason that it trains buyers to wait for the next rescue",
"Both prior editions are run as separate references with the 2025 edition preferred, and the 2024 edition is flagged for booking-window drift",
"Each prior edition is aligned on days-out and shifted so its keynote-announcement spike sits on this year's announcement date, with a different shift for 2024 and 2025",
"The hotel block is committed at the low end, with the written reason that over-committing costs more under an 80% usage guarantee",
"Growing the block later is conditioned on the hotel confirming in writing that rooms can be added at the group rate; 'we can probably add rooms' is not accepted as that confirmation",
"Room-nights are computed as expected attendance times the 45% out-of-town share times nights per guest divided by guests per room, with each input labelled own-data or self-set",
"Nights per guest for the two-day event are the night before day one and the night between the days, never the night after the last day",
"The tripwire response if the low end runs short is a push brief to event-marketing-plan, with the push to be marked on the curve so next edition does not read it as organic",
"No demand verdict is issued; the 700 claim is replaced by a band and any demand question is routed to event-market-fit"
]
},
{
"id": 5,
"prompt": "Portcullis DevCon, second edition, 45 days out, 300 registrations net of comps. Last year's weekly export is on disk (final 520). Break-even is 380 registrations. The venue's cancellation fee steps from 50% to 75% at 30 days out, and our board meets at 32 days out. Our budget has three tiers: Good works at 380, Better at 450, Best at 550. Badge printing locks at 12 days out, and the 45 speakers and 30 sponsor staff get badges too. The board chair wants one number for the final, which tier to lock now, and whether we cancel if that number is under 380. Give me what I bring to the meeting.",
"expected_output": "A band instead of one number, the tier the low end funds, a go/no-go hand-off to the risk skill with the 380 threshold fixed before the review and which band end clears it, a badge commit at high-end registrations plus 75 comps, a lock-date table with band end and reason on every row, a declared on-hand range for the 32-day board date, and the demand question routed to the market-fit skill.",
"files": [],
"expectations": [
"The request for one number is declined; a low / mid / high band net of comps is delivered",
"The budget tier to lock is the one the low end funds; the mid is explicitly not used to pick the tier",
"The cancel question is not answered here; the go/no-go review is routed to event-risk-management with the 380 threshold, the band at the review date, and which end clears it",
"The 380 threshold is stated as fixed before the reading at the review, not adjusted to the reading",
"The venue cancellation-fee step is not committed via the newsvendor rule; the go/no-go poll decides it",
"A miss on the registration criterion alone is described as an input to the poll, not a cancellation",
"Go/no-go escalation is promoted only if the mid misses 380 at the review preceding the 30-day fee step; otherwise the default response is a push brief",
"The badge print commit is taken from high-end registrations plus the 75 comps, with the reason that running short costs more",
"Every commit figure in the lock-date table carries its band end and a written reason",
"The demand question (whether the event is wanted) is routed to event-market-fit, not answered",
"Last edition's export is the default reference, with the pooled generic curve run as a second reference",
"An expected on-hand registration range at the 32-day board date is declared now, before that reading",
"The script is run with --threshold 380 and --checkpoint entries for the board date and the badge lock",
"Each commit is labelled provisional, with a re-run on the lock date itself"
]
},
{
"id": 6,
"prompt": "Signalhaus Conf is a two-day paid conference. Our latest forecast band for final registrations net of comps is 420 / 480 / 560. Sold mix: 70% standard, 20% student, 10% group tickets bought by employers. Comps: 45 speakers, 60 sponsor staff passes allotted (last year 44 of 60 were claimed and 31 badges were collected), 25 volunteers. Last year: 505 registrations net of comps, 455 badges scanned on day one including 52 comps; we didn't scan day two. The caterer needs day-one and day-two lunch numbers. My co-organizer's plan: apply 85% across the board, drop the last-two-weeks buyers to 60% because latecomers flake, add 10% walk-ins because every conference gets them, and give the caterer the same number for both days. Produce the attendance numbers.",
"expected_output": "A per-type attendance table built through the script's types file: own show rate of about 80% computed on a comps-consistent basis, sponsor staff from claimed and collected passes, group tickets at the paid rate labelled hypothesis, speakers and volunteers self-set, late registrants not discounted, walk-ins unknown without a prior count, day one delivered as a low / mid / high attendance range, day two stated unknown, and day-one attendance handed to the attendee-experience skill for the desk.",
"files": [],
"expectations": [
"The blanket 85% is rejected; attendance is computed per ticket type as registrations times that type's show rate",
"The 60% rate for last-two-weeks buyers is rejected; late registrants are not discounted, with the reason that within one event the early-versus-late attendance gap is under one point",
"The 10% walk-in addition is rejected; walk-ins are forecast only from the organizer's own prior count and otherwise stated as unknown",
"Day-two attendance is stated as unknown because no day-two check-ins exist; day one is not copied to day two, and a later day-two guarantee or counting day-one check-ins first is proposed",
"Last edition's own show rate is computed on the same basis as the registrations: (455 minus 52) over 505, about 80%, with comps removed from the attended side",
"The sponsor-staff show rate is built from claimed and collected passes (31 of 60 allotted, or 31 of 44 claimed) and labelled own-data; the 60 allotment is not treated as 60 attending",
"Group and employer-bought tickets are treated at the paid rate until measured, with the label hypothesis",
"Every rate in the types table carries a label: sourced, own-data, self-set or hypothesis",
"Speaker and volunteer rates are labelled self-set, with the note that no published rate exists for them",
"The types file uses share basis for sold types (shares summing to 1) and count basis for speakers, sponsor staff and volunteers",
"The day-one catering number is delivered as a low / mid / high attendance range, not a single number and not a registration count",
"Day-one attendance is handed to event-attendee-experience for registration-desk sizing",
"Recommends measuring each self-set type at this edition's check-in so next edition carries own-data rates",
"The script's --types file is produced, or its command shown, rather than the per-type arithmetic being done by hand"
]
},
{
"id": 7,
"prompt": "Driftwood Rust Days, second edition. Last year we had 150 seats and finished at 180 registrations; this year we moved to a 400-seat venue and planned for 350. Sales opened ten days ago. We're 95 days out with 22 registrations; last year at 95 days out we had 9. My co-organizer says we're at 2.4x last year's pace, so 2.4 times 180 is 432, and wants to lock the top catering tier and sign a second hotel block this week while the rates are good. Early-bird closes in three weeks. Where do we actually stand?",
"expected_output": "A response that runs the script, reports that every reference yields only a bound or an unstable figure at 95 days out (under 15% of the curve in, this year at more than double the reference), says the forecast cannot be made yet, locks nothing, names the days-out at which a stable multiplicative read becomes possible, explains that multiplicative pickup carries the scale change while additive does not, and routes any on-track question to the demand skill.",
"files": [],
"expectations": [
"The 2.4x pace projection to about 432 is rejected; multiplicative pickup is called unstable because under 15% of the reference curve is in at 95 days out",
"The additive projection is reported only as a bound because this year runs at more than double the reference count at the same days-out, and it is kept out of the band",
"The response says the forecast cannot be made yet rather than presenting a band from these readings",
"No catering tier is locked and no second hotel block is signed on this reading; both are deferred to a later run",
"The launch-period reading is characterised as measuring reach, not demand, with the pace to be read from about week two of sales onward",
"States that the 150-to-400-seat scale change is carried by multiplicative pickup (the shape transfers across scale) but not by additive pickup",
"The script is still run with last edition's export and the pooled curve as references, and its bounds-only or no-usable-projection output is reported as-is",
"Names the days-out at which last edition's curve reaches 15% of its final as the earliest point a stable multiplicative read becomes possible",
"No demand verdict (ahead, behind, on track) is issued; any demand question is routed to event-market-fit",
"The comparison is made at matching days-out (95 against 95), not on calendar date or days since sales opened",
"Notes that with 9 reference registrations at this days-out, a single stray registration moves the multiplicative figure by several registrations",
"Today's reading and the no-forecast outcome are recorded unedited for the error record"
]
},
{
"id": 8,
"prompt": "Harrowgate API Days, paid, second edition, 25 days out, 400-seat hall. 372 paid registrations in; comps are separate, 30 speakers and 25 sponsor staff. Last year at 25 days out we had 300 and finished at 420. The venue has offered a 600-seat hall instead, and the option expires in 6 days. My co-organizer's plan: close registration at 400, then keep selling as overbooking since about 10% won't show, and since the forecast says 600, take the bigger hall. Tell me when to close registration and whether to take the room.",
"expected_output": "A capacity read on attendance including comps rather than on registrations, a paid close point of capacity minus comps expected to attend (about 350) that 372 already exceeds so the waitlist opens now, the overbooking ratio routed to the no-show skill, the larger-room decision flagged to the venue skill with the 6-day deadline because high-end attendance crosses 400, a --ceiling run giving the crossing days-out per reference, expected attendance shown against the 600-seat option, and registrations no longer read as demand once the cap binds.",
"files": [],
"expectations": [
"Capacity is read on expected attendance including the 55 comps, not on the 372 registrations",
"The paid registration close point is computed as room capacity minus comps expected to attend (about 400 minus 50), not 400",
"The response points out that 372 already exceeds that close point, so paid registration closes and the waitlist opens now rather than at 400",
"The overbooking proposal is not decided here; the ratio is routed to event-no-show-management and only applied per type for the attendance read",
"The larger-room decision is flagged to event-venue-sourcing with the 6-day option deadline, triggered by high-end attendance crossing the 400 capacity",
"The band is built from last edition's export and the pooled curve, and the high end is the figure compared against capacity",
"Once the cap binds, registrations are no longer read as demand; the waitlist is forecast instead",
"The script is run with --ceiling, and the days-out at which each reference reaches the ceiling is reported",
"The 'forecast says 600' claim is not accepted as given; expected attendance is shown explicitly against the 600-seat option",
"Comps are counted once, as count-basis types in the --types file, never inside the 372",
"Expected attendance by ticket type is delivered with each show rate labelled sourced, own-data or self-set",
"No demand verdict is issued",
"The 600-seat option expiry appears as a lock date in the lock-date table with its commit figure, band end and reason"
]
},
{
"id": 9,
"prompt": "Hollowmere DevFest is over. Final: 492 registrations net of comps, 418 attended of whom 36 were comps; 52 comps were registered. During the sale I ran the forecast at three milestones: at 60 days out mid 410 (band 360-470), at 30 days out mid 455 (band 420-500), at 14 days out mid 470 (band 450-495). This is our third edition and every year we've under-forecast: 2024 by 8%, 2025 by 6%, now 5%. I want to tidy the forecast sheet by replacing the old milestone numbers with corrected ones, and for next year average the 2024, 2025 and 2026 curves into one clean reference. What error band should I use next year?",
"expected_output": "A refusal to overwrite the milestone forecasts, signed error per milestone against the final (about -17%, -8%, -4.5%), the three-year same-sign miss named as bias to fix through reference choice rather than only a wider band, next year's --error-band taken from this year's error at the matching days-out, band coverage per milestone, a refusal to average editions into one curve with 2026 preferred and older ones flagged for drift, an own show rate of about 78% on a comps-consistent basis, and the full record kept for next edition.",
"files": [],
"expectations": [
"Overwriting the milestone forecasts is refused; each one is kept as it was made",
"Signed error is computed per milestone against the final 492: about -17% at 60 days, -8% at 30 days, -4.5% at 14 days, with the negative sign meaning under-forecast",
"Three editions of under-forecast with the same sign are named as bias, with the fix being the reference choice or alignment, not only a wider band",
"A scattered sign would instead be called noise, with the fix being to widen the band",
"Next year's --error-band is taken from this year's own recorded error at the matching days-out, not from a single global percentage",
"Averaging the three editions' curves into one reference is refused; each edition runs as its own reference",
"The 2026 edition is named the preferred reference, with the 2024 and 2025 editions flagged for booking-window drift",
"Band coverage is computed per milestone (492 outside the 60-day band, inside the 30-day and 14-day bands), with the note that a band that never misses is too wide to commit against",
"The own show rate is computed on the same basis as the registrations: (418 minus 36) over 492, about 78%, with comps removed from both sides",
"Attendance by ticket type against the check-in count is recommended so next edition's types file carries own-data rates",
"The reference set, each milestone forecast with its date, each commit figure with its band end, and the final are recorded, in persistent memory where the harness has one",
"Each milestone's forecast is compared to the final, never to a later forecast"
]
},
{
"id": 10,
"prompt": "Tidewater Cloud Summit, third edition, on 2026-12-10 this year; last year's was on 2025-12-03. I pulled both years as weekly rows by calendar date. This year's rows are gross (we haven't removed the 14 cancellations yet) and still include 28 speaker and sponsor codes; last year's export is net of refunds and codes. One of this year's weeks, the one with the national holiday, shows cumulative going from 161 to 158 because of refunds. My co-organizer wants to compare October 1st this year against October 1st last year and says we're 12% behind. Clean this up and tell me where we stand.",
"expected_output": "Cleaned readings on one refund basis with the 28 codes removed, converted to days-out with the one-week date move named, the holiday week annotated rather than adjusted, the falling cumulative fixed before the script will accept it, a pace index at matching days-out replacing the 12% calendar-date claim, last edition and the pooled curve run via --event-date, and the result delivered in the seven-section forecast sheet.",
"files": [],
"expectations": [
"The October-1-to-October-1 comparison is rejected; readings are converted to days before doors, with the one-week move of the event date named",
"The gross-versus-net mismatch is flagged, and one basis (gross or net of refunds) is held across both editions before any comparison",
"The 28 speaker and sponsor codes are removed from this year's counts before projection",
"The holiday week is annotated on the curve by name, not silently adjusted in the numbers",
"Every reading is annotated with what happened that week (holiday, announcement, early-bird, push) where known",
"The 161-to-158 fall is explained as inconsistent refund netting and fixed in the readings, citing that the script refuses a falling cumulative",
"Date-based CSVs are run with --event-date so the script converts dates to days-out",
"The 12%-behind claim is replaced by a pace index computed at matching days-out",
"Last edition and the pooled generic curve are both run as references",
"The band is reported net of comps",
"The forecast sheet follows the seven-section shape: readings, references and methods, band, lock-date table, milestone table, capacity read, attendance by type",
"The projection is produced by running the script rather than by hand arithmetic",
"Comps are recorded once in the --types file for the attendance step"
]
},
{
"id": 11,
"prompt": "Saltmarsh K8s Days, two days, second edition, 40 days out with 240 registrations net of comps. Last year's export: at 40 days out we had 230, final 470. The hotel's courtesy block cutoff is in 10 days: the rate code expires at 30 days out, there's an 80% usage guarantee, and they've offered three nights including the night after day two. Last year's postcodes say 55% of attendees came from out of town. The hotel hasn't said whether rooms can be added later. My co-organizer wants to block the mid for all three nights now so attendees get the rate, and lock it today. How many room-nights?",
"expected_output": "A provisional low-end room-night figure computed from expected attendance times 0.55 times two nights, with the post-event night dropped and guests per room at 1, the reason written beside it, later growth conditioned on written confirmation from the hotel, the 30-day rate-code expiry as the lock date to re-run on, a band from last edition plus the pooled curve via multiplicative pickup, and the expected on-hand range at 30 days declared now.",
"files": [],
"expectations": [
"The commit is taken from the low end, with the written reason that over-committing costs more under an 80% usage guarantee",
"The night after day two is dropped; nights per guest is 2 (the night before day one and the night between the days)",
"Room-nights are computed as expected attendance times 0.55 times 2 divided by guests per room, with guests per room set to 1 unless attendees demonstrably share",
"The formula uses expected attendance, not registrations",
"The mid is refused as the default commit; the band end is chosen by cost asymmetry and the reason is written next to the figure",
"Growing the block later is conditioned on written confirmation that rooms can be added at the group rate; its absence is flagged as leaving late attendees at rack rate",
"The figure given today is labelled provisional; the forecast is re-run on the cutoff date and that run's figure is the commitment",
"The rate-code expiry at 30 days out is listed as the lock date in the lock-date table",
"The band is built from last edition's export and the pooled curve as two separate references",
"Multiplicative pickup is used, justified by last edition having well over 15% of its final in at 40 days out",
"Each input (out-of-town share, nights per guest, guests per room) is labelled own-data or self-set",
"An expected on-hand registration range at the 30-day cutoff is declared now, before that reading"
]
}
],
"trigger_queries": [
{ "query": "We've sold 180 tickets with 50 days to go and last year ended at 520. Where will we land?", "should_trigger": true },
{ "query": "How many people will actually show up to our conference based on current sign-ups?", "should_trigger": true },
{ "query": "Project this year's registrations from last year's sign-up curve.", "should_trigger": true },
{ "query": "The caterer needs a headcount guarantee next Friday and registration is still open. What number do I give them?", "should_trigger": true },
{ "query": "Hotel block cutoff is in 10 days - how many room-nights should we keep?", "should_trigger": true },
{ "query": "When will our free meetup hit its 300-person cap at this pace?", "should_trigger": true },
{ "query": "Are we ahead or behind last year's ticket pace at the same point?", "should_trigger": true },
{ "query": "First edition, no history, 90 sign-ups six weeks out. How many will we end up with?", "should_trigger": true },
{ "query": "Give me a low/mid/high range for final attendance at our DevOps conference.", "should_trigger": true },
{ "query": "What should our registration count be at the early-bird close if we're going to hit 400?", "should_trigger": true },
{ "query": "Set checkpoints for ticket sales so we know early if we're going to miss the target.", "should_trigger": true },
{ "query": "How many of our 600 hackathon registrants will actually turn up?", "should_trigger": true },
{ "query": "We announced the keynote and sold 90 tickets in a week - does that mean we'll hit 700?", "should_trigger": true },
{ "query": "Convert our registration numbers into expected attendance per ticket type for catering.", "should_trigger": true },
{ "query": "Our badge print deadline is in 9 days. How many badges should we order with sales still open?", "should_trigger": true },
{ "query": "Expected final registrations for a two-day Rust conference given this pace?", "should_trigger": true },
{ "query": "Ticket sales look slow but we're still a month out. Is this normal or are we behind?", "should_trigger": true },
{ "query": "When should we open the waitlist for our free developer event?", "should_trigger": true },
{ "query": "Last year's export is on disk - use it to tell me what this year's final count will be.", "should_trigger": true },
{ "query": "Our venue cancellation fee jumps at 30 days. What registration number should we expect by then?", "should_trigger": true },
{ "query": "Forecast our ticket sales pace and tell me if we're on track against the curve.", "should_trigger": true },
{ "query": "I need a headcount to commit to the venue before sign-ups close.", "should_trigger": true },
{ "query": "How do I read our registration curve now that we're two weeks into sales?", "should_trigger": true },
{ "query": "Second edition, moved the early-bird close a week earlier - how do I compare this year to last year?", "should_trigger": true },
{ "query": "Student hackathon, free, registration closes a week before: how many to plan food for?", "should_trigger": true },
{ "query": "What's the realistic attendee count for the summit if we keep selling at this rate?", "should_trigger": true },
{ "query": "Tell me how many registrations we'll have on hand by the speaker announcement.", "should_trigger": true },
{ "query": "How big will the waitlist get for our sold-out meetup?", "should_trigger": true },
{ "query": "Build a sign-up forecast with a band, not just one number, for our board.", "should_trigger": true },
{ "query": "We're at 45% of target with three weeks left - will the last-minute rush cover it?", "should_trigger": true },
{ "query": "Expected show-up by ticket tier: paid, student, speaker comps, sponsor passes.", "should_trigger": true },
{ "query": "Our registrations plateaued after the early-bird deadline - is the event collapsing?", "should_trigger": true },
{ "query": "Estimate day-one and day-two attendance for our two-day conference.", "should_trigger": true },
{ "query": "What's the expected registration count at our go/no-go review date?", "should_trigger": true },
{ "query": "I have weekly registration counts for 2025 and 2026 - project the 2026 final.", "should_trigger": true },
{ "query": "What number do I lock with the caterer: registrations or expected attendees?", "should_trigger": true },
{ "query": "Should we commit to the bigger room? Depends how many people are coming.", "should_trigger": true },
{ "query": "Figure out whether we'll sell out before the larger-room option expires.", "should_trigger": true },
{ "query": "Our ticket sales always surge in the last two weeks; how do I forecast around that?", "should_trigger": true },
{ "query": "Run the numbers: 240 registered, 40 days out, prior edition finished at 470.", "should_trigger": true },
{ "query": "The swag order deadline is Monday - how many to order when sales are still open?", "should_trigger": true },
{ "query": "Set tripwires on registrations so we know when to escalate.", "should_trigger": true },
{ "query": "What error margin should I put on this year's attendance forecast from last year's misses?", "should_trigger": true },
{ "query": "How many will register for our free conference if 120 have signed up five weeks out?", "should_trigger": true },
{ "query": "Compare our sign-up pace to a generic conference booking curve.", "should_trigger": true },
{ "query": "Give the board a projected final registration count with the assumptions listed.", "should_trigger": true },
{ "query": "Predict final ticket sales for a 350-seat developer conference.", "should_trigger": true },
{ "query": "How many room-nights to block if 40% of our attendees travel in?", "should_trigger": true },
{ "query": "We're reading registrations weekly - what should each week's count look like if we're on track?", "should_trigger": true },
{ "query": "I want to know by what date we cross 500 registrations at this pace.", "should_trigger": true },
{ "query": "Help me plan catering quantities from the sign-up trend while registration is open.", "should_trigger": true },
{ "query": "Registration pace check for our devcon: 310 in, 28 days out, target 600.", "should_trigger": true },
{ "query": "Turn our ticketing export into an end-of-sales projection.", "should_trigger": true },
{ "query": "How much of our final attendance usually registers in the last week, and what does that mean for our number now?", "should_trigger": true },
{ "query": "Which number do I give the venue by the 30-day deadline, given uncertainty in sales?", "should_trigger": true },
{ "query": "Are our hackathon registrations tracking toward the 500 we promised sponsors?", "should_trigger": true },
{ "query": "My co-organizer says straight-line the sales to the event date. Is that how we should project?", "should_trigger": true },
{ "query": "Project attendance for our conference's second edition in a bigger venue.", "should_trigger": true },
{ "query": "Registration forecast for a nominal-fee community conference, 8 weeks out.", "should_trigger": true },
{ "query": "Forecast how full the room will be on the day.", "should_trigger": true },
{ "query": "We're at 380 of 400 seats with three weeks left - when do we hit the cap and what happens after?", "should_trigger": true },
{ "query": "Given 900 free sign-ups so far and three weeks to go, what attendance should I plan for?", "should_trigger": true },
{ "query": "Model our registration ramp to doors from the curve so far.", "should_trigger": true },
{ "query": "Give me registration milestones to expect between now and the event.", "should_trigger": true },
{ "query": "Can we hit capacity before the early-bird ends at this signup rate?", "should_trigger": true },
{ "query": "Sanity-check my attendance projection for the summit.", "should_trigger": true },
{ "query": "Expected final headcount for a 2-day meetup-turned-conference, first edition, 150 registered, 5 weeks out.", "should_trigger": true },
{ "query": "How many registrations should we expect to have in hand before the catering guarantee locks?", "should_trigger": true },
{ "query": "Is there enough demand for a Rust conference in our city to sell it out?", "should_trigger": false },
{ "query": "Our registrations are weak - should we cancel, pivot to a meetup, or push on?", "should_trigger": false },
{ "query": "Read our sign-up numbers and tell me go or no-go.", "should_trigger": false },
{ "query": "What overbooking ratio should we use for free registrations?", "should_trigger": false },
{ "query": "Registration closed yesterday at 420. How many lunches do we order?", "should_trigger": false },
{ "query": "Design the waitlist and walk-in lane for our sold-out meetup.", "should_trigger": false },
{ "query": "How do we reduce no-shows at our free event?", "should_trigger": false },
{ "query": "Write the reminder email sequence to get registrants to actually show up.", "should_trigger": false },
{ "query": "Set the early-bird price and when it should end.", "should_trigger": false },
{ "query": "Should we extend the early-bird deadline to boost sales?", "should_trigger": false },
{ "query": "Plan the marketing push to sell the remaining 200 tickets.", "should_trigger": false },
{ "query": "What registration targets should each marketing phase hit?", "should_trigger": false },
{ "query": "Set up the go/no-go review and its thresholds before the venue fee step.", "should_trigger": false },
{ "query": "Build the risk register for our conference.", "should_trigger": false },
{ "query": "Build the budget for our 300-person developer conference.", "should_trigger": false },
{ "query": "Which budget tier can we afford on current sponsorship?", "should_trigger": false },
{ "query": "Find us a venue for 400 people and negotiate the rental terms.", "should_trigger": false },
{ "query": "Negotiate the hotel room block contract and the attrition clause.", "should_trigger": false },
{ "query": "Build the month-by-month work-back plan from today to doors open.", "should_trigger": false },
{ "query": "Pick the best date for our conference next year.", "should_trigger": false },
{ "query": "How do we grow from 300 to 600 attendees next edition?", "should_trigger": false },
{ "query": "How do we launch the first edition of a conference from zero?", "should_trigger": false },
{ "query": "Size the registration desk for the morning rush on day one.", "should_trigger": false },
{ "query": "Plan the catering menu and service style for 500 people.", "should_trigger": false },
{ "query": "Which ticketing platform should we use for registration?", "should_trigger": false },
{ "query": "Design the registration form fields and the ticket types to sell.", "should_trigger": false },
{ "query": "Write the attendee survey to send after the event.", "should_trigger": false },
{ "query": "Run the retrospective on last month's conference.", "should_trigger": false },
{ "query": "Analyse attendance trends across our last five editions to spot what changed.", "should_trigger": false },
{ "query": "Forecast sponsorship revenue for next year's conference.", "should_trigger": false },
{ "query": "Predict how many sponsors will renew after this edition.", "should_trigger": false },
{ "query": "How many volunteers do we need and on what shifts?", "should_trigger": false },
{ "query": "How many speakers should we accept for a two-track day?", "should_trigger": false },
{ "query": "Estimate how many CFP submissions we'll get.", "should_trigger": false },
{ "query": "Form the hackathon teams from the sign-up list.", "should_trigger": false },
{ "query": "Our registrations spiked - write the social post to keep the momentum.", "should_trigger": false },
{ "query": "Should the event be single-day or two-day?", "should_trigger": false },
{ "query": "Model the cash-flow timing of ticket revenue against our deposits.", "should_trigger": false },
{ "query": "Set the refund policy for attendees who can't make it.", "should_trigger": false },
{ "query": "Draft the code of conduct for our event.", "should_trigger": false },
{ "query": "Write the sponsor prospectus with our expected attendee numbers.", "should_trigger": false },
{ "query": "Should we run virtual or in-person next year?", "should_trigger": false },
{ "query": "Set up the badge printing workflow at check-in.", "should_trigger": false },
{ "query": "What show-up rate should we assume to set the overbooking ceiling?", "should_trigger": false },
{ "query": "Forecast our SaaS revenue for next quarter from the pipeline.", "should_trigger": false },
{ "query": "Project our startup's user signups for the next 12 months for the investor deck.", "should_trigger": false },
{ "query": "Build a demand forecast for our e-commerce inventory before Black Friday.", "should_trigger": false },
{ "query": "How many rooms should our hotel overbook tonight given expected no-shows?", "should_trigger": false },
{ "query": "Predict airline seat load factor for the holiday season.", "should_trigger": false },
{ "query": "Set up the webinar registration landing page and tracking pixels.", "should_trigger": false },
{ "query": "Forecast monthly active users for our developer platform.", "should_trigger": false },
{ "query": "Estimate how many GitHub stars we'll have by year end.", "should_trigger": false },
{ "query": "Predict newsletter subscriber growth from the current trend.", "should_trigger": false },
{ "query": "Forecast the weather for our outdoor event day.", "should_trigger": false },
{ "query": "Build a time-series model for website traffic in Python.", "should_trigger": false },
{ "query": "Forecast call-center staffing from ticket volume.", "should_trigger": false },
{ "query": "How many pizzas for a 30-person team offsite?", "should_trigger": false },
{ "query": "Estimate election turnout from early voting numbers.", "should_trigger": false },
{ "query": "Project course enrolments for our online bootcamp cohort.", "should_trigger": false },
{ "query": "Forecast our meetup group's membership growth over the next year.", "should_trigger": false },
{ "query": "What's the newsvendor order quantity for our retail store's seasonal stock?", "should_trigger": false },
{ "query": "Calculate the cookie-consent banner conversion rate.", "should_trigger": false },
{ "query": "Forecast our conference's carbon footprint from expected travel.", "should_trigger": false },
{ "query": "Write the registration confirmation email copy.", "should_trigger": false },
{ "query": "Estimate how long check-in queues will be at the door.", "should_trigger": false },
{ "query": "Write the announcement for ticket sales opening.", "should_trigger": false },
{ "query": "Choose the ticket tiers and what each includes.", "should_trigger": false },
{ "query": "Set up a dashboard to track registrations and no-shows.", "should_trigger": false }
]
}
Related skills
| Skill | Stars | Updated | Works with | Status | Install |
|---|---|---|---|---|---|
| reverse-engineer-anythingmorluto/reaReverse engineer native, managed, Electron/JavaScript, packaged, firmware, and browser targets with REA, and build agent environments (AgentEnv bundles) of web applications from a live instance or a capture, and of Linux desktop apps with a task from a request. Use shipped-artifact or requested runtime evidence to explain features, compare versions, decompile code, or guide a reconstruction. Skip REA for ordinary source-repository architecture analysis. | Stars: 472k | Updated | Claude CodeCodex | Verified | Install |
| diagnosing-superpowersobra/superpowersUse when a superpowers session went wrong and your human partner wants to know why — repeated work, ignored plans, stumbles, poor results, a skill that didn't fire, "it took too long", "why is it so expensive", "what is it doing" — or wants to build a bug report for the superpowers maintainers, for the current session or a past one identified by id or path, on any harness. | Stars: 322k | Updated | Claude CodeCodex | Verified | Install |
| dispatching-parallel-agentsobra/superpowersUse when facing 2+ independent tasks that can be worked on without shared state or sequential dependencies | Stars: 322k | Updated | Claude CodeCodex | Verified | Install |
| executing-plansobra/superpowersUse when executing an implementation plan in the current session as the implementer yourself — your human partner chose inline execution, or no subagent tool is available | Stars: 322k | Updated | Claude CodeCodex | Verified | Install |