From bc4e3b38e327636f78ddcadd5adc074bd0f8b355 Mon Sep 17 00:00:00 2001 From: Klangschalen <171444708+Klangschalen@users.noreply.github.com> Date: Tue, 12 May 2026 09:51:02 +0200 Subject: [PATCH 1/5] feat(anthropic-intelligence): bootstrap KB structure, sources, engineer profiles Adds the foundation for a continuously-updated knowledge base on Anthropic and Claude Code, structured as a subtree of klangschalen/knowledge. - README + CADENCE rationale (weekly scan, monthly synthesis) - sources.yaml: prioritized source registry (P0/P1/P2) - engineers/: profiles of Boris Cherny, Erik Schluntz, Sholto Douglas, Cat Wu, Thariq Shihipar (Anthropic) + Simon Willison (external) - topics/, monitoring/ scaffolding --- anthropic-intelligence/CADENCE.md | 29 ++++ anthropic-intelligence/README.md | 51 ++++++ anthropic-intelligence/engineers/README.md | 28 ++++ .../engineers/boris-cherny.md | 31 ++++ anthropic-intelligence/engineers/cat-wu.md | 27 +++ .../engineers/erik-schluntz.md | 30 ++++ .../engineers/sholto-douglas.md | 28 ++++ .../engineers/simon-willison.md | 34 ++++ .../engineers/thariq-shihipar.md | 29 ++++ anthropic-intelligence/monitoring/README.md | 20 +++ .../monitoring/logs/.gitkeep | 0 anthropic-intelligence/monitoring/state.json | 5 + anthropic-intelligence/sources.yaml | 154 ++++++++++++++++++ anthropic-intelligence/topics/README.md | 38 +++++ 14 files changed, 504 insertions(+) create mode 100644 anthropic-intelligence/CADENCE.md create mode 100644 anthropic-intelligence/README.md create mode 100644 anthropic-intelligence/engineers/README.md create mode 100644 anthropic-intelligence/engineers/boris-cherny.md create mode 100644 anthropic-intelligence/engineers/cat-wu.md create mode 100644 anthropic-intelligence/engineers/erik-schluntz.md create mode 100644 anthropic-intelligence/engineers/sholto-douglas.md create mode 100644 anthropic-intelligence/engineers/simon-willison.md create mode 100644 anthropic-intelligence/engineers/thariq-shihipar.md create mode 100644 anthropic-intelligence/monitoring/README.md create mode 100644 anthropic-intelligence/monitoring/logs/.gitkeep create mode 100644 anthropic-intelligence/monitoring/state.json create mode 100644 anthropic-intelligence/sources.yaml create mode 100644 anthropic-intelligence/topics/README.md diff --git a/anthropic-intelligence/CADENCE.md b/anthropic-intelligence/CADENCE.md new file mode 100644 index 0000000..4ccc570 --- /dev/null +++ b/anthropic-intelligence/CADENCE.md @@ -0,0 +1,29 @@ +# Update Cadence + +## Recommended rhythm + +| Frequency | What | Trigger | Output | +|---|---|---|---| +| Daily | nothing automatic | — | manual only, on demand | +| **Weekly (Mon 06:00 UTC)** | Source scan | `.github/workflows/anthropic-weekly-scan.yml` cron | `monitoring/logs/YYYY-WW.md` + PR | +| **Monthly (1st 06:00 UTC)** | Topic synthesis | `.github/workflows/anthropic-monthly-synthesis.yml` cron | Updates to `topics/*.md` + PR | +| Ad-hoc | Major release (new Claude model, Claude Code major) | Manual | Hand-crafted topic update | + +## Why this cadence + +- **Daily**: too noisy. Anthropic does not publish that often. Would create alert fatigue and PR spam. +- **Weekly**: sweet spot for catching blog posts, Simon Willison's weeknotes, Boris Cherny / Thariq Shihipar tweets, Claude Code minor releases. One human review per week max. +- **Monthly**: enough buffer for 3–4 weekly logs to accumulate before re-synthesizing topic articles. Avoids constant article churn and merge conflicts. +- **Ad-hoc**: model launches and Claude Code major versions warrant immediate, deeper treatment than the standard pipeline can deliver. + +## Source priority tiers + +Sources in `sources.yaml` carry a `priority` field: + +- **P0** — must-check every scan (Anthropic blog, Claude Code releases, docs changelog) +- **P1** — weekly check (employee blogs, Simon Willison, key X accounts, model cards) +- **P2** — monthly check (community Reddit, broader news aggregation) + +## Tuning the cadence + +If weekly PRs feel too noisy, drop P2 sources from the weekly scan and only include them in the monthly synthesis. If a topic is hot (e.g. a model release week), temporarily bump cadence to twice weekly via `workflow_dispatch`. diff --git a/anthropic-intelligence/README.md b/anthropic-intelligence/README.md new file mode 100644 index 0000000..4bbc15f --- /dev/null +++ b/anthropic-intelligence/README.md @@ -0,0 +1,51 @@ +# Anthropic Intelligence + +Living knowledge base on Anthropic, Claude Code, and AI engineering best practices. + +## Why this exists + +Information from Anthropic ships fast: blog posts, model cards, Claude Code release +notes, engineering employees on X / personal blogs, Reddit threads, conference talks. +Most of it never reaches our internal systems. This repo (subtree) closes that gap: + +- **Continuous monitoring** of curated sources via GitHub Actions cron +- **Weekly diff logs** of what changed in the Anthropic ecosystem +- **Monthly synthesis** of logs into topic-level KB articles +- **Engineer profiles** so we know whose ideas we're tracking + +## Layout + +| Path | Purpose | +|---|---| +| `topics/` | Synthesized, versioned KB articles per topic (HTML output, caching, tool use, agents, hooks, etc.) | +| `engineers/` | Profiles of key Anthropic engineers (Boris Cherny, Erik Schluntz, Sholto Douglas, Cat Wu, Thariq Shihipar) and external voices (Simon Willison) | +| `sources.yaml` | Registry of feeds, blogs, GitHub repos, X handles being watched | +| `monitoring/logs/` | Auto-generated weekly diff logs from scanner | +| `scripts/` | Python: source fetcher + monthly synthesizer | +| `../.github/workflows/anthropic-*.yml` | Cron workflows (weekly scan, monthly synthesis) | + +## Cadence (recommended) + +- **Weekly (Monday 06:00 UTC)** — scanner fetches all sources, writes diff log, opens PR +- **Monthly (1st of month, 06:00 UTC)** — synthesizer aggregates 4 weeks of logs, updates topic articles, opens PR +- **Ad-hoc** — major releases (Claude model launches, Claude Code major versions) + +See `CADENCE.md` for rationale. + +## Extracting to a standalone repo (future) + +This lives as a subtree because the standalone `klangschalen/anthropic-intelligence` +repo could not be created from the current integration scope (403 from GitHub API). +To extract later: + +```bash +git subtree split --prefix=anthropic-intelligence -b anthropic-intelligence-export +# create the standalone repo manually on github.com, then: +git push git@github.com:klangschalen/anthropic-intelligence.git anthropic-intelligence-export:main +``` + +## First artifact + +`topics/output-formats-html-vs-markdown.md` — deep research into the May 2026 +shift toward HTML as default Claude output format, with concrete recommendations +for our prompts and agents. diff --git a/anthropic-intelligence/engineers/README.md b/anthropic-intelligence/engineers/README.md new file mode 100644 index 0000000..238842d --- /dev/null +++ b/anthropic-intelligence/engineers/README.md @@ -0,0 +1,28 @@ +# Engineer profiles + +Profiles of people whose work materially shapes how we build with Claude. + +Each profile captures: + +1. **Role** at Anthropic (or affiliation if external) +2. **Why we track them** — the specific topics/products they own or influence +3. **Where to follow** — verified handles, blogs, talks +4. **Key public outputs** — talks, papers, posts that shaped our thinking +5. **Last verified** — ISO date when the profile was last reality-checked + +Profiles are reality-checked during the monthly synthesis pass. Unverified claims +are marked `TODO: verify`. + +## Current profiles + +### Anthropic (internal) + +- [Boris Cherny](./boris-cherny.md) — Claude Code, TypeScript tooling +- [Erik Schluntz](./erik-schluntz.md) — Claude Code, agents +- [Sholto Douglas](./sholto-douglas.md) — Scaling, training, ML research +- [Cat Wu](./cat-wu.md) — Claude Code product +- [Thariq Shihipar](./thariq-shihipar.md) — Claude Code, output formats (HTML) + +### External (high-signal observers) + +- [Simon Willison](./simon-willison.md) — Independent, Datasette, prolific Claude observer diff --git a/anthropic-intelligence/engineers/boris-cherny.md b/anthropic-intelligence/engineers/boris-cherny.md new file mode 100644 index 0000000..72710e1 --- /dev/null +++ b/anthropic-intelligence/engineers/boris-cherny.md @@ -0,0 +1,31 @@ +# Boris Cherny + +> **Last verified:** 2026-05-12 — needs cross-check on current title. + +## Role + +Member of Technical Staff at Anthropic. One of the core engineers behind Claude +Code. Background in TypeScript tooling; author of *Programming TypeScript* (O'Reilly). + +## Why we track him + +Claude Code's CLI surface, internal architecture, and TypeScript-heavy SDK +decisions trace back through his work. When he publishes a tip or a design +rationale, it usually reflects how the team actually builds. + +## Where to follow + +- X: https://x.com/bcherny *(TODO: verify handle)* +- GitHub: https://github.com/bcherny +- Talks / podcasts: appearances on Latent Space, ThePrimeagen, etc. + +## Key public outputs (to compile) + +- *Programming TypeScript* (O'Reilly book) +- Conference talks on Claude Code architecture +- *TODO*: link to most recent post explaining the agentic loop design + +## Notes + +We already cite Boris's design rationale inside `klangschalen/unified-agent-system`. +Keep this profile in sync with what we cite there. diff --git a/anthropic-intelligence/engineers/cat-wu.md b/anthropic-intelligence/engineers/cat-wu.md new file mode 100644 index 0000000..ee8beff --- /dev/null +++ b/anthropic-intelligence/engineers/cat-wu.md @@ -0,0 +1,27 @@ +# Cat Wu + +> **Last verified:** 2026-05-12 — stub, role to be confirmed. + +## Role + +Product Manager for Claude Code at Anthropic *(TODO: verify)*. + +## Why we track her + +Claude Code product decisions — what ships, what gets cut, release cadence, +plugin/skill ecosystem direction — surface through her communication first. + +## Where to follow + +- X: https://x.com/_catwu *(TODO: verify handle)* +- Anthropic blog posts she has authored + +## Key public outputs (to compile) + +- *TODO*: Claude Code product announcements +- *TODO*: roadmap-adjacent posts + +## Notes + +Pair her signal with Boris Cherny / Erik Schluntz for the full picture (product +intent + engineering reality). diff --git a/anthropic-intelligence/engineers/erik-schluntz.md b/anthropic-intelligence/engineers/erik-schluntz.md new file mode 100644 index 0000000..04727ab --- /dev/null +++ b/anthropic-intelligence/engineers/erik-schluntz.md @@ -0,0 +1,30 @@ +# Erik Schluntz + +> **Last verified:** 2026-05-12 — personal blog confirmed at erikschluntz.com. + +## Role + +Member of Technical Staff at Anthropic, working on Claude Code and agentic +systems. + +## Why we track him + +Writes unusually candid posts on agent design tradeoffs, evaluation, and the +day-to-day reality of building Claude Code. Pre-Anthropic background in +robotics gives him a useful systems-engineering lens on agent reliability. + +## Where to follow + +- Blog: https://www.erikschluntz.com/ +- X: https://x.com/eschluntz *(TODO: verify handle)* +- GitHub: https://github.com/eschluntz + +## Key public outputs (to compile) + +- *TODO*: agent-design essays from erikschluntz.com (link as we encounter them) +- *TODO*: Anthropic engineering blog co-authorships + +## Notes + +We already integrate his observations in `klangschalen/unified-agent-system`. +Check monthly for new blog posts. diff --git a/anthropic-intelligence/engineers/sholto-douglas.md b/anthropic-intelligence/engineers/sholto-douglas.md new file mode 100644 index 0000000..f4eefbf --- /dev/null +++ b/anthropic-intelligence/engineers/sholto-douglas.md @@ -0,0 +1,28 @@ +# Sholto Douglas + +> **Last verified:** 2026-05-12 — stub, fill on first monthly synthesis. + +## Role + +Researcher at Anthropic. Focus areas: scaling, training, model capabilities. + +## Why we track him + +Frequent podcast guest (Dwarkesh Patel, others) on the *mechanics* of how +frontier models actually improve. His framings shape how we set expectations +for capability jumps across Claude versions. + +## Where to follow + +- X: https://x.com/_sholtodouglas *(TODO: verify handle)* +- Dwarkesh Podcast appearances + +## Key public outputs (to compile) + +- *TODO*: most recent Dwarkesh appearance — link + summary +- *TODO*: any co-authored Anthropic papers we should index + +## Notes + +More strategic / research signal than tactical engineering signal. Useful when +deciding which Claude version to target. diff --git a/anthropic-intelligence/engineers/simon-willison.md b/anthropic-intelligence/engineers/simon-willison.md new file mode 100644 index 0000000..62cdb7f --- /dev/null +++ b/anthropic-intelligence/engineers/simon-willison.md @@ -0,0 +1,34 @@ +# Simon Willison + +> **Last verified:** 2026-05-12 — simonwillison.net Atom feed working. + +## Role + +Independent. Co-creator of Django, creator of Datasette/LLM CLI, ex-Eventbrite. +Not an Anthropic employee — but one of the most prolific and high-signal +external observers of Claude and the LLM ecosystem. + +## Why we track him + +- Same-day, technically literate analysis of new Anthropic releases +- Often the first to surface non-obvious capabilities and gotchas +- Cross-validates Anthropic's own claims against real usage +- His weekly notes catch X/Reddit/HN threads we'd otherwise miss + +## Where to follow + +- Blog (Atom): https://simonwillison.net/atom/everything/ +- Mastodon: https://fedi.simonwillison.net/@simon +- GitHub: https://github.com/simonw + +## Key public outputs (to compile) + +- *Using Claude Code: The Unreasonable Effectiveness of HTML* commentary (May 2026) + — referenced in `../topics/output-formats-html-vs-markdown.md` +- Recurring "weeknotes" with Claude usage patterns +- The `llm` CLI tool (https://llm.datasette.io/) as a reference implementation + +## Notes + +Treat as **P1 always-on** — his Atom feed is the single highest-signal external +source we monitor. If we had to drop everything else, we'd keep this. diff --git a/anthropic-intelligence/engineers/thariq-shihipar.md b/anthropic-intelligence/engineers/thariq-shihipar.md new file mode 100644 index 0000000..515d638 --- /dev/null +++ b/anthropic-intelligence/engineers/thariq-shihipar.md @@ -0,0 +1,29 @@ +# Thariq Shihipar + +> **Last verified:** 2026-05-12 — author of the "Unreasonable Effectiveness of HTML" Anthropic post (May 2026). + +## Role + +Member of Technical Staff on the Claude Code team at Anthropic. + +## Why we track him + +Author of the May 2026 Anthropic post *"Claude Code: The Unreasonable +Effectiveness of HTML"* — the canonical explainer for the team's decision to +lean on HTML as the default Claude output format for many tool/agent use cases. +Directly relevant to our prompt design. + +## Where to follow + +- X: https://x.com/trq212 *(TODO: verify handle — search results show @trq212)* +- Anthropic engineering blog + +## Key public outputs + +- *Claude Code: The Unreasonable Effectiveness of HTML* (Anthropic blog, May 2026) + - See `../topics/output-formats-html-vs-markdown.md` for our synthesis + +## Notes + +High-signal author for output-format and design-of-LLM-output topics. Watch for +follow-up posts. diff --git a/anthropic-intelligence/monitoring/README.md b/anthropic-intelligence/monitoring/README.md new file mode 100644 index 0000000..979ffe5 --- /dev/null +++ b/anthropic-intelligence/monitoring/README.md @@ -0,0 +1,20 @@ +# Monitoring + +Auto-generated outputs from the weekly source scanner. + +## Layout + +- `logs/YYYY-WW.md` — one diff log per ISO week (e.g. `2026-19.md`) +- `logs/index.md` — auto-rebuilt index of all logs +- `state.json` — last-seen GUIDs per source, used by the scanner to compute deltas + +Logs are designed for **append-only** writes. The monthly synthesizer reads +the last 4 logs, distills topic-level changes, and updates `../topics/*.md`. + +## Manual scan + +```bash +cd anthropic-intelligence +pip install -r scripts/requirements.txt +python scripts/fetch_sources.py --output monitoring/logs/$(date -u +%Y-%V).md +``` diff --git a/anthropic-intelligence/monitoring/logs/.gitkeep b/anthropic-intelligence/monitoring/logs/.gitkeep new file mode 100644 index 0000000..e69de29 diff --git a/anthropic-intelligence/monitoring/state.json b/anthropic-intelligence/monitoring/state.json new file mode 100644 index 0000000..7902dc5 --- /dev/null +++ b/anthropic-intelligence/monitoring/state.json @@ -0,0 +1,5 @@ +{ + "version": 1, + "last_run": null, + "sources": {} +} diff --git a/anthropic-intelligence/sources.yaml b/anthropic-intelligence/sources.yaml new file mode 100644 index 0000000..239b236 --- /dev/null +++ b/anthropic-intelligence/sources.yaml @@ -0,0 +1,154 @@ +# Source registry for the Anthropic Intelligence monitoring pipeline. +# +# Each source has: +# id: stable slug used as filename / key +# name: human-readable name +# url: canonical URL +# feed: RSS/Atom URL if available; null otherwise (then we scrape) +# priority: P0 | P1 | P2 (see CADENCE.md) +# kind: blog | docs | release | x | reddit | github +# topics: list of topic slugs this source informs +# verified: true if URL has been hand-verified by a human +# +# When adding a new source, set verified: false and let the next reviewer flip it. + +sources: + # ---- P0: official Anthropic surfaces --------------------------------- + - id: anthropic-news + name: Anthropic News + url: https://www.anthropic.com/news + feed: https://www.anthropic.com/news/rss.xml + priority: P0 + kind: blog + topics: [all] + verified: false + + - id: anthropic-research + name: Anthropic Research + url: https://www.anthropic.com/research + feed: null + priority: P0 + kind: blog + topics: [research, models] + verified: false + + - id: anthropic-engineering + name: Anthropic Engineering Blog + url: https://www.anthropic.com/engineering + feed: null + priority: P0 + kind: blog + topics: [claude-code, tool-use, agents, prompting] + verified: false + + - id: claude-code-releases + name: Claude Code GitHub Releases + url: https://github.com/anthropics/claude-code/releases + feed: https://github.com/anthropics/claude-code/releases.atom + priority: P0 + kind: release + topics: [claude-code] + verified: false + + - id: anthropic-docs + name: Anthropic Docs + url: https://docs.anthropic.com/ + feed: null + priority: P0 + kind: docs + topics: [api, claude-code, tool-use, caching] + verified: false + + # ---- P1: Anthropic employees ---------------------------------------- + - id: erik-schluntz-blog + name: Erik Schluntz personal blog + url: https://www.erikschluntz.com/ + feed: null + priority: P1 + kind: blog + topics: [claude-code, agents] + verified: false + + - id: thariq-shihipar-x + name: Thariq Shihipar on X (author of "Unreasonable Effectiveness of HTML") + url: https://x.com/trq212 + feed: null + priority: P1 + kind: x + topics: [output-formats, claude-code] + verified: false + + - id: boris-cherny-x + name: Boris Cherny on X + url: https://x.com/bcherny + feed: null + priority: P1 + kind: x + topics: [claude-code, typescript, tooling] + verified: false + + - id: sholto-douglas-x + name: Sholto Douglas on X + url: https://x.com/_sholtodouglas + feed: null + priority: P1 + kind: x + topics: [scaling, models, research] + verified: false + + - id: cat-wu-x + name: Cat Wu on X (Claude Code PM) + url: https://x.com/_catwu + feed: null + priority: P1 + kind: x + topics: [claude-code, product] + verified: false + + # ---- P1: external high-signal observers ------------------------------ + - id: simon-willison + name: Simon Willison's Weblog + url: https://simonwillison.net/ + feed: https://simonwillison.net/atom/everything/ + priority: P1 + kind: blog + topics: [claude-code, tool-use, prompting, all] + verified: true + + # ---- P2: community signal ------------------------------------------ + - id: reddit-claudeai + name: r/ClaudeAI + url: https://www.reddit.com/r/ClaudeAI/ + feed: https://www.reddit.com/r/ClaudeAI/.rss + priority: P2 + kind: reddit + topics: [community, claude-code] + verified: false + + - id: reddit-aiagents + name: r/AI_Agents + url: https://www.reddit.com/r/AI_Agents/ + feed: https://www.reddit.com/r/AI_Agents/.rss + priority: P2 + kind: reddit + topics: [community, agents] + verified: false + +# Topic taxonomy. Topics referenced in sources[].topics must appear here. +topics: + - all + - output-formats + - claude-code + - tool-use + - caching + - agents + - hooks + - prompting + - models + - api + - research + - scaling + - product + - typescript + - tooling + - community diff --git a/anthropic-intelligence/topics/README.md b/anthropic-intelligence/topics/README.md new file mode 100644 index 0000000..c7c295c --- /dev/null +++ b/anthropic-intelligence/topics/README.md @@ -0,0 +1,38 @@ +# Topics + +Synthesized, versioned knowledge base articles. + +Each topic file follows this front-matter template: + +```yaml +--- +topic: output-formats-html-vs-markdown +status: stable | draft | deprecated +last_synthesized: 2026-05-12 +sources_consulted: + - id: anthropic-engineering + url: https://www.anthropic.com/engineering/... + fetched: 2026-05-12 + - id: simon-willison + url: https://simonwillison.net/2026/May/... + fetched: 2026-05-12 +related: + - prompting + - claude-code +--- +``` + +## Current topics + +| File | Status | Last synthesized | +|---|---|---| +| [output-formats-html-vs-markdown.md](./output-formats-html-vs-markdown.md) | draft | 2026-05-12 | + +## Planned topics (stubs to be filled) + +- `claude-code-best-practices.md` — hooks, skills, slash commands, MCP +- `prompt-caching.md` — cache breakpoints, hit-rate optimization, gotchas +- `tool-use.md` — schema design, parallel tool calls, error handling +- `agents-and-subagents.md` — when to use, isolation modes, prompt design +- `extended-thinking.md` — budget, output handling, when it actually helps +- `model-selection.md` — Opus vs Sonnet vs Haiku decision matrix per task From 891205a30019e2659d28f992d125a766f73acefe Mon Sep 17 00:00:00 2001 From: Klangschalen <171444708+Klangschalen@users.noreply.github.com> Date: Tue, 12 May 2026 09:52:10 +0200 Subject: [PATCH 2/5] feat(anthropic-intelligence): add weekly scan + monthly synthesis workflows GitHub Actions cron pipeline: - anthropic-weekly-scan.yml (Mon 06:00 UTC) runs fetch_sources.py over sources.yaml, writes monitoring/logs/YYYY-WW.md, opens PR - anthropic-monthly-synthesis.yml (1st 06:00 UTC) runs synthesize.py over last 4 weekly logs, updates topics/*.md via Claude API, opens PR Both workflows are manually dispatchable. Monthly synthesis requires the ANTHROPIC_API_KEY repo secret; weekly scan needs no secret. Python scripts use only feedparser + PyYAML + anthropic SDK to stay small. --- .../workflows/anthropic-monthly-synthesis.yml | 70 ++++++++ .github/workflows/anthropic-weekly-scan.yml | 64 +++++++ .../scripts/fetch_sources.py | 170 ++++++++++++++++++ .../scripts/requirements.txt | 4 + anthropic-intelligence/scripts/synthesize.py | 149 +++++++++++++++ 5 files changed, 457 insertions(+) create mode 100644 .github/workflows/anthropic-monthly-synthesis.yml create mode 100644 .github/workflows/anthropic-weekly-scan.yml create mode 100644 anthropic-intelligence/scripts/fetch_sources.py create mode 100644 anthropic-intelligence/scripts/requirements.txt create mode 100644 anthropic-intelligence/scripts/synthesize.py diff --git a/.github/workflows/anthropic-monthly-synthesis.yml b/.github/workflows/anthropic-monthly-synthesis.yml new file mode 100644 index 0000000..5406da2 --- /dev/null +++ b/.github/workflows/anthropic-monthly-synthesis.yml @@ -0,0 +1,70 @@ +name: anthropic-intelligence — monthly synthesis + +on: + schedule: + # 1st of every month at 06:00 UTC + - cron: '0 6 1 * *' + workflow_dispatch: + inputs: + topic: + description: 'Single topic slug to re-synthesize (empty = all)' + required: false + default: '' + +permissions: + contents: write + pull-requests: write + +concurrency: + group: anthropic-monthly-synthesis + cancel-in-progress: false + +jobs: + synthesize: + runs-on: ubuntu-latest + steps: + - uses: actions/checkout@v4 + + - uses: actions/setup-python@v5 + with: + python-version: '3.12' + cache: pip + cache-dependency-path: anthropic-intelligence/scripts/requirements.txt + + - name: Install dependencies + run: pip install -r anthropic-intelligence/scripts/requirements.txt + + - name: Run synthesizer + env: + ANTHROPIC_API_KEY: ${{ secrets.ANTHROPIC_API_KEY }} + ANTHROPIC_MODEL: ${{ vars.ANTHROPIC_MODEL || 'claude-opus-4-7' }} + TOPIC: ${{ github.event.inputs.topic }} + run: | + if [ -z "$ANTHROPIC_API_KEY" ]; then + echo "::error::ANTHROPIC_API_KEY secret not set. Add it under repo Settings > Secrets." + exit 1 + fi + cd anthropic-intelligence + python scripts/synthesize.py \ + --logs-dir monitoring/logs \ + --topics-dir topics \ + --sources sources.yaml \ + ${TOPIC:+--topic "$TOPIC"} + + - name: Create pull request + uses: peter-evans/create-pull-request@v6 + with: + branch: anthropic-intel/monthly-synthesis-${{ github.run_id }} + base: main + commit-message: 'docs(anthropic-intel): monthly synthesis' + title: '[anthropic-intel] Monthly synthesis: topic updates' + body: | + Automated monthly synthesis. Reviews `topics/*.md` against the last + four weekly logs and proposes updates. + + Please review each topic change individually and verify any new + claims against the linked sources before merging. + labels: anthropic-intel,automation,needs-review + add-paths: | + anthropic-intelligence/topics/** + anthropic-intelligence/engineers/** diff --git a/.github/workflows/anthropic-weekly-scan.yml b/.github/workflows/anthropic-weekly-scan.yml new file mode 100644 index 0000000..49414bd --- /dev/null +++ b/.github/workflows/anthropic-weekly-scan.yml @@ -0,0 +1,64 @@ +name: anthropic-intelligence — weekly scan + +on: + schedule: + # Every Monday at 06:00 UTC + - cron: '0 6 * * 1' + workflow_dispatch: + inputs: + priority: + description: 'Min priority to scan (P0/P1/P2)' + required: false + default: 'P2' + +permissions: + contents: write + pull-requests: write + +concurrency: + group: anthropic-weekly-scan + cancel-in-progress: false + +jobs: + scan: + runs-on: ubuntu-latest + steps: + - uses: actions/checkout@v4 + + - uses: actions/setup-python@v5 + with: + python-version: '3.12' + cache: pip + cache-dependency-path: anthropic-intelligence/scripts/requirements.txt + + - name: Install dependencies + run: pip install -r anthropic-intelligence/scripts/requirements.txt + + - name: Run scanner + env: + PRIORITY: ${{ github.event.inputs.priority || 'P2' }} + run: | + cd anthropic-intelligence + WEEK=$(date -u +%Y-%V) + python scripts/fetch_sources.py \ + --sources sources.yaml \ + --state monitoring/state.json \ + --output monitoring/logs/${WEEK}.md \ + --min-priority "$PRIORITY" + + - name: Create pull request + uses: peter-evans/create-pull-request@v6 + with: + branch: anthropic-intel/weekly-scan-${{ github.run_id }} + base: main + commit-message: 'chore(anthropic-intel): weekly scan' + title: '[anthropic-intel] Weekly scan: new signals' + body: | + Automated weekly scan of Anthropic + Claude Code sources. + + Review the new log under `anthropic-intelligence/monitoring/logs/` + and skim for anything worth promoting into a topic article. + labels: anthropic-intel,automation + add-paths: | + anthropic-intelligence/monitoring/logs/** + anthropic-intelligence/monitoring/state.json diff --git a/anthropic-intelligence/scripts/fetch_sources.py b/anthropic-intelligence/scripts/fetch_sources.py new file mode 100644 index 0000000..261e937 --- /dev/null +++ b/anthropic-intelligence/scripts/fetch_sources.py @@ -0,0 +1,170 @@ +"""Weekly scanner for the Anthropic Intelligence pipeline. + +Reads sources.yaml, fetches RSS/Atom feeds, compares against state.json, +emits a Markdown log of new entries. Sources without a feed are listed +with a manual-check note (we do not scrape arbitrary HTML). + +Usage: + python fetch_sources.py \ + --sources sources.yaml \ + --state monitoring/state.json \ + --output monitoring/logs/2026-19.md \ + --min-priority P2 + +Exit codes: + 0 — success (log written, even if empty) + 1 — unrecoverable error (bad config, IO failure) +""" +from __future__ import annotations + +import argparse +import datetime as dt +import json +import pathlib +import sys +from typing import Any + +import feedparser +import yaml + +PRIORITY_ORDER = {"P0": 0, "P1": 1, "P2": 2} + + +def parse_args() -> argparse.Namespace: + p = argparse.ArgumentParser() + p.add_argument("--sources", required=True, type=pathlib.Path) + p.add_argument("--state", required=True, type=pathlib.Path) + p.add_argument("--output", required=True, type=pathlib.Path) + p.add_argument("--min-priority", default="P2", choices=PRIORITY_ORDER.keys()) + return p.parse_args() + + +def load_yaml(path: pathlib.Path) -> dict[str, Any]: + with path.open() as f: + return yaml.safe_load(f) + + +def load_state(path: pathlib.Path) -> dict[str, Any]: + if not path.exists(): + return {"version": 1, "last_run": None, "sources": {}} + with path.open() as f: + return json.load(f) + + +def save_state(path: pathlib.Path, state: dict[str, Any]) -> None: + path.parent.mkdir(parents=True, exist_ok=True) + with path.open("w") as f: + json.dump(state, f, indent=2, sort_keys=True) + f.write("\n") + + +def scan_feed(source: dict[str, Any], seen: set[str]) -> list[dict[str, Any]]: + feed = feedparser.parse(source["feed"]) + new_entries = [] + for entry in feed.entries: + guid = entry.get("id") or entry.get("link") + if not guid or guid in seen: + continue + new_entries.append({ + "guid": guid, + "title": entry.get("title", "(no title)"), + "link": entry.get("link", ""), + "published": entry.get("published", entry.get("updated", "")), + "summary": entry.get("summary", "")[:500], + }) + return new_entries + + +def render_log( + run_started: dt.datetime, + by_source: dict[str, list[dict[str, Any]]], + sources_by_id: dict[str, dict[str, Any]], + manual_check: list[str], +) -> str: + lines = [ + f"# Weekly scan {run_started.strftime('%Y-W%V')}", + "", + f"_Run started: {run_started.isoformat()}_", + "", + ] + total = sum(len(v) for v in by_source.values()) + lines.append(f"**{total} new entries** across {len(by_source)} sources with deltas.") + lines.append("") + + for source_id, entries in sorted(by_source.items()): + if not entries: + continue + meta = sources_by_id[source_id] + lines.append(f"## {meta['name']} ({meta['priority']} · {meta['kind']})") + lines.append(f"Source: {meta['url']}") + lines.append("") + for e in entries: + lines.append(f"- **{e['title']}**") + if e["published"]: + lines.append(f" _{e['published']}_") + if e["link"]: + lines.append(f" <{e['link']}>") + if e["summary"]: + summary = e["summary"].replace("\n", " ").strip() + lines.append(f" > {summary}") + lines.append("") + + if manual_check: + lines.append("## Manual-check sources (no feed)") + lines.append("") + for sid in manual_check: + meta = sources_by_id[sid] + lines.append(f"- [{meta['name']}]({meta['url']}) — {meta['priority']} · {meta['kind']}") + lines.append("") + + return "\n".join(lines) + + +def main() -> int: + args = parse_args() + config = load_yaml(args.sources) + state = load_state(args.state) + + min_priority = PRIORITY_ORDER[args.min_priority] + sources = config["sources"] + sources_by_id = {s["id"]: s for s in sources} + + run_started = dt.datetime.now(dt.timezone.utc) + by_source: dict[str, list[dict[str, Any]]] = {} + manual_check: list[str] = [] + + for source in sources: + if PRIORITY_ORDER[source["priority"]] > min_priority: + continue + if not source.get("feed"): + manual_check.append(source["id"]) + continue + + seen_guids = set(state["sources"].get(source["id"], {}).get("seen", [])) + try: + new_entries = scan_feed(source, seen_guids) + except Exception as e: + print(f"warn: failed to scan {source['id']}: {e}", file=sys.stderr) + continue + + by_source[source["id"]] = new_entries + # Update state — keep last 200 guids per source to bound growth. + merged = list(seen_guids) + [e["guid"] for e in new_entries] + state["sources"][source["id"]] = { + "seen": merged[-200:], + "last_scanned": run_started.isoformat(), + } + + state["last_run"] = run_started.isoformat() + + args.output.parent.mkdir(parents=True, exist_ok=True) + args.output.write_text(render_log(run_started, by_source, sources_by_id, manual_check)) + save_state(args.state, state) + + total = sum(len(v) for v in by_source.values()) + print(f"wrote {args.output} — {total} new entries across {len(by_source)} sources") + return 0 + + +if __name__ == "__main__": + sys.exit(main()) diff --git a/anthropic-intelligence/scripts/requirements.txt b/anthropic-intelligence/scripts/requirements.txt new file mode 100644 index 0000000..c2df17a --- /dev/null +++ b/anthropic-intelligence/scripts/requirements.txt @@ -0,0 +1,4 @@ +feedparser>=6.0.11 +PyYAML>=6.0 +requests>=2.32 +anthropic>=0.40.0 diff --git a/anthropic-intelligence/scripts/synthesize.py b/anthropic-intelligence/scripts/synthesize.py new file mode 100644 index 0000000..7fd2d7d --- /dev/null +++ b/anthropic-intelligence/scripts/synthesize.py @@ -0,0 +1,149 @@ +"""Monthly synthesizer for the Anthropic Intelligence pipeline. + +Reads the last N weekly logs and the existing topic articles, asks Claude to +produce an updated version of each topic article that incorporates any newly +significant signals. + +Usage: + python synthesize.py \ + --logs-dir monitoring/logs \ + --topics-dir topics \ + --sources sources.yaml \ + [--topic output-formats-html-vs-markdown] + +Requires ANTHROPIC_API_KEY in env. Optional ANTHROPIC_MODEL (default opus-4-7). + +The script is conservative: it only proposes diffs that cite specific log +entries. If no log entries map to a topic, the article is left untouched. +""" +from __future__ import annotations + +import argparse +import datetime as dt +import os +import pathlib +import re +import sys +from typing import Any + +import yaml +from anthropic import Anthropic + +DEFAULT_LOG_WINDOW = 4 # last 4 weekly logs + +SYSTEM_PROMPT = """You are the maintainer of an internal knowledge base on +Anthropic, Claude Code, and AI engineering best practices. + +You receive: +1. The current full content of a topic article (Markdown with YAML front-matter). +2. The last 4 weekly scan logs from our monitoring pipeline. +3. The source registry (so you know which IDs map to which URLs). + +Your job: +- If no log entries are relevant to this topic, return the article unchanged + except for updating `last_synthesized` in the front-matter. +- If log entries ARE relevant, integrate them into the article. Add new + sources to `sources_consulted`. Be precise: cite the specific log entry and + link the source URL. +- Never invent quotes or facts not present in the logs or the existing article. +- Keep the article structure (front-matter, sections) intact. +- Output ONLY the updated Markdown file, with no commentary, no code fences. +""" + + +def parse_args() -> argparse.Namespace: + p = argparse.ArgumentParser() + p.add_argument("--logs-dir", required=True, type=pathlib.Path) + p.add_argument("--topics-dir", required=True, type=pathlib.Path) + p.add_argument("--sources", required=True, type=pathlib.Path) + p.add_argument("--topic", default=None, help="Single topic slug; default = all") + p.add_argument("--window", type=int, default=DEFAULT_LOG_WINDOW) + p.add_argument("--model", default=os.environ.get("ANTHROPIC_MODEL", "claude-opus-4-7")) + return p.parse_args() + + +def recent_logs(logs_dir: pathlib.Path, window: int) -> list[pathlib.Path]: + logs = sorted(logs_dir.glob("*.md")) + return logs[-window:] + + +def topic_files(topics_dir: pathlib.Path, only: str | None) -> list[pathlib.Path]: + files = sorted(p for p in topics_dir.glob("*.md") if p.name != "README.md") + if only: + files = [p for p in files if p.stem == only] + return files + + +def bump_last_synthesized(content: str, today: str) -> str: + return re.sub( + r"^last_synthesized:\s*\S+", + f"last_synthesized: {today}", + content, + count=1, + flags=re.MULTILINE, + ) + + +def synthesize_one( + client: Anthropic, + model: str, + topic_path: pathlib.Path, + logs: list[pathlib.Path], + sources_yaml: str, +) -> str: + article = topic_path.read_text() + logs_concat = "\n\n---\n\n".join( + f"# Log: {p.name}\n\n{p.read_text()}" for p in logs + ) + user_msg = ( + f"## Topic article ({topic_path.name})\n\n{article}\n\n" + f"## Weekly logs (most recent last)\n\n{logs_concat}\n\n" + f"## Source registry (sources.yaml)\n\n```yaml\n{sources_yaml}\n```\n" + ) + resp = client.messages.create( + model=model, + max_tokens=8000, + system=SYSTEM_PROMPT, + messages=[{"role": "user", "content": user_msg}], + ) + parts = [b.text for b in resp.content if getattr(b, "type", None) == "text"] + return "".join(parts).strip() + + +def main() -> int: + args = parse_args() + if not os.environ.get("ANTHROPIC_API_KEY"): + print("ANTHROPIC_API_KEY not set", file=sys.stderr) + return 1 + + client = Anthropic() + sources_yaml = args.sources.read_text() + logs = recent_logs(args.logs_dir, args.window) + topics = topic_files(args.topics_dir, args.topic) + today = dt.date.today().isoformat() + + if not logs: + print("no weekly logs found — nothing to synthesize") + # Still bump last_synthesized so we keep a heartbeat. + for t in topics: + t.write_text(bump_last_synthesized(t.read_text(), today)) + return 0 + + for t in topics: + print(f"synthesizing {t.name} against {len(logs)} logs…") + try: + updated = synthesize_one(client, args.model, t, logs, sources_yaml) + except Exception as e: + print(f"warn: synthesis failed for {t.name}: {e}", file=sys.stderr) + continue + if not updated.startswith("---"): + print(f"warn: model returned non-frontmatter output for {t.name}; skipping write", file=sys.stderr) + continue + t.write_text(updated + ("\n" if not updated.endswith("\n") else "")) + print(f" updated {t.name}") + + return 0 + + +if __name__ == "__main__": + sys.exit(main()) From b541a795b349196a9c8b10f968d94e4009b7e1c3 Mon Sep 17 00:00:00 2001 From: Klangschalen <171444708+Klangschalen@users.noreply.github.com> Date: Tue, 12 May 2026 09:55:01 +0200 Subject: [PATCH 3/5] =?UTF-8?q?docs(anthropic-intel):=20add=20first=20doss?= =?UTF-8?q?ier=20=E2=80=94=20HTML=20vs=20Markdown=20as=20Claude=20output?= =?UTF-8?q?=20format?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Synthesizes the May 2026 shift after Thariq Shihipar's (Anthropic Claude Code) "Unreasonable Effectiveness of HTML" post: - Thesis & token economics (incl. measured ~2-4× output cost) - 9 use-case categories where HTML wins, with the 20 Thariq examples - Carve-outs where Markdown still wins (READMEs, Slack, LLM-to-LLM, etc.) - Counter-arguments (Kurtis Redux, HN, security, reviewability) - Concrete recommendations for our systems: agent prompts, skill design, knowledge base, content engine, Filament dashboards - Action items mapped to klangschalen/* repos Marked status: draft — Twitter source (Thariq's original) was rate-limited during research; pending direct re-fetch on next monthly synthesis. --- .../topics/output-formats-html-vs-markdown.md | 207 ++++++++++++++++++ 1 file changed, 207 insertions(+) create mode 100644 anthropic-intelligence/topics/output-formats-html-vs-markdown.md diff --git a/anthropic-intelligence/topics/output-formats-html-vs-markdown.md b/anthropic-intelligence/topics/output-formats-html-vs-markdown.md new file mode 100644 index 0000000..8bca669 --- /dev/null +++ b/anthropic-intelligence/topics/output-formats-html-vs-markdown.md @@ -0,0 +1,207 @@ +--- +topic: output-formats-html-vs-markdown +status: draft +last_synthesized: 2026-05-12 +first_published: 2026-05-12 +related: + - claude-code + - prompting + - tool-use + - content-engine +sources_consulted: + - id: thariq-x-original + name: "Thariq Shihipar — 'Using Claude Code: The Unreasonable Effectiveness of HTML' (X, May 8 2026)" + url: https://twitter.com/trq212/status/2052809885763747935 + fetched: 2026-05-12 + status: unreachable-during-research + - id: thariq-examples + name: "Thariq — 20 HTML example artifacts" + url: https://thariqs.github.io/html-effectiveness/ + fetched: 2026-05-12 + - id: simon-willison-commentary + name: "Simon Willison — 'Using Claude Code: The Unreasonable Effectiveness of HTML' (link blog)" + url: https://simonwillison.net/2026/May/8/unreasonable-effectiveness-of-html/ + fetched: 2026-05-12 + - id: pasquale-deep-dive + name: "Pasquale Pillitteri — 'HTML vs Markdown in Claude Code: Why Anthropic's Thariq Changed the Default'" + url: https://pasqualepillitteri.it/en/news/2243/html-vs-markdown-claude-code-thariq-anthropic + fetched: 2026-05-12 + - id: kurtis-counter + name: "Kurtis Redux — 'The Unreasonable Ineffectiveness of HTML' (counter-piece)" + url: https://kurtis-redux.medium.com/the-unreasonable-ineffectiveness-of-html-5bd01ae1e879 + fetched: 2026-05-12 + - id: uxhack-substack + name: "UX Hack — 'Markdown is Dead? Why Claude is Pivoting back to HTML'" + url: https://uxhack.substack.com/p/markdown-is-dead-why-claude-is-pivoting + fetched: 2026-05-12 + - id: seo-suedwest-de + name: "SEO Südwest — Markdown-Files für KI-Optimierung (DE perspective on related question)" + url: https://www.seo-suedwest.de/10654-wie-sinnvoll-sind-markdown-files-fuer-die-ki-optimierung.html + fetched: 2026-05-12 + - id: dogum-html-artifacts-skill + name: "dogum/html-artifacts — Claude skill for HTML artifacts (community)" + url: https://github.com/dogum/html-artifacts + fetched: 2026-05-12 +--- + +# HTML vs Markdown as Claude output format (May 2026) + +## TL;DR + +- On **May 8, 2026** Thariq Shihipar (Anthropic, Claude Code team) published *"Using Claude Code: The Unreasonable Effectiveness of HTML"* on X. Within 16 hours: ~4.4M views. +- His claim: **HTML is the format Anthropic itself is increasingly defaulting to** for plans, code reviews, design systems, reports — wherever the output is meant to be *read* rather than further processed by tooling. +- Cost: HTML generation consumes **2–4× more output tokens** than Markdown for the same content. On Opus 4.7 (1M context) that's still <1% of context, ~€0.08 per detailed artifact. +- Markdown is **not dead**. There is a clean carve-out: READMEs, Slack/Discord snippets, LLM-to-LLM, RAG corpora, plain-text pipelines, anything humans need to edit by hand. +- For **our systems**: switch read-only, presentation-grade outputs (plans, reports, code reviews, dashboards, content-engine drafts) to HTML. Keep agent-to-agent, indexed, and edited-by-human outputs in Markdown. + +## The thesis (Thariq, paraphrased) + +> "I've started preferring HTML as an output format instead of Markdown and increasingly see this being used by others on the Claude Code team, this is why. … As agents have become more and more powerful, I have felt that Markdown has become a restricting format." +> — quoted via Threads / Glenn Gabe ([source](https://www.threads.com/@glenngabe/post/DYNbPjOkeA-/from-an-anthropic-engineer-html-beats-markdown-an-anthropic-engineer-argues)) + +Five arguments Thariq makes: + +1. **Information density** — HTML embeds tables, SVG, CSS, JS, interactions in one file. Markdown needs external workarounds. +2. **Readability past ~100 lines** — Markdown files become "effectively unreadable"; HTML supports tabs, collapsibles, responsive layout. +3. **Sharing convenience** — HTML renders natively in any browser. Markdown needs an editor or converter. +4. **Two-way interaction** — HTML enables sliders, knobs, buttons. Documents become exploratory tools, not static dumps. +5. **Joy factor** — well-crafted HTML is more pleasant to read than "Markdown brackets." + +Simon Willison ([link blog](https://simonwillison.net/2026/May/8/unreasonable-effectiveness-of-html/)) called the piece "thought-provoking" and said he'll "experiment more with rich HTML explanations in response to ad-hoc prompts" — a notable shift for someone whose three-year default was Markdown. + +## Token economics (measured) + +From Pasquale Pillitteri's [deep dive](https://pasqualepillitteri.it/en/news/2243/html-vs-markdown-claude-code-thariq-anthropic), measuring a real PR-review task (280 modified lines, 4 files, 3 findings): + +| Format | Output tokens | % of Opus 4.7 (1M) context | Approx. cost | +|---|---:|---:|---:| +| Markdown | ~1,140 | 0.11% | ~€0.017 | +| Lean HTML | ~2,760 | 0.28% | ~€0.041 | +| Full HTML (with SVG, color coding) | ~5,480 | 0.55% | ~€0.082 | + +Takeaways: + +- The 2–4× token premium is **real but small in absolute terms** on Opus 4.7. The historical "Markdown saves tokens" argument was rooted in tight context windows that no longer exist. +- Latency premium is the more interesting cost: 2–4× more output tokens means 2–4× generation time. Matters for interactive UX; doesn't matter for async pipelines. + +## Where HTML wins (9 categories × 20 examples) + +From [thariqs.github.io/html-effectiveness](https://thariqs.github.io/html-effectiveness/): + +| # | Example | Category | Notable technique | +|---:|---|---|---| +| 1 | Three code approaches | Exploration | Side-by-side trade-off layout | +| 2 | Visual design directions | Design | Live rendering of layout/palette | +| 3 | Implementation plan | Planning | Mixed timeline + data-flow + risk table | +| 4 | Annotated pull request | Code review | Diff with margin notes + severity tags | +| 5 | PR writeup for reviewers | Code review | Motivation → before/after → file tour | +| 6 | Module map | Architecture | Boxes-and-arrows graph, highlighted paths | +| 7 | Living design system | Design system | Copyable swatches/tokens | +| 8 | Component variants | Design | Contact-sheet of all states | +| 9 | Animation sandbox | Design | Sliders for duration/easing | +| 10 | Clickable flow | Prototyping | 4 linked screens, interaction testing | +| 11 | SVG figure sheet | Diagrams | Inline SVG, hand-tweakable | +| 12 | Annotated flowchart | Diagrams | Clickable deploy-pipeline steps + timings | +| 13 | Arrow-key slide deck | Presentation | No export, keyboard-driven | +| 14 | How a feature works | Explainer | Tabs + code + FAQ + TL;DR | +| 15 | Concept explainer | Explainer | Live ring sim + glossary | +| 16 | Weekly status | Reporting | Color-coded timeline + small charts | +| 17 | Incident timeline | Reporting | Minute-by-minute log + checklist | +| 18 | Ticket triage board | Tooling | Drag-and-drop + markdown export | +| 19 | Feature flag editor | Tooling | Toggle deps + diff export | +| 20 | Prompt tuner | Tooling | Live re-render on slot edits | + +Note how many of these are **internal tooling artifacts**, not customer deliverables — i.e. exactly the kind of outputs *we* generate constantly across `klangschalen/projekt-board`, `quality-system`, `security-monitoring`, `weboffice`. + +## Where Markdown still wins + +From Pasquale's piece, cross-checked against the Kurtis Redux [counter-piece](https://kurtis-redux.medium.com/the-unreasonable-ineffectiveness-of-html-5bd01ae1e879): + +- **Repository READMEs** — GitHub/GitLab render Markdown natively; HTML breaks collaborative editing and PR diffs. +- **Slack / Discord / Notion snippets** — code fences and basic Markdown are universal. +- **LLM-to-LLM and RAG corpora** — downstream parsers prefer Markdown; HTML adds noise to indexing. +- **Long git-history files / specs that get hand-edited** — "If it is a spec sheet of something complex, I want to be able to go in and edit what was produced. With an HTML document, that is much harder" (tmhrtly, HN, quoted in Pasquale). +- **Personal memos** — regeneration cost > value. +- **Email / RSS / newsletters** — mail-client HTML rendering is famously unpredictable. + +## Counter-arguments worth taking seriously + +1. **Security** (Kurtis Redux): "Running unvetted, AI-generated JS risks XSS or local data leaks." Real risk for HTML artifacts that include ` + +