1. an "impact on my life" card under news issues, and
2. a "what experts said vs what the market did" page that plots named expert statements as dots on real price charts and checks them 7 and 30 days later.

The constraint was strict: no invented sentences, no invented numbers, and no server. Here is how it is built.

1. A rule table instead of generated text

If a model writes "this could raise your loan interest" on the fly, it will eventually write something plausible and wrong. So impact sentences come only from a hand-written JSON rule table.

• 10 rules: interest rates, FX, oil, housing, semiconductors, stocks, crypto, prices, policy, security
• each rule = keyword regex + 1–3 lines of "who is affected → what may change → where to check (link)" + a small gauge (my wallet / daily life / schedule: low, mid, high) + which market series to attach
• wording is always conditional ("may", "can"), and every card ends with general information, depends on your situation, not investment advice
• issues containing death/accident terms never get a card (1 of 60 today)

Result on today's build: 7 of 60 news issues and 7 of 26 trending topics matched a rule and got a card. Most issues do not affect a household budget, and the card simply does not appear for them.

Numbers in a card come only from the article headline (a regex for %, %p, won, dollars, bp and dates), printed next to the outlet and title so there is never a number without a source.

2. Public price data, checked against robots.txt

Six series download in 1.6 s into a 12.8 KB JSON file, once a day. The hourly site build only reads that cache. If one series fails, it keeps yesterday's values for that series only.

3. Checking statements after the fact

• value on the statement date = that day's close, or the last trading day before it
• value 7 days later = first trading day on or after date + 7; until then the page says "check on 10/27"
• an optimistic statement followed by a rise (or a cautious one followed by a fall) is shown as "moved as stated", otherwise "moved the other way": facts only, no mocking
• a per-institution leaderboard appears only after 5 judged statements; below that the page shows "sample N"

Right now there are 15 named expert statements in 30 days and 0 judged, because collection started on 10/16 and no 7-day window has closed yet. The rule "don't rank before there is data" is visible on the page instead of hidden in code.

4. Static JSON + one SVG path

There is no charting library. At build time each chart is a single SVG path plus circles for statements; the only script opens the headline and source link when a dot is tapped. FRED lags a day or two, so statements newer than the last price point used to pile up at the right edge. The fix: extend the axis to today and draw dots right of a dashed "no data yet" line in a lighter colour.

Size of the whole thing: impact code 62 lines + rule JSON 44 lines, market module 86 lines. A full site build takes about 89 s and the site is plain static HTML on GitHub Pages.

5. Opinion lives in a labelled box

The same data feeds a weekly commentary piece, for example why "AI bubble" talk came back the day the Nasdaq rose 1.1%. It keeps facts (with links), the conflicting expert quotes, the actual index moves and the impact card separate from opinion, which sits in its own clearly labelled box.

Try it

• Expert talk vs market: sungprofile.cloud/money/experts
• Full build notes (Korean): sungprofile.cloud/dev/issue-impact-market-pipeline
• The rest of the site (contests, support programs, 1,350 fridge recipes): sungprofile.cloud

Built with an AI coding assistant; all numbers re-measured on the 2026-10-20 build. General information, not investment advice.

Last night every step failed in the first second with:

FileNotFoundError(2, 'The system cannot find the file specified')

Nothing ran, and the only thing that "worked" was the final packaging step, which happily summarised yesterday's data. Here is what happened and the replacement I use now.

The cause: wmic is gone

The "is it running?" check shelled out to wmic:

r = subprocess.run(
    ["wmic", "process", "where", "name like 'python%'", "get", "commandline"],
    capture_output=True, text=True)
return script_name in r.stdout

WMIC has been deprecated for years, and on current Windows 11 builds it is not installed by default (it became an optional feature, and newer installs simply do not have it). subprocess.run therefore cannot find the executable and raises FileNotFoundError before anything else happens.

Because I wrapped each step in try/except and only logged the error, the job did not crash. It just quietly skipped the work. That is the real lesson: a guard that fails should not be treated the same as "nothing to wait for".

Replacement 1: PowerShell CIM (no extra packages)

Get-CimInstance Win32_Process returns the same data WMIC used to:

import subprocess

NO_WINDOW = 0x08000000  # don't flash a console window from a scheduled task

def is_running(script_name: str) -> bool:
    ps = ("(Get-CimInstance Win32_Process "
          "-Filter \"Name like 'python%'\").CommandLine")
    r = subprocess.run(["powershell", "-NoProfile", "-Command", ps],
                       capture_output=True, text=True, errors="ignore",
                       creationflags=NO_WINDOW)
    if r.returncode != 0:
        raise RuntimeError(f"process check failed: {r.stderr[-200:]}")
    return script_name in r.stdout

Two details matter here:

• The filter uses WQL, so it is Name like 'python%' (with %, not *), the same syntax WMIC used.

• CREATE_NO_WINDOW keeps a scheduled task from popping up a PowerShell window on the desktop.

PowerShell start-up costs a few hundred milliseconds, which is irrelevant for a once-a-night check.

Replacement 2: psutil (if you can add a dependency)

import psutil

def is_running(script_name: str) -> bool:
    for p in psutil.process_iter(["name", "cmdline"]):
        name = (p.info["name"] or "").lower()
        if name.startswith("python") and any(script_name in a for a in (p.info["cmdline"] or [])):
            return True
    return False

This is faster and cross-platform. Some processes deny access to cmdline; process_iter with the attribute list returns None for those instead of raising, which is why the or [] is there.

Make the guard fail loudly

The bigger fix was in the caller. Before:

try:
    wait_until_free("build.py")
    run_build()
except Exception as e:
    log("build failed", e)

After, the wait has a timeout and a broken check stops the run instead of being mistaken for "free":

for _ in range(60):              # wait up to 30 minutes
    if not is_running("build.py"):
        break
    time.sleep(30)
else:
    raise RuntimeError("build.py still running after 30 min")
run_build()

and the summary step now refuses to package if the build step did not succeed, so a failed night can't look like a quiet one.

Checklist if you have old Windows automation

• grep -r wmic your scripts and scheduled tasks.

• Replace wmic process with Get-CimInstance Win32_Process or psutil.

• Replace wmic os get ... / wmic logicaldisk ... the same way (Win32_OperatingSystem, Win32_LogicalDisk).

• Make sure a failing pre-check stops the job instead of being swallowed.

Written with the help of an AI coding assistant, from a bug in my own scheduled job.

Where this runs

This nightly job keeps Ruri Jupjup fresh: a free Korean site I build with an AI coding agent that lists open contests and government support programs (rebuilt every hour) and has an ingredient-based finder over ~1,350 home recipes. The 00:00 run collects new listings, rebuilds and pushes the static site, and packages a summary for my other machine. That is why a silent failure mattered: the site simply stopped updating for a night.

1. Decide the source list by reading robots.txt, not by what's convenient

For news, the useful thing is that most publishers expose an RSS feed and their robots.txt doesn't forbid it. For stock and crypto commentary I wanted the big portals, and that is where I hit a wall: several of them disallow automated collection, so they are simply not in the list. In the module docstring:

"""Source: only securities/crypto RSS from outlets that allow collection
(some large finance portals, a news aggregator and a global finance site
disallow it in robots.txt, so they are not used). Coin prices come from
the exchange's public API."""

The rule I use is boring and I keep it boring: before adding a source, fetch /robots.txt and read it. If the path I need is disallowed, I don't use that source, even if I could technically scrape it. A quick check looks like this:

from urllib.robotparser import RobotFileParser

def allowed(url, ua='*'):
    base = '/'.join(url.split('/')[:3])
    rp = RobotFileParser(base + '/robots.txt')
    rp.read()
    return rp.can_fetch(ua, url)

That helper is a sketch for the check I do before adding a feed. The point is the habit, not the code.

For the data that isn't news, the same idea applies: public trend RSS, a public ticker endpoint, and public-sector open data. One public recipe database I experimented with has fields named MANUAL01 to MANUAL20 for the cooking steps, and the step text can end with a stray a/b/c marker. A one-line re.sub(r'[a-z]$', '', step) cleans it. Public data tends to be accurate and badly formatted, so budget time for formatting.

2. Parse RSS without a library, but handle the two things that break

I parse feeds with a few regexes instead of a feed library. Two things bit me:

Encoding. Some Korean outlets still serve euc-kr / cp949. requests guesses wrong often enough to produce mojibake. I sniff the XML declaration instead:

def decode(r):
    head = r.content[:300].decode('ascii', 'ignore').lower()
    for enc in ('euc-kr', 'cp949', 'ks_c_5601'):
        if enc in head:
            return r.content.decode('cp949', 'ignore')
    return r.content.decode('utf-8', 'ignore')

Missing dates. In the news collector, when an item has no parseable pubDate, the fallback is "now":

try:
    ts = email.utils.parsedate_to_datetime(ds).timestamp() ...
except Exception:
    ts = time.time()

For news that is filtered to the last 36 hours, that's tolerable. For anything where age matters it's a trap, and I fell into it: an undated, year-old article in a feed was shown as "today's report".

3. Dates you can trust: RSS, then page metadata, then URL, then give up

For the analyst-comment collector, an item without a reliable date is dropped. The idea: use the RSS date if there is one, otherwise the date from the page's own metadata, otherwise a date found in the URL, and otherwise nothing. Here is the URL part and the sanity check, trimmed:

def url_date(u):
    m = re.search(r'(20[12]\d)[-/]?(0[1-9]|1[0-2])[-/]?(0[1-9]|[12]\d|3[01])', u)
    if m:
        return datetime.datetime(int(m[1]), int(m[2]), int(m[3]), 12, tzinfo=KST).timestamp()

# RSS date -> page metadata (filled in earlier) -> date inside the URL. Unknown: drop.
if a['ts'] is None:
    a['ts'] = int(ud) if ud else None
elif ud and a['ts'] - ud > 3 * 86400:
    a['ts'] = int(ud)            # URL says it's much older than the feed claims
items = [a for a in items if a['ts'] and now - a['ts'] < 7 * 86400]

Two details I like: the URL date wins when it is more than 3 days older than the RSS date (re-published old articles are exactly what the RSS date lies about), and "unknown" means "drop", never "now".

What I'd tell myself at the start

• Write the allowed-source list down in the code, with the reason for each exclusion.
• A missing date is a missing fact. Don't fill it with time.time() unless a wrong date is harmless.
• Public data is free to use, but the formatting work isn't free.

The site this runs on is Korean; the build notes (in Korean) are here: https://sungprofile.cloud/ailog/?src=hashnode

The $0 constraint

• Hosting: GitHub Pages (static HTML) — free
• Login, bookmarks, visit counter, web-push subscriptions: Cloudflare Workers + D1 free tier
• Photo-to-ingredients recognition for a "what can I cook with my fridge" tool: a public vision model on Workers AI, capped per day to stay inside the free allocation
• Data: publishers' public RSS feeds (only where robots.txt allows), Upbit's public crypto API, Google Trends RSS
• Character art: open models on my own GPU
• Automation: Windows Task Scheduler on my PC, every hour: collect → process → build → git push

Things I found interesting

Grouping the same story across 15 news outlets. The first version linked articles in a chain (A≈B, B≈C), which merged completely different stories A and C. Switching to "compare everything against a seed article" fixed it.

A "verification signals" score, not a fact-check verdict. Each article gets points for cross-reporting, named (vs anonymous or social-media) sources, whether numbers and double-quoted quotes in the headline actually appear in the body, and a flag when outlets report different casualty numbers for the same event. The page always says this is a reading aid, not a final judgement.

Analyst reports as nodes. One brokerage-report article = one node (firm, direction, old → new price target, reason tags). Nodes roll up into per-stock "reasons up / reasons down" trees.

Where the AI got it wrong

• A year-old article without a date slipped into an RSS feed and showed up as "today's report". Fix: resolve dates from RSS → URL → page metadata, drop anything older than 7 days, and flag implausible price-target jumps.
• Single quotes used for emphasis in Korean headlines were treated as quotations and penalised. Fix: only compare double-quoted text.
• Generated characters with odd hands. Fix: only hand-checked images are used.

The full cost table, architecture and the actual instructions I gave are on the build log page (in Korean): https://sungprofile.cloud/ailog/?src=hashnode

Update (Oct 18, evening)

• The home page is now four themed entrances; news, money, contests, everyday-life and the AI build log each became a separate screen with its own colours and menu. The entrance matching where you came from (?src=) is shown first.
• Per-theme chatbots that run entirely in the browser (no model): today's issues and questionable articles; crypto prices and price-target upgrades/downgrades; subsidy search and housing-lottery schedules. Data loads only when the panel is opened.
• Housing-lottery helper: enter your situation → score (out of 84) + supply types worth trying + matching notices open right now.
• Money section: an investment-policy table checked against official sources, general age-based principles, and on-the-record expert comments grouped by topic, side by side when they disagree (not investment advice).
• Search clean-up: RSS feed, sitemap lastmod that only changes when a content hash changes, noindex on thin auto-generated pages, and pre-rendering JS-drawn screens to static HTML (text visible to crawlers went from 687 to 13,605 characters).
• Analytics: channels grouped by first touch; automated health-check traffic from overseas servers excluded (12 hits had slipped in on day one).
• Updated numbers: 2 days · 110 commits · 1,360 pages (about 2,400 old multilingual pages removed). Server/API cost is still $0.