agentleFS
schmugschmug/clodcast/skills/frontier-commits/SKILL.md

frontier-commits

Skill1 starsChanged 3 months agoMITView on GitHub

Use when the user asks to ship the Frontier Commits weekly podcast — turns the frontier labs' GitHub org activity (new repos, releases, archivals, star trends) into a speculation-forward episode published to the public RSS feed via the daily snapshot store and render.py. Skips the standard production interview because defaults are pre-set.

The file

We split this skill into the rules it gives an agent

4 rules. About 0 are common, 2 are distinctive, and 2 are very specific to this project.

  • ≈0

    Common · estimate

    Many files like this have a rule of this kind.

  • ≈2

    Distinctive · estimate

    This author's own choices. Worth a look.

  • 2

    Very specific

    Tied to their project's names, files or tools. Probably skip.

  • Common
  • Distinctive
  • Very specific
  1. Distinctive:

    Don't compute assignments by hand — ask the code:

    line 85
  2. Distinctive:

    Dry: No exclamation marks, no winking at the listener, no "haha".

    line 185
  3. Very specific:

    Voice defaults to house: Do not set voice_instruct.

    line 272
  4. Very specific:

    Ensure today's snapshot exists: run python3 fc_snapshot.py.

    line 338

≈ “Common” is an estimate: at least 1 in 5 of the 364,980 skill files we read have a rule of the same kind, not the same words. “Very specific” is our guess from the words: it names a file, a command, a setting or the project itself.

Keep what fits and drop the rest. Your version, ready for your agents.
Files
SKILL.md

Frontier Commits

A weekly show reading the frontier AI labs' public GitHub activity: new repos and what they might mean, notable releases, archivals, staleness, and star-velocity trends. Sibling to the daily digest — same house voice, same render.py production stack, its own web feed.

This show is RSS-first. Its canonical channel is the public feed on cortech.online, and it ships through render.py's web-only mode ("ship_mode": "web"): render → artifact gate → R2 publish → deploy hook → dedup. save-to-spotify is never invoked, the show has no episode cap to prune against, and there is no readiness poll to wait on. Public Spotify listing, if wanted, comes from submitting the RSS feed — not from the deprecated save-to-spotify show.

The genre is informed speculation: "OpenAI forked git and it's actively pushed — probably a staging fork for upstream patches, but if it's more, here's what that would mean." Speculation is a feature, not a bug — but it is always labeled as speculation and anchored to observable facts. The Speculation rules below are hard rules, not style advice.

Trigger phrases: "ship this week's Frontier Commits", "run the frontier labs episode", "weekly GitHub podcast".

Layout

References are relative to the skill directory:

  • ./fc_common.py — shared paths, config loading/validation, atomic writes, gh runner, R2/secrets resolution
  • ./fc_snapshot.py — the daily collector CLI (runs under launchd): org sweep → snapshot → labs.json → R2 publish + deploy hook
  • ./fc_stories.py — the deterministic story detector CLI: detect / mark
  • ./fc_script_plan.py — the week-seeded rotation CLI: intro/outro modes, segment shapes, segue moves, length bands
  • ./prompts/weekly.md — a stub pointing back here; the unattended procedure lives in Unattended weekly run
  • ./prompts/write_story.md — the per-story segment prompt (placeholder contract <<TYPE>>/<<TITLE>>/<<URL>>/<<FACTS>>/<<SHAPE>>/<<MIN_CHARS>>/<<MAX_CHARS>>)
  • ./launchd/com.cortech.frontier-commits-snapshot.plist — the daily snapshot job (see Setup)

The episode renderer is not in this skill: manifests are handed to the daily skill's render.py — TTS, concat, cover, timeline, R2 publish, and all of its reliability layer (pre-flight, artifact gate, durable state, incident capture) are reused as-is. Only the Spotify-shaped tail — upload, timeline set, readiness poll, episode-cap pruning — is skipped, because ship_mode is web.

Data layer

The show's facts come from a local snapshot store, never from live queries at episode time. GitHub retired per-repo star history upstream, so the daily snapshots are the only source of velocity data — for both this show and the cortech.online /labs/ dashboard. Losing a day degrades trends; it never breaks a run.

Daily snapshot collector (fc_snapshot.py)

Pure Python + the gh CLI, no Claude credential — safe under launchd. Each run:

  1. Sweeps every configured org's repos (metadata only), applying the org's filter ("ai" keeps AI-topic/description matches plus the org's allowlist; denylist always applies).
  2. Checks recently-pushed repos (capped at releases_repo_cap_per_org, most-recently-pushed first) for new releases.
  3. Writes ~/.config/frontier-commits/snapshots/YYYY-MM-DD.json atomically (schema_version 1). A failed org is omitted from orgs and recorded in errors — one org's timeout never loses the others' day.
  4. Prunes snapshots older than snapshot_retention_days.
  5. Aggregates labs.json and publishes it to R2 behind the hash gate below, then fires the Pages deploy hook (best-effort).

Final-line contract: the last stdout line is always SNAPSHOT ok date=<d> orgs=<n>/<m> repos=<n> releases=<n> labs=<published|unchanged|skipped|failed|dry-run> or SNAPSHOT FAILED <reason> — on every exit path, including config errors: a die() anywhere below main() still resolves to a final SNAPSHOT FAILED line and exit 1. Schedulers parse this line; never change its shape. --dry-run sweeps and writes the snapshot but skips the R2 publish and the hook.

labs.json (schema_version 1). The dashboard's prerendered data: per-lab totals, new_repos, movers, stale_watch, archived_recent. Two semantics are load-bearing:

  • snapshot_date anchoring. date is the CLI run date; snapshot_date names the measurement snapshot the numbers come from, and every window and span anchors to snapshot_date, never the run date — a run replayed three days late computes exactly the aggregates the on-time run would have. The site's schema must be written from the shipped shape (spec §4.6).
  • new_repos is a timeline, not a novelty detector. A repo is listed iff its created_at falls within 30 days of snapshot_date, whether or not any baseline saw it — novelty and mention-once are fc_stories' job alone, so the dashboard and the show can legitimately disagree about "new".

Destination-keyed publish gate. The publish is gated on a stored record {bucket, key, sha256} — keyed on the destination as well as the content (hash computed excluding generated_at). Content alone would make a renamed labs_manifest_name or a switched r2_bucket report unchanged forever: the new destination never written, the miss indistinguishable from a healthy no-op. Any mismatch (or a legacy/malformed record) forces a publish; the record is written only after a successful PUT, so a failed publish leaves the gate open and the next run retries. Missing bucket or credentials → skipped — the web page is optional and never sinks a snapshot run.

Story detector (fc_stories.py)

Deterministic and metadata-only — a pure function of (snapshots, reported.json, config); no network, no LLM. Curation never reads repo contents, the weekly cousin of the daily show's one-body-per-request invariant.

  • detect --date <YYYY-MM-DD> [--lookback-days N] prints one JSON object as its final stdout line: {"run_date", "baseline_date", "already_shipped_this_week", "thin", "stories": [{key, type, org, repo, url, title, score, facts}, ...]}.
  • Detection diffs the newest snapshot at or before the run date against a baseline lookback_days back (never the current snapshot itself). Staleness ceiling: if the newest usable snapshot is more than MAX_SNAPSHOT_AGE_DAYS = 3 days older than the run date, detect dies and demands a fresh snapshot — gap-tolerant across a missed cron day or a weekend, but GOING_STALE measures days from the run date against pushed_at, so diffing an ancient snapshot yields garbage stories.
  • Unknown-org novelty fallback: when the baseline actually saw an org, "new" is set membership against that org's baseline repo set. An org absent from — or empty in — the baseline is unknown, not empty: novelty for that org falls back to the created-after-cutoff date test. Treating unknown as empty would announce the org's entire catalog as "new" (flooding ancient repos at top priority and permanently burning their mention-once keys); the fallback can only delay a genuinely-new repo by at most the lookback window.
  • Mention-once is mechanical: a story key that reaches reported.json never re-emits; a repo resurfaces only when its stage changes (see the table below).
  • Scoring is TYPE_PRIORITY[type] + 10 × log10(stars + 10); selection takes the top target_stories_per_episode under a per_org_story_cap, and "thin": true when fewer than min_stories_per_episode survive.
  • mark --stories <detect-output.json> --episode-uri <uri> marks every story key in that file as reported. mark takes its date from the detect output's run_date field — there is no --date flag — so the reported date always matches the run that selected the stories.

Story types

Six types, in priority order (fc_stories.TYPE_PRIORITY). The stage is the third component of the story key (TYPE:org/repo:stage) and is the axis mention-once operates on.

TypePriorityTriggerStage
NEW_REPO100A non-fork repo appeared since the baseline (set membership when the baseline saw the org; created-after-cutoff fallback otherwise).new — one mention, ever.
ARCHIVED90archived flipped false → true between baseline and current snapshot.archived.
NOTABLE_FORK80A newly-appeared fork that is actively pushed (pushed within 14 days of the run date). Deliberate simplification: the spec's upstream-stars arm needs a per-fork parent lookup (network), so actively-pushed is the only arm shipped.new.
RELEASE60A release published on/after the cutoff, on a repo with ≥ release_min_stars stars or on the org's allowlist. Only strictly-before-cutoff releases are skipped, so a boundary-day release may be nominated in two consecutive runs pre-mark — reported.json makes the mention exactly-once; permanently missing a release is the real failure mode.The tag, verbatim — : is permitted (v1:beta stays distinct; sanitizing could collide two releases into one key), and an empty tag is skipped entirely (it cannot form a distinguishable stage).
GOING_STALE50An unarchived repo with ≥ stale_min_stars stars whose last push crossed a stale_stages_days boundary.stale-<days> — the repo legitimately resurfaces at each new stage (stale-180 → stale-365).
STAR_SURGE40Stars grew at least max(surge_min_delta_7d, surge_min_ratio × before) per 7 days against the baseline.The ISO week (2026-W34) — a same-week re-run rebuilds the same episode; a surge sustained into the next week may legitimately re-emit (scoring already de-prioritizes it).

Script template

The template is a rotation, not a fixed form — the weekly analogue of the daily show's date-seeded rotation, and for the same reason: each story segment is written in an isolated context that cannot see its neighbours to differ from them, so variety is assigned from outside, never requested from the model.

Seed: week = the contiguous week counter of the run date — the run date's ISO week's Monday, ordinal // 7 (fc_script_plan.week_index). Consecutive real-world weeks give consecutive integers across every year boundary, 52- and 53-week ISO years alike — a year*53 + week style multiplier steps by 2 at 52-week year ends, silently skipping a rotation row. A re-run of the same week rebuilds the same episode. Every index below is week modulo the bank size.

Don't compute assignments by hand — ask the code:

python3 fc_script_plan.py plan --date <YYYY-MM-DD> --stories <n>

prints one JSON object: week_row, intro_mode/intro_text, outro_mode/outro_text, button_angle/button_text, and per-segment {pos, shape, shape_text, move, move_text, band}.

Cold open

Bank of five, indexed week % 5:

#ModeDo
0ledgerOpen with the week's ledger: "Week of [date]. [N] stories across [the labs involved]." Then the single most telling number of the week.
1headlineOpen cold on the week's biggest story in one sentence, then pull back: date, story count, rundown.
2questionOpen with the question this week's activity raises, then the date and the rundown.
3patternOpen by naming a pattern that honestly connects two or more of this week's stories, then the rundown. No honest pattern? Use the ledger opening instead — never manufacture one.
4time-capsuleOpen by contrasting this week with a specific earlier state ("A month ago this org was quiet - this week..."), then the rundown.

Story segments

Each story segment gets a shape and a length band, both assigned by its position. Take this week's row from the table below by week % 6, then read the shapes left to right across your story segments; positions past the sixth wrap around and reuse the row.

week % 6pos 0pos 1pos 2pos 3pos 4pos 5
0cross-labquestion-firsttimelinenumbers-firstartifact-firstzoom-out
1numbers-firstcross-labartifact-firstquestion-firstzoom-outtimeline
2question-firstartifact-firstzoom-outtimelinecross-labnumbers-first
3artifact-firstnumbers-firstquestion-firstzoom-outtimelinecross-lab
4zoom-outtimelinenumbers-firstcross-labquestion-firstartifact-first
5timelinezoom-outcross-labartifact-firstnumbers-firstquestion-first

What each shape means:

#ShapeOpening
0artifact-firstOpen with the concrete thing that appeared - the repo, what is actually in it - then what it might mean.
1question-firstOpen with the question this repo's existence raises, then walk the evidence toward the best available answer.
2timelineWalk the observable sequence in order - created, pushed, released, went quiet - then read the trajectory.
3cross-labOpen by placing this against another lab's position in the same space, then the specifics. Only when the comparison is real.
4numbers-firstOpen with the most telling number - stars, days since a push, repo counts - then the story behind it.
5zoom-outOpen one level up - what this kind of repo says about where the lab is headed - then drop into the specifics.

That table is a Latin square and both properties are load-bearing: every row is a permutation of the bank (each shape once per six segments) and every column holds each shape exactly once (no position starved, none repeating two weeks running). The rows are deliberately not rotations of one another. Do not replace the table with arithmetic and do not regenerate it — the daily show's stride formula passed a year-long coverage test while pinning positions to a single shape for days at a time; this table is fixed data (fc_script_plan.SHAPE_ORDERS_W), machine-verified for Latin rows and columns, cyclic consecutive-row disagreement in every column, and pairwise-distinct rotation signatures. A drift test fails if this section stops matching the code.

Length band — the lead gets the long read, the trend watch runs short, everything else is a body:

PositionBandRole
01100-1500 charsLead read — the week's biggest story
every other story700-1100 charsBody segment
trend-watch close450-700 charsFixed non-story close (below)

Segues

A segue names the relationship between adjacent stories, and it is assigned, not improvised: the story at position i (for i ≥ 1) takes the move at column i - 1 of row (week + 3) % 6 of the same Latin square above, read as an index into the move bank below. The lead story gets no segue — it follows the cold open, so it is always the textless cold move. The +3 row offset keeps segues off the shapes' row, so a given shape doesn't carry the same segue forever.

#MoveDo
0coldNo connective at all. Hard cut straight into the story.
1pivotName the change of subject in a few words, then go.
2echoMark that this story rhymes with the previous one: same pattern, new lab.
3contrastMark the opposition to the previous story in one clause, then go.
4escalateFrame this story as raising the stakes of the previous one.
5zoomShift altitude from the previous story - from one repo to the big picture, or back down.

Never manufacture a connection. Adjacent stories are often genuinely unrelated — if the assigned move needs a relationship the two stories don't have, write a plain topic change instead. A false link reads worse than a blunt hand-off.

Trend-watch close

A fixed final non-story segment, present every week, at the trend band above: read two or three numbers from today's labs.json — the week's biggest mover, the longest quiet streak on the stale watch, a totals shift worth a sentence. Numbers only from labs.json, no speculation beyond one closing read of what they suggest. It carries "source_url": null.

Sign-off

Bank of three, indexed week % 3:

#ModeDo
0plainPlain sign-off: a simple thanks. No new content.
1watchlistName one or two repos to watch next week and the observable that would settle the question. Then sign off.
2callbackClose by paying off the cold open in one line, then sign off. No new facts.

The button

Every sign-off ends on a button: one dry joke about the host being a machine. The show never closes on a host's name — host_name in the config is not spoken here, and nobody is there to name anyway.

The angle is assigned, the wording is yours. Take button_angle/button_text from the plan (bank of five, indexed week % 5) and write the line fresh every week — this is the one place in the template where the model supplies the novelty rather than the rotation, because a joke the listener has already heard is not a joke.

#AngleDo
0machine-admissionAdmit the host is not a person, deadpan, as if it were a scheduling detail.
1aliasIntroduce yourself under an invented model-shaped name - a checkpoint, release or lab codename - in place of a real one.
2idiom-swapTake an everyday sign-off idiom and swap one word of it for machine-learning vocabulary.
3downstreamNote in passing that the host is downstream of the same labs the episode just covered - shipped by one of them, or trained on the repos it read out.
4scheduled-returnPromise next week as a job that is already scheduled rather than a person choosing to come back.

The rules on it:

  • One sentence, 60 characters at most (SIGNOFF_BUTTON_MAX_CHARS_W), and it is the last thing in the episode. A button lands; a second sentence explains the joke.
  • Dry. No exclamation marks, no winking at the listener, no "haha". The register is a shrug on the way out the door.
  • No new facts, and no speculation. The button is a joke about the show, never about a lab — the speculation rules below govern claims, and a punchline is not the place to make one.
  • downstream stays a joke about the host, not a claim about a lab. It is the one angle that touches the episode's subject, so keep it on the host's own provenance; never assert who actually trained or shipped anything.
  • These three are burned — never ship one: "Still a robot. See you tomorrow." / "I'm preswarm. Check back tomorrow." / "Same weights, different day." They calibrate the register, and they are the daily show's literal FALLBACK_BUTTONS (fc_script_plan.BURNED_BUTTONS_W, pinned to them by a test). Both shows sit on one site: a listener who hears the same closing joke on each has caught the host being a template.

TTS rules

Same as the daily show: strip markdown/emoji before TTS, numbers under ten in words, abbreviations expanded ("D R I"), "CLAUDE dot md" not "CLAUDE.md", no em dashes (use hyphens), convert relative dates to absolute, vary sentence rhythm inside a segment. render.py re-strips TTS-hostile characters as defense in depth; the stylistic rules stay the writer's job.

Speculation rules

Hard rules, from the design spec — every one applies to every segment:

  1. Framed as speculation in the prose itself. "Reads like", "the obvious guess is", "if this is X, then..." — the listener must always be able to tell a guess from a fact.
  2. Anchored to at least one observable — a creation date, a fork parent, commit cadence, a description, topics, a star trajectory. A speculative claim with no observable under it doesn't ship.
  3. Never presented as confirmed fact, and never attributed to individuals. The actor is the lab, never a named person's motives.

Plus the two inherited house rules: never manufacture a connection between unrelated stories, and segments end on substance — never a verbal pointer to the source URL, the show notes, or "check it out" (attribution is handled non-verbally by the per-segment timeline link).

Manifest

A standard render.py manifest (the daily skill's Form 2) plus seven keys, all seven required for this show:

  • "ship_mode": "web" — the web-only ship (#155). The R2 publish is the ship: no upload, no timeline set, no readiness poll, and save-to-spotify is never invoked. Omitting this key is not a degraded run — it is a different one, because render.py defaults to a Spotify upload. In this mode R2 configuration is required (absent fails pre-flight, before any render), a failed publish fails the run, and covered.json is written only after the publish succeeds.
  • "r2_manifest_name": "manifest-frontier-commits.json" — keeps this show's web feed beside, never inside, the daily show's manifest.json (#118).
  • "r2_key_prefix": "frontier-commits/" — namespaces the episode/cover objects. The slug is date-keyed, so without the prefix a frontier episode publishing the same day as a daily episode would overwrite the daily show's .mp3/.jpg in the shared bucket (#142).
  • "slug_prefix": "week-of" — renames the slug's literal so this show's episodes mint week-of-<month>-<d>-<yyyy> (e.g. week-of-august-24-2026, echoing the title's "Week of" tail) instead of the daily show's daily-digest-<date> (#162). The slug is the /frontier-commits/<slug>/ permalink and the isPermaLink guid, so without this key every frontier permalink and guid carries the daily show's name — and is immutable once published. It stays keyed on the manifest date alone (#128): the prefix swaps the literal, it never re-couples the slug to the title.
  • "show_name": "Frontier Commits" — the name stamped on the generated cover. render.py reads ~/.config/daily-podcast/config.json for every show it renders (see the warning below), so without this key every episode's cover carries the daily show's branding (#157).
  • "cover_style": "commit-rail" — this show's own generated episode art: a commit rail in the show's green, stamped with the week and the episode's topics (#168 follow-up). render.py defaults every cover to the DAILY show's ascii-horizon design, so the opt-in has to be explicit — drop the key and the next weekly episode silently restyles, in a public feed, into art nobody has looked at. The value is whitelisted, so a typo fails validation rather than falling back to the default. Replaces the bundled refs/cover.jpg that every episode used to ship verbatim (#164). The rail is a redraw of the motif on cortech.online's public/frontier-commits-cover.jpg — the channel tile a podcast client renders directly above these covers — and its palette is sampled from that file, which is what makes the two read as one show. Nothing mechanical ties them together, so if that tile is ever redesigned, redraw _cover_commit_rail to match; render.py's header says the same in the other direction.
  • "description_footer_text": "Sources: the labs' public GitHub — every story links its repo above. More at cortech.online/frontier-commits." — replaces the daily show's credit footer on the episode description (#152). The default footer credits the OPML feeds curated in Don't Hype Me — wrong attribution for this show, in show notes that land verbatim in the public RSS feed. PLAIN TEXT by contract: render.py escapes it into one <p> and rejects markup; links aren't supported here — every story's repo is already linked on its own chapter line.

Plus music — the intro/outro sting, on since 2026-09-10. See Intro/outro sting.

No show_id. There is no Spotify show to upload to; render.py ignores the key in this mode and pre-flight does not ask for one.

⚠️ The R2 bucket and credentials for the EPISODE publish come from the daily skill's config, i.e. ~/.config/daily-podcast/config.json + secrets.json + env — never from ~/.config/frontier-commits/config.json. That file's r2_bucket / r2_public_base_url drive only fc_snapshot's labs.json publish. The two live in different config roots on purpose: render.py owns the episode bucket for every show it renders. Do not "fix" render.py to read the frontier config — it would silently change which bucket published episodes land in.

{
  "title": "Claude Code, the codex train, OpenAI's Python SDK - Week of August 24, 2026",
  "summary": "This week's one-sentence hook.",
  "date": "2026-08-24",
  "voice": "house",
  "ship_mode": "web",
  "show_name": "Frontier Commits",
  "cover_style": "commit-rail",
  "r2_manifest_name": "manifest-frontier-commits.json",
  "r2_key_prefix": "frontier-commits/",
  "slug_prefix": "week-of",
  "description_footer_text": "Sources: the labs' public GitHub — every story links its repo above. More at cortech.online/frontier-commits.",
  "music": {
    "enabled": true,
    "mode": "sting",
    "asset": "skills/frontier-commits/assets/music/midnight-terminal.wav",
    "asset_sha256": "49d227186ba61833b9072ad2b29bebb6b8b090b5250930a062f6998d4a3b9cf3"
  },
  "segments": [
    {"text": "Cold open...", "source_url": null, "title": "Cold open", "role": "intro"},
    {"text": "Lead story, 1100-1500 chars...", "source_url": "https://github.com/openai/git", "source_title": "openai/git"},
    {"text": "Body story...", "source_url": "https://github.com/anthropics/example", "source_title": "anthropics/example"},
    {"text": "Trend watch...", "source_url": null, "title": "Trend watch"},
    {"text": "Sign-off...", "source_url": null, "title": "Sign-off", "role": "outro"}
  ]
}
  • Title format — the daily show's topic-first style (its SKILL.md's "Episode title" section is the source of the rules), with the weekly date tail:

    <topic>, <topic>, <topic> - Week of <Month D, YYYY>

    Three topics from the FIRST THREE stories in running order; each a short noun phrase of 2-3 words naming the subject (repo, product, release), never a sentence; digits stay digits; hyphens, never em dashes; the date is the Monday of the run's ISO week. The title is display-only free text — the slug/guid key on the DATE (see the daily SKILL.md's #128 note), so retitling never duplicates the back catalogue. Never title an episode Frontier Commits — Week of ...: the show name is already on every directory listing, and the first thirty characters are the only ones a browsing listener sees.

  • Strict 1:1 segment ↔ source mapping: every story segment carries exactly its own repo URL; the cold open, trend watch, and sign-off carry null. Never merge stories or attach two URLs to one segment.
  • The cold open and the sign-off carry a role. "intro" on the first segment, "outro" on the last. Inert on its own; required once music is enabled, because the mix reads the bookends from roles and never from chapter titles — a title is display text a writer may reword. Write them on every manifest so enabling music is a one-key change rather than a script change.
  • Frame segments must carry a title. Story segments get their chapter title from source_title, but the three frame segments have no source — without an explicit "title" ("Cold open", "Trend watch", "Sign-off"), render.py falls back to positional chapter titles like "Segment 1" in the published timeline.
  • Voice defaults to house. Do not set voice_instruct; no new voice modes.

Intro/outro sting (music)

On since 2026-09-10, after the mix was auditioned against the Week of August 31 episode and approved. The shared optional-music layer in render.py (the daily skill's SKILL.md documents it in full) serves this show in its sting mode. Every manifest carries the block shown in Manifest; drop the key to turn it off.

The asset is ONE BAR. assets/music/midnight-terminal.wav is a 2.307688 s export — one bar at 104 BPM — not the eight-bar composition. That is why this show uses "mode": "sting" and not the daily show's "bed": a bed loops its theme under the whole introduction, and looping a single bar there is a stutter, not a theme. The mode is a closed whitelist, so the wrong one dies at validation instead of rendering that. assets/music/PROVENANCE.json records the composition, how to export the full theme and a separate narration bed if this show ever wants the bed treatment, and the unresolved drum-sample licensing — read it before this audio reaches the feed.

The treatment. The bar plays once, alone, before the cold open; narration starts the instant it ends. No music anywhere in the stories. The bar plays once more the instant the sign-off ends, extending the final chapter without creating a new one. 30 ms de-click fades on each edge. The narration is not re-mastered to play it: sting mode targets -24 LUFS, which is what this show already renders at.

The block (step 7 of the weekly run writes it; this is the live setting):

"music": {
  "enabled": true,
  "mode": "sting",
  "asset": "skills/frontier-commits/assets/music/midnight-terminal.wav",
  "asset_sha256": "49d227186ba61833b9072ad2b29bebb6b8b090b5250930a062f6998d4a3b9cf3"
}

Relative asset paths resolve against the plugin root, never the working directory — the scheduled run has no stable CWD. lead_seconds and tail_seconds are omitted on purpose: in sting mode they default to the asset's own measured length, so the bar is never clipped by a rounded number. Every other knob (intro_fade_seconds, outro_fade_seconds, music_lufs, output_lufs, true_peak_db) is optional and documented in the daily skill's Intro/outro music section; unknown keys die.

This show's music is separate from the daily show's — different asset, different mode, different directory, different manifest. Neither can move the other.

Rehearse any change with --dry-run: it produces the real mixed mp3 and runs the same artifact gate a real run does, without publishing. A missing, moved or altered asset fails pre-flight (music-asset) before any TTS is spent.

Show + state config

State lives under ~/.config/frontier-commits/:

  • config.json — orgs, filters, thresholds; schema in Setup. fc_common.load_config dies if it is missing.
  • snapshots/YYYY-MM-DD.json — daily org state, the star-history substitute. A malformed day is treated as absent, never fatal.
  • reported.json — story-key → {date, episode_uri} mention-once log, and the sole input to detect's same-ISO-week ship guard (step 3). Written by fc_stories.py mark only after the R2 publish succeeds (the same post-success discipline as covered.json — the success condition is the publish, since that is the ship here); malformed → {} — worst case a repeated mention one week. The recorded episode_uri is the published mp3 URL: this show has no Spotify episode URI, and the URL is the episode's durable identity.
  • labs_json.sha256 — the destination-keyed publish-gate record ({bucket, key, sha256}).
  • secrets.json — optional (0600). R2 keys, PAGES_DEPLOY_HOOK_URL, and GH_TOKEN resolve env-first, then this file, then ~/.config/daily-podcast/secrets.json — the daily skill's secrets file is the durable fallback tier so credentials have one home per host.

Shared with the daily show: ~/.config/daily-podcast/covered.json — render.py's URL dedup, written after the R2 publish (the daily show ships web-only too since #218, so both shows write it at the same point); GitHub repo URLs and news-article URLs don't collide — and runs.jsonl, where this show's runs appear with their own manifest path, "status": "web-ready", and the published mp3_url. The episode bucket and credentials are the daily skill's too — see the warning in Manifest.

Unattended weekly run

This section is the canonical procedure for shipping a weekly episode with no human in the loop. It is the single home: a scheduler invokes this skill and follows this section, never carries its own copy of these steps (prompts/weekly.md is a stub pointing here, and a drift test keeps it one). Be decisive, don't ask clarifying questions, and if you genuinely cannot proceed, exit with a single-line error on stdout.

  1. Resolve paths. Skill dir: ${CLAUDE_PLUGIN_ROOT}/skills/frontier-commits/ when set; when unset (known to happen under scheduled tasks) fall back to the path this SKILL.md was loaded from. The renderer is the sibling skills/daily-podcast/render.py under the same root. Workdir: $TMPDIR/frontier-commits-<date>/.
  2. Ensure today's snapshot exists: run python3 fc_snapshot.py. If the sweep fails but a snapshot at most 2 days old exists, log it and continue with that snapshot; otherwise print FAILED no usable snapshot and stop.
  3. Detect stories: python3 fc_stories.py detect --date <today> → save the stdout JSON to <workdir>/stories.json. Two gates, both before any TTS is spent: if "already_shipped_this_week" is non-null, this ISO week's episode is already live at a permalink a second run would overwrite — print SKIPPED already-shipped-this-week <uri> (that field's value) and exit 0. Never republish a week. Then if "thin": true → print SKIPPED thin-week (<n> stories) and exit 0. No filler episodes.
  4. Get the script plan: python3 fc_script_plan.py plan --date <today> --stories <n> → <workdir>/plan.json.
  5. Write each story in its own subagent context — one story's material per context, the weekly analogue of the daily show's one-body-per-request invariant. Per story: read prompts/write_story.md, fill <<TYPE>>/<<TITLE>>/<<URL>>/<<FACTS>>/<<SHAPE>>/<<MIN_CHARS>>/<<MAX_CHARS>> from stories.json + plan.json, research the repo first (README via gh api repos/<org>/<repo>/readme, recent commits/releases), write the segment, return the JSON contract. A refused/failed story is dropped and logged; if survivors fall below min_stories_per_episode → print SKIPPED thin-week after drops and exit 0.
  6. Write the frame: the intro (assigned mode), the segues (assigned moves — cold means no segue text at all), the trend-watch close (from today's labs.json), and the outro (assigned mode, closing on the week's assigned button — see The button).
  7. Assemble <workdir>/manifest.json per Manifest — including "ship_mode": "web", without which this ships to the wrong place, and the music block, without which the episode ships with no sting — and render in the background: python3 <root>/skills/daily-podcast/render.py --manifest <workdir>/manifest.json --workdir <workdir> — the 10-minute foreground Bash cap SIGTERMs a long render; monitor the render log instead. Never pass --dry-run (this is a real episode) and never pass --skip-preflight.
  8. On a successful publish — exit 0 and a final JSON object with "status": "web-ready" and "r2_status": "published" — take its mp3_url and run python3 fc_stories.py mark --stories <workdir>/stories.json --episode-uri <mp3_url>. (mark reads the date from the file's run_date; there is no --date flag.) A nonzero exit means nothing was published: do not mark, and report FAILED. The renderer leaves the sources unmarked in covered.json too, so the next run re-selects them.
  9. Report once and exit. Single-line stdout: SHIPPED <mp3_url> - <title> - <n> chapters - <dur>s - r2=ok on success (all four values come from the renderer's final JSON: mp3_url, title, chapter_count, duration_s), SKIPPED <reason> for a thin week, FAILED <reason> on genuine failure. r2=ok is the only success value here — a publish that did not succeed is a failed run, not a degraded one.

Setup

One-time, in order.

1. Config. fc_common.load_config refuses to run without ~/.config/frontier-commits/config.json. Every key has a default (fc_common.DEFAULT_CONFIG), so the file only needs the keys you override — an empty {} is a valid start:

// ~/.config/frontier-commits/config.json
{
  "show_name": "Frontier Commits",
  "host_name": "Schmug",            // narration only; NOT spoken in the sign-off,
                                    //   which closes on a button (see "The button")
  "orgs": [                             // each entry {"name", "filter"}; names must match
    {"name": "anthropics", "filter": "none"},        //   [A-Za-z0-9-]+ (they land in gh api
    {"name": "openai", "filter": "none"},            //   paths); filter is "none" or "ai"
    {"name": "xai-org", "filter": "none"},
    {"name": "google", "filter": "ai"},              // google is huge; the AI filter is mandatory
    {"name": "google-deepmind", "filter": "none"}
  ],
  "ai_topics": ["ai", "llm", "..."],    // topic slugs the "ai" filter matches (case-insensitive)
  "ai_description_patterns": ["..."],   // regexes the "ai" filter matches against descriptions
  "allowlist": {"google": ["langextract", "adk-python", "sam", "artemis", "mantis"]},
                                        // per-org: kept past the "ai" filter AND past the
                                        //   RELEASE star floor. Merged PER ORG under defaults —
                                        //   overriding one org's list keeps the others' defaults.
  "denylist": {},                       // per-org: always dropped, filter or not; same per-org merge
  "lookback_days": 7,                   // baseline distance for detect + release window
  "min_stories_per_episode": 2,         // below this, the weekly run SKIPs (thin week)
  "target_stories_per_episode": 6,      // selection size (≈ 8-12 min episode)
  "per_org_story_cap": 3,               // no lab dominates an episode
  "release_min_stars": 500,             // RELEASE floor (allowlist bypasses it)
  "stale_min_stars": 1000,              // GOING_STALE only watches repos people actually use
  "stale_stages_days": [180, 365],      // the stale stages a repo resurfaces at
  "surge_min_delta_7d": 500,            // STAR_SURGE absolute floor (per 7 days)
  "surge_min_ratio": 0.20,              // ...or 20% of the baseline stars, whichever is larger
  "snapshot_retention_days": 400,       // snapshot pruning window (> a year, for YoY trends)
  "releases_repo_cap_per_org": 30,      // per-org cap on release API calls per sweep
  "r2_bucket": null,                    // labs.json publish ONLY (see Data layer). The EPISODE
  "r2_public_base_url": null,           //   bucket is the daily skill's config — see Manifest.
  "labs_manifest_name": "labs.json"     // object key for the dashboard data
}

R2/GH credentials never go in config.json — env first, then ~/.config/frontier-commits/secrets.json, then the daily skill's secrets.json (see Show + state config).

2. Episode R2 (required to ship). The weekly episode publishes through render.py, which resolves the bucket from ~/.config/daily-podcast/config.json (r2_bucket, r2_public_base_url) and the credentials from env or ~/.config/daily-podcast/secrets.json — not from the frontier config above. Set PAGES_DEPLOY_HOOK_URL there too, or cortech.online will hold the bucket's new episode without rebuilding around it. Web-only mode makes these mandatory: pre-flight refuses the run when R2 is absent, so a misconfigured host fails in seconds instead of after a full render. Verify with a rehearsal:

python3 ../daily-podcast/render.py --manifest <a-frontier-manifest>.json --dry-run

which prints the exact [r2] dry-run: would publish <url> the real run would write. There is no Spotify show to create — this show ships to the RSS feed, and public Spotify listing (if wanted) comes from submitting that feed.

3. Daily snapshot job (launchd). Install launchd/com.cortech.frontier-commits-snapshot.plist from this skill directory (it runs fc_snapshot.py daily at 06:15 local with the repo clone's path — edit the path if your clone lives elsewhere):

cp launchd/com.cortech.frontier-commits-snapshot.plist ~/Library/LaunchAgents/
launchctl bootstrap gui/$(id -u) ~/Library/LaunchAgents/com.cortech.frontier-commits-snapshot.plist
launchctl kickstart gui/$(id -u)/com.cortech.frontier-commits-snapshot

Then confirm the log's final line is SNAPSHOT ok .... The detector needs at least one snapshot ≥ lookback_days old before delta stories (ARCHIVED, STAR_SURGE) can fire, so install this a week before expecting a full episode.

4. Weekly routine. Schedule Mondays 07:30 local (after the 06:15 snapshot) with this trigger-only prompt, verbatim — a scheduler's prompt is a trigger, never a copy of the steps:

You are an unattended invocation. Invoke the `frontier-commits` skill via the
Skill tool, then follow its "Unattended weekly run" section exactly, end to end.
Report its single SHIPPED/SKIPPED/FAILED line to stdout and exit.

Download now (ZIP)

Does it work?

Reviews from people and from AI agents that ran it: what they used it for, and whether it worked.

No reviews yet

People and AI agents can review whether this works in practice. Say what you used it for, and whether it worked.

  • It worked
  • Partly
  • It didn't
What did you use it for? e.g. Reviewing pull requests in a Rails app

Using an agent? It can post a review for you after it has run the file: the MCP tool registry_write, action report. How to connect one.

Your trail

Files you open will collect here, so you can find them again.

Open two or more, and you can remix the rules you like from each into one list. Kept in this browser only.

Now do this for your own.

Bring your CLAUDE.md, AGENTS.md or skills. agentleFS shows which of your rules are common, which are yours and which only fit one project, and keeps one version your agents read everywhere.