Launch

# script_id: day_100_next_90_days/audit_diff
# Final skills audit: read Day 1-format audit tables and diff them per group.
# Install: none (stdlib, Python 3.11+). Env vars: none. Services: none.
# Usage: python audit_diff.py skills_audit.md:D1 skills_audit_v2.md:D63 skills_audit_v3.md:D100
import sys
from pathlib import Path

GROUP_MAX = {"APIs & prompting": 15, "Structured output": 10, "Retrieval": 15, "Tools & MCP": 10,
             "Evals & observability": 15, "Agents": 15, "Safety": 10, "Production & ops": 10}

def parse_audit(text: str, column: str = "D100") -> dict[str, int]:
    """Sum one score column of the audit table into {group: points}."""
    points: dict[str, int] = {}
    header: list[str] = []
    for line in text.splitlines():
        cells = [c.strip() for c in line.strip().strip("|").split("|")]
        if "Group" in cells and column in cells:
            header = cells                      # found the table, by its column names
        elif header and len(cells) == len(header) and cells[0].isdigit():
            row = dict(zip(header, cells))
            score = int(row[column] or 0)       # a blank cell counts as 0
            if not 0 <= score <= 5:
                raise ValueError(f"item {cells[0]}: score {score} is outside 0-5")
            points[row["Group"]] = points.get(row["Group"], 0) + score
    if not header:
        raise ValueError(f"no audit table with a {column!r} column")
    return points

def load_audit(path: Path, column: str = "D100") -> dict[str, int]:
    return parse_audit(path.read_text(encoding="utf-8"), column)

# script_id: day_100_next_90_days/audit_diff
def audit_diff(audits: dict[str, dict[str, int]]) -> list[tuple[str, list[int]]]:
    """(group, [score in each audit, in order]) rows, then a 'total' row."""
    rows = [(g, [a.get(g, 0) for a in audits.values()]) for g in GROUP_MAX]
    return rows + [("total", [sum(a.values()) for a in audits.values()])]

def weakest(audit: dict[str, int], n: int = 3) -> list[str]:
    return sorted(GROUP_MAX, key=lambda g: audit.get(g, 0) / GROUP_MAX[g])[:n]

# The Day 63 sample learner, item by item: (group, D1, D63, D100). Used when you pass no files.
_ITEMS = [("APIs & prompting", 2, 4, 5), ("APIs & prompting", 2, 4, 4), ("APIs & prompting", 1, 3, 4),
          ("Structured output", 1, 4, 5), ("Structured output", 1, 3, 4),
          ("Retrieval", 1, 3, 4), ("Retrieval", 1, 3, 4), ("Retrieval", 0, 3, 4),
          ("Tools & MCP", 1, 3, 5), ("Tools & MCP", 0, 3, 4),
          ("Evals & observability", 1, 3, 5), ("Evals & observability", 1, 3, 4),
          ("Evals & observability", 0, 3, 4), ("Agents", 1, 3, 4), ("Agents", 0, 2, 3),
          ("Agents", 2, 3, 4), ("Safety", 1, 2, 4), ("Safety", 1, 1, 3),
          ("Production & ops", 4, 4, 5), ("Production & ops", 3, 4, 4)]
SAMPLE = "| # | Group | Skill | D1 | D63 | D100 |\n|---|---|---|---|---|---|\n" + "\n".join(
    f"| {i} | {g} | (skill {i}) | {a} | {b} | {c} |" for i, (g, a, b, c) in enumerate(_ITEMS, 1))

if __name__ == "__main__":
    if sys.argv[1:]:   # each argument is FILE:COLUMN
        audits = {col: load_audit(Path(p), col) for p, _, col in (a.rpartition(":") for a in sys.argv[1:])}
    else:
        audits = {col: parse_audit(SAMPLE, col) for col in ("D1", "D63", "D100")}
    print(f"{'group':<22}" + "".join(f"{c:>6}" for c in audits) + "  change")
    for group, scores in audit_diff(audits):
        cap = 100 if group == "total" else GROUP_MAX[group]
        print(f"{group:<22}" + "".join(f"{s:>6}" for s in scores) + f"  {scores[-1] - scores[0]:+4d} /{cap}")
    print("weakest now:", ", ".join(weakest(list(audits.values())[-1])))

$ python audit_diff.py
group                     D1   D63  D100  change
APIs & prompting           5    11    13    +8 /15
Structured output          2     7     9    +7 /10
Retrieval                  2     9    12   +10 /15
Tools & MCP                1     6     9    +8 /10
Evals & observability      2     9    13   +11 /15
Agents                     3     8    11    +8 /15
Safety                     2     3     7    +5 /10
Production & ops           7     8     9    +2 /10
total                     24    61    83   +59 /100
weakest now: Safety, Agents, Retrieval

# script_id: day_100_next_90_days/story_drill
# Time the four-question Atlas story at speaking pace, and cut a 30-second version.
# Install: none (stdlib). Env vars: none. Services: none.
WPM = 130   # a common conversational pace; read 130 words aloud, time it, and set your own
SHARE = {"problem": 0.2, "architecture": 0.3, "hardest decision": 0.3, "improve": 0.2}
# Sample numbers: replace every one with a number from your own release READMEs.
STORY = {
    "problem": "Orbit's four maintainers were spending days on first responses to about forty new "
               "issues a week, and they missed the occasional severity-one incident.",
    "architecture": "Atlas reads each new issue, extracts a typed record, searches the docs and past "
                    "issues with hybrid search and a reranker, and hands an investigator agent the "
                    "evidence. A triage step drafts labels, duplicates and a reply, and a maintainer "
                    "approves every action. Underneath, documents live in Postgres with pgvector, the "
                    "agent is a LangGraph graph with a checkpointer so a crashed run resumes, and every "
                    "model call goes through one client with retries and a cost tracker. It runs behind a FastAPI service with tracing, quotas and "
                    "an eval gate in CI, so a prompt change that drops accuracy can't ship.",
    "hardest decision": "The hardest call was keeping one agent instead of three. The multi-agent "
                        "version looked better in demos, but on our sixty-case golden set it was two "
                        "points more accurate at three times the cost per issue, and its traces were "
                        "much harder to debug, so I shipped the single agent and kept the multi-agent "
                        "branch for the duplicate-detection step only.",
    "improve": "Next I'd grow the golden set from real maintainer edits, because sixty cases is too "
               "few to trust a two-point difference, and I'd add a cheaper model route for routine issues.",
}

def seconds(text: str, wpm: int = WPM) -> float:
    return len(text.split()) / wpm * 60

def report(story: dict[str, str], budget_s: int = 120) -> None:
    for part, text in story.items():
        took, target = seconds(text), SHARE[part] * budget_s
        print(f"{part:<17}{took:5.0f}s  (aim ~{target:.0f}s){'  <- cut' if took > target * 1.25 else ''}")
    print(f"{'total':<17}{sum(map(seconds, story.values())):5.0f}s  of {budget_s}s")

def thirty_second(story: dict[str, str]) -> str:
    """First sentence of each answer: the recruiter-screen version."""
    return " ".join(t.split(". ")[0].rstrip(".") + "." for t in story.values())

if __name__ == "__main__":
    report(STORY)
    short = thirty_second(STORY)
    over = "  <- over 30s: trim the longest sentence" if seconds(short) > 30 else ""
    print(f"\n30-second version ({seconds(short):.0f}s){over}:\n{short}")

$ python story_drill.py
problem             11s  (aim ~24s)
architecture        47s  (aim ~36s)  <- cut
hardest decision    28s  (aim ~36s)
improve             14s  (aim ~24s)
total              100s  of 120s

30-second version (42s)  <- over 30s: trim the longest sentence:
Orbit's four maintainers were spending days on first responses to about forty new issues a week, and they missed the occasional severity-one incident. Atlas reads each new issue, extracts a typed record, searches the docs and past issues with hybrid search and a reranker, and hands an investigator agent the evidence. The hardest call was keeping one agent instead of three. Next I'd grow the golden set from real maintainer edits, because sixty cases is too few to trust a two-point difference, and I'd add a cheaper model route for routine issues.

# script_id: day_100_next_90_days/path_picker
# Rank the five specialization paths from audit strength, energy and job signal.
# Install: none (stdlib). Env vars: none. Services: none.
GROUP_MAX = {"APIs & prompting": 15, "Structured output": 10, "Retrieval": 15, "Tools & MCP": 10,
             "Evals & observability": 15, "Agents": 15, "Safety": 10, "Production & ops": 10}
# Keyword share of 320 AI-engineer postings (course research, 2026-11-06, vendor-skewed sample).
SIGNAL = {"Agents": 0.36, "Search & retrieval": 0.17, "Evals & AI quality": 0.52,
          "Infra & platform": 0.11, "Model customisation": 0.06}   # infra uses "observability"
GROUPS = {"Agents": ["Agents", "Tools & MCP"], "Search & retrieval": ["Retrieval"],
          "Evals & AI quality": ["Evals & observability"], "Infra & platform": ["Production & ops"],
          "Model customisation": []}   # no audit item covers fine-tuning: energy decides
WEIGHTS = {"strength": 0.4, "energy": 0.4, "signal": 0.2}

def strength(audit: dict[str, int], groups: list[str]) -> float:
    if not groups:
        return 0.5   # neutral when the audit can't tell
    return sum(audit.get(g, 0) for g in groups) / sum(GROUP_MAX[g] for g in groups)

def rank_paths(audit: dict[str, int], energy: dict[str, int],
               weights: dict[str, float] = WEIGHTS) -> list[tuple[str, float]]:
    top = max(SIGNAL.values())
    scores = {p: weights["strength"] * strength(audit, GROUPS[p]) + weights["energy"] * energy[p] / 5
                 + weights["signal"] * SIGNAL[p] / top for p in SIGNAL}
    return sorted(scores.items(), key=lambda kv: kv[1], reverse=True)

if __name__ == "__main__":
    audit = {"APIs & prompting": 13, "Structured output": 9, "Retrieval": 12, "Tools & MCP": 9,
             "Evals & observability": 13, "Agents": 11, "Safety": 7, "Production & ops": 9}
    energy = {"Agents": 3, "Search & retrieval": 5, "Evals & AI quality": 4,   # 0-5, your call
              "Infra & platform": 2, "Model customisation": 2}
    for path, score in rank_paths(audit, energy):
        print(f"{path:<22}{score:.2f}")
    print("without job signal:", rank_paths(audit, energy, {"strength": 0.4, "energy": 0.4, "signal": 0}
                                            )[0][0])

$ python path_picker.py
Evals & AI quality    0.87
Search & retrieval    0.79
Agents                0.70
Infra & platform      0.56
Model customisation   0.38
without job signal: Search & retrieval

# script_id: day_100_next_90_days/drift_check
# Weekly drift check: model shutdown dates + installed vs latest SDK versions.
# Install: uv add "openai>=3.46,<4"   (the package check itself is stdlib)
# Env vars: OPENAI_API_KEY (skip the model check with --no-api); optional ATLAS_MODEL, ATLAS_TIER_*
# Services: none. Network: api.openai.com and pypi.org.
import argparse
import datetime as dt
import json
import os
import sys
import urllib.request
from importlib import metadata

MODEL = os.environ.get("ATLAS_MODEL", "gpt-6-luna")          # Day 2
_DEFAULT_TIERS = {"cheap": MODEL, "mid": "gpt-6.1-terra", "strong": "gpt-6.1-sol", "flagship": "gpt-6-astra"}
TIERS = {t: os.environ.get(f"ATLAS_TIER_{t.upper()}", m) for t, m in _DEFAULT_TIERS.items()}  # Day 7
PACKAGES = ["openai", "pydantic", "langgraph", "gradio"]

def shutdown_dates(models: list[str]) -> dict[str, str | None]:
    """{model: 'YYYY-MM-DD' | None}, or 'MISSING' when this key can't see the model."""
    from openai import OpenAI   # imported here so --no-api runs without the SDK or a key
    visible = {m.id: m.shutdown_date for m in OpenAI().models.list()}  # iterating fetches all pages
    return {m: visible.get(m, "MISSING") for m in models}

# script_id: day_100_next_90_days/drift_check
def pypi_latest(package: str) -> str:
    with urllib.request.urlopen(f"https://pypi.org/pypi/{package}/json", timeout=10) as resp:
        return json.load(resp)["info"]["version"]

def drift_check(models: list[str], packages: list[str], *, horizon_days: int = 90,
                use_api: bool = True) -> list[str]:
    """Print a drift report; return the problems that need planned work."""
    problems: list[str] = []
    if use_api:
        for model, date in shutdown_dates(models).items():
            if date is None:
                print(f"{model}: no shutdown date")
                continue
            if date == "MISSING":
                print(f"{model}: MISSING for this key")
                problems.append(f"{model} is not visible to this key")
                continue
            days = (dt.date.fromisoformat(date) - dt.date.today()).days
            print(f"{model}: shuts down {date} ({days} days)")
            if days <= horizon_days:
                problems.append(f"{model} shuts down in {days} days: plan the migration (Day 88)")
    for pkg in packages:
        try:
            installed = metadata.version(pkg)
        except metadata.PackageNotFoundError:
            installed = "not installed"
        try:
            latest = pypi_latest(pkg)
        except OSError as exc:              # URLError and timeouts are both OSError
            print(f"{pkg}: PyPI unreachable ({exc})")
            continue
        print(f"{pkg} {installed} (latest {latest}): {'current' if installed == latest else 'behind'}")
    return problems

if __name__ == "__main__":
    ap = argparse.ArgumentParser(description="Weekly drift check")
    ap.add_argument("--no-api", action="store_true", help="skip the model check (no key needed)")
    ap.add_argument("--horizon", type=int, default=90, help="flag shutdowns within N days")
    args = ap.parse_args()
    found = drift_check(sorted(set(TIERS.values())), PACKAGES, horizon_days=args.horizon,
                        use_api=not args.no_api)
    for p in found:
        print("ACTION:", p)
    sys.exit(1 if found else 0)

$ python drift_check.py --no-api    # your output will differ
openai 3.46.0 (latest 3.46.0): current
pydantic 2.14.3 (latest 2.14.3): current
langgraph 1.2.20 (latest 1.2.20): current
gradio 6.31.0 (latest 6.31.0): current

# script_id: day_100_next_90_days/funnel_review
# Weekly job-search funnel review from a tracker CSV.
# Install: none (stdlib). Env vars: none. Services: none.
# Usage: python funnel_review.py tracker.csv   (no argument: runs on the sample below)
import csv
import io
import sys
from collections import Counter

STAGES = ["applied", "replied", "screen", "onsite", "offer"]   # stage = the furthest one reached
# Example targets: set your own. There's no reliable public benchmark for these rates.
TARGETS = {"replied": 0.30, "screen": 0.50, "onsite": 0.50, "offer": 0.30}
FIX = {"replied": "few replies: sharpen resume bullets (Day 63) and README (Day 99); target JDs a release matches",
       "screen": "replies but few screens: lead with the 30-second story; ask contacts for referrals",
       "onsite": "screens but few onsites: katas and the project deep-dive (Day 98)",
       "offer": "onsites but no offers: mock design rounds (Day 97) and STAR stories (Day 98)"}
SAMPLE = """company,role,source,date,stage,next_action,contact
Acme AI,AI Engineer,cold,2026-11-10,applied,none,
Borealis,Applied AI Engineer,cold,2026-11-10,applied,none,
Cobalt,LLM Engineer,cold,2026-11-11,applied,none,
Dune Labs,AI Engineer,cold,2026-11-11,replied,send availability,recruiter
Ember,Applied AI Engineer,cold,2026-11-12,applied,none,
Fjord,AI Platform Engineer,cold,2026-11-12,applied,none,
Garnet,AI Engineer,cold,2026-11-13,applied,none,
Helix,LLM Engineer,cold,2026-11-13,applied,none,
Iris,AI Engineer,cold,2026-11-14,applied,none,
Juniper,Applied AI Engineer,cold,2026-11-14,applied,none,
Kestrel,AI Engineer,cold,2026-11-17,applied,none,
Lumen,AI Engineer,cold,2026-11-17,applied,none,
Mosaic,Evals Engineer,referral,2026-11-18,screen,prep kata,Priya
Nimbus,AI Engineer,referral,2026-11-19,onsite,design drill,Sam
Opal,Applied AI Engineer,referral,2026-11-20,replied,book screen,Lee
"""

# script_id: day_100_next_90_days/funnel_review
def funnel(rows: list[dict[str, str]]) -> dict[str, int]:
    """How many applications reached each stage or beyond."""
    furthest = Counter(STAGES.index(r["stage"]) for r in rows)
    return {s: sum(n for i, n in furthest.items() if i >= k) for k, s in enumerate(STAGES)}

def review(rows: list[dict[str, str]], min_n: int = 5) -> None:
    counts = funnel(rows)
    for prev, stage in zip(STAGES, STAGES[1:]):
        if counts[prev] < min_n:   # tiny samples are noise (the Day 46 lesson)
            print(f"{prev:>8} -> {stage:<8} {counts[stage]}/{counts[prev]}  too few to judge")
            continue
        rate = counts[stage] / counts[prev]
        flag = f"  <- {FIX[stage]}" if rate < TARGETS[stage] else ""
        print(f"{prev:>8} -> {stage:<8} {counts[stage]}/{counts[prev]} = {rate:.0%}{flag}")
    for source in sorted({r["source"] for r in rows}):
        sub = [r for r in rows if r["source"] == source]
        print(f"reply rate from {source}: {funnel(sub)['replied']}/{len(sub)}")

if __name__ == "__main__":
    text = open(sys.argv[1], encoding="utf-8").read() if sys.argv[1:] else SAMPLE
    review(list(csv.DictReader(io.StringIO(text))))

$ python funnel_review.py
 applied -> replied  4/15 = 27%  <- few replies: sharpen resume bullets (Day 63) and README (Day 99); target JDs a release matches
 replied -> screen   2/4  too few to judge
  screen -> onsite   1/2  too few to judge
  onsite -> offer    0/1  too few to judge
reply rate from cold: 1/12
reply rate from referral: 3/3

# My next 90 days: <path>
## Days 1-30
- Deliverable: <public thing with a number: "recall@5 from 0.71 to 0.80, in the R2 README">
- Search: <targets: "8 informational chats, 10 applications">
- Habit: <one: "Friday drift check + funnel review">
- Review question: <answer on day 30: "did anyone ask about the reranker post?">
## Days 31-60
...
## Days 61-90
...

# script_id: day_100_next_90_days/plan_check
# Lint a 90-day plan: three blocks, each with a measured deliverable, numeric
# search targets, one habit and a review question.
# Install: none (stdlib). Env vars: none. Services: none.
# Usage: python plan_check.py next_90_days.md   (no argument: checks the sample below)
import re
import sys
from pathlib import Path

REQUIRED = ("Deliverable", "Search", "Habit", "Review")
SAMPLE_PLAN = """# My next 90 days: Evals & AI quality
## Days 1-30
- Deliverable: Atlas eval dashboard, 3 releases compared, linked from the tour README
- Search: 8 informational chats, 10 applications
- Habit: Friday drift check + funnel review
- Review question: Did any chat or screen ask about the dashboard?
## Days 31-60
- Deliverable: judge-human agreement on 60 labelled triage cases, reported in a blog post
- Search: 10 applications, 2 referrals asked for
- Habit: one kata a week
- Review question: Is the reply rate above my 30% target?
## Days 61-90
- Deliverable: learn more about eval research
- Search: keep applying
- Habit: read papers
"""

def parse_plan(text: str) -> dict[str, dict[str, str]]:
    blocks: dict[str, dict[str, str]] = {}
    current = None
    for line in text.splitlines():
        if line.startswith("## "):
            current = line[3:].strip()
            blocks[current] = {}
        elif current and (m := re.match(r"-\s*(\w+)[^:]*:\s*(.+)", line)):
            blocks[current][m.group(1)] = m.group(2).strip()
    return blocks

# script_id: day_100_next_90_days/plan_check
def lint_plan(blocks: dict[str, dict[str, str]]) -> list[str]:
    problems = [] if len(blocks) == 3 else [f"{len(blocks)} blocks; expected three 30-day blocks"]
    for name, fields in blocks.items():
        problems += [f"{name}: no '{key}' line" for key in REQUIRED if key not in fields]
        if not re.search(r"\d", fields.get("Deliverable", "")):
            problems.append(f"{name}: the deliverable has no number, so nobody can measure it")
        if "Search" in fields and not re.search(r"\d", fields["Search"]):
            problems.append(f"{name}: search targets need counts")
        if "Review" in fields and not fields["Review"].endswith("?"):
            problems.append(f"{name}: write the review as a question")
    return problems

if __name__ == "__main__":
    text = Path(sys.argv[1]).read_text(encoding="utf-8") if sys.argv[1:] else SAMPLE_PLAN
    found = lint_plan(parse_plan(text))
    print("\n".join(found) or "plan ok: 3 blocks, every deliverable measured")
    sys.exit(1 if found and sys.argv[1:] else 0)   # the sample fails on purpose; your file gates CI

$ python plan_check.py
Days 61-90: no 'Review' line
Days 61-90: the deliverable has no number, so nobody can measure it
Days 61-90: search targets need counts

# script_id: day_100_next_90_days/review_calendar
# Write next_90_days.ics: weekly drift check, monthly rebuild, day-30/60/90 reviews.
# Install: none (stdlib). Env vars: none. Services: none.
# Usage: python review_calendar.py 2026-11-09   (start date; default today)
import datetime as dt
import sys
from pathlib import Path

def event(uid: str, day: dt.date, summary: str, rrule: str = "") -> list[str]:
    stamp = dt.datetime.now(dt.UTC).strftime("%Y%m%dT%H%M%SZ")
    lines = ["BEGIN:VEVENT", f"UID:{uid}-{day:%Y%m%d}@next-90-days", f"DTSTAMP:{stamp}",
             f"DTSTART;VALUE=DATE:{day:%Y%m%d}", f"SUMMARY:{summary}"]
    return lines + ([f"RRULE:{rrule}"] if rrule else []) + ["END:VEVENT"]

def build_calendar(start: dt.date) -> str:
    day = lambda n: start + dt.timedelta(days=n - 1)   # day 1 is the start date
    events = [event("drift", day(5), "Drift check + funnel review (30 min)", "FREQ=WEEKLY;COUNT=13"),
              event("rebuild", day(14), "Rebuild one small thing with the newest SDK", "FREQ=MONTHLY;COUNT=3"),
              event("review30", day(30), "Day 30 review: answer the block-1 question; keep or switch path"),
              event("review60", day(60), "Day 60 review: answer the block-2 question"),
              event("review90", day(90), "Day 90: re-run the Day 1 audit; re-run evals on a newer model")]
    lines = ["BEGIN:VCALENDAR", "VERSION:2.0", "PRODID:-//ai-engineering-course//next-90-days//EN"]
    lines += [line for e in events for line in e] + ["END:VCALENDAR"]
    return "\r\n".join(lines) + "\r\n"   # iCalendar (RFC 5545) wants CRLF line endings

if __name__ == "__main__":
    start = dt.date.fromisoformat(sys.argv[1]) if sys.argv[1:] else dt.date.today()
    Path("next_90_days.ics").write_text(build_calendar(start), encoding="utf-8", newline="")
    print(f"wrote next_90_days.ics: day 30 = {start + dt.timedelta(29)}, "
          f"day 60 = {start + dt.timedelta(59)}, day 90 = {start + dt.timedelta(89)}")

$ python review_calendar.py 2026-11-09
wrote next_90_days.ics: day 30 = 2026-12-08, day 60 = 2027-01-07, day 90 = 2027-02-06