Code415 Radar

by Ziyu Guo · @Code415zg

What people are paying attention to in AI, LLMs and CS today. Every item comes with a short path to learn it and a small test to try it yourself. Updated every evening, Japan time.

Tuesday, November 10, 2026

20 items · Claude Fable 5.2 ships; Meta's $0.10 Muse Ember aims at subagents
  1. #1Models & launches

    Claude Fable 5.2 ships at $8 in, $40 out, one model with two safety tiers

    Anthropic released Claude Fable 5.2 on Nov 9 on all its platforms, including AWS, Google Cloud and Azure, with API id claude-fable-5-2, and Claude Mythos 5.2 for vetted cyber and life sciences organizations. Anthropic says both are the same underlying model, with Fable carrying stronger cyber and biology safeguards. Against Opus 5.5 it reports FrontierSWE v2 at 69.9% vs 62.3%, Terminal-Bench-Science at 74.6% vs 58.7% and Remote Labor Index at 41.3% vs 21.3%; it also adds Advisor and Orchestrator modes that pair Fable with smaller Claude models, and preserved thinking now applies to every API account.

    Heat · HN front page: main launch thread about 595 comments, a second submission about 300 points and 118 comments; covered by TechCrunch, The Verge and CNBC
    What people foundPricing is $8 per M input and $40 per M output tokens, with an optional fast mode at $16 and $80 that generates up to 2.5x faster. Anthropic itself still recommends starting with Opus 5.5 for most coding and knowledge work and moving up to Fable only for the hardest tasks; note the API default effort for Fable is high while Claude apps and Claude Code default to medium.
    Learn it15 min · 5 steps

    Key ideas

    Effort level
    A setting from low up to max that controls how much the model thinks, trading tokens and latency for quality.
    Advisor and Orchestrator
    Two ways to mix models: a smaller Claude model consults Fable on hard steps, or Fable plans and hands simple subtasks to smaller models.
    Preserved thinking
    An API feature that keeps the model's earlier reasoning intact across turns so clients cannot edit it, now on for all accounts.

    Steps

    1. Read the Anthropic announcement first, focusing on the pricing, effort and "which model to start with" sections.
    2. Open the Fable 5.2 model overview in the Claude docs and note the 1M context, 128K max output and the API constraints: adaptive thinking always on, no forced tool use, no temperature or top_p.
    3. Skim the effort documentation linked from the overview to see how effort changes token use.
    4. Compare the benchmark table rows that match your own work, such as FrontierSWE for coding agents.
    5. Self check: for a task where Opus 5.5 already passes, what would justify paying Fable prices and its extra output tokens?
    Try it30 min · 6 steps
    You need: Python 3, the official Anthropic SDK, an Anthropic API key with billing; about a few dollars of credit

    Steps

    1. Pick three real tasks from your own backlog, for example a bug fix prompt, a code review prompt and a refactor plan.
    2. Send each prompt to claude-fable-5-2 and to Opus 5.5 using the Messages API, leaving out temperature and forced tool choice since Fable rejects them.
    3. Log input tokens, output tokens and wall time from each response's usage field.
    4. Compute cost per task with $8 and $40 per M tokens for Fable and Opus 5.5 list prices from the pricing page.
    5. Repeat the Fable calls at a lower effort setting per the effort docs and compare quality and tokens.
    6. Grade the answers blind and decide which tasks, if any, deserve Fable.

    Small angles to try

    • Try fast mode on one task and check whether 2x price buys enough latency for interactive use.
    • In Claude Code, run the same task at medium and high effort and compare the diffs.
    • Read the Advisor docs and sketch how a Haiku 5.5 loop could call Fable only on failures.
  2. #2Models & launches

    Meta's Muse Ember: a $0.10 per M token subagent model with 1M context

    Meta released Muse Ember, its smallest Muse model, built for high volume agent work such as tool calls, coding subtasks, routing and extraction. It natively handles text, images, audio and video, has a 1M token context window and up to 512K output tokens, and is available as muse-ember-1.0 on the Meta Model API with Responses API support, plus Google Cloud and Oracle Cloud. Meta's post does not say the weights are open.

    Heat · HN, about 220 points and 93 comments; covered by TechCrunch
    What people foundPrice is $0.10 in, $0.004 cached in and $0.50 out per M tokens for prompts up to 200K, tripling above that. Meta's own table ties it with Claude Haiku 5.5 at 36 on the Artificial Analysis Index and beats Haiku on Terminal-Bench 4.0, 40.9% vs 39.2%, but Haiku leads on FrontierCode 2.0, 34.9% vs 27.2%, so test it on your own coding subtasks before swapping.
    Learn it15 min · 4 steps

    Key ideas

    Subagent model
    A cheap fast model that a larger agent calls for narrow jobs like reading files, routing or extracting fields.
    Tiered context pricing
    The per token price rises once a prompt passes a size threshold, here 200K tokens.
    Cached input
    Repeated prompt prefixes billed at a much lower rate, which matters for agents that resend the same context.

    Steps

    1. Read the Meta blog post on Muse Ember first, especially the pricing and benchmark tables.
    2. Read the TechCrunch article for context on where Ember sits in the Muse lineup.
    3. Note which benchmarks Ember wins and loses against Haiku 5.5 and which match your workload.
    4. Self check: for a job that sends a 300K token prompt, what is the input cost per call, and why is it not $0.03?
    Try it30 min · 5 steps
    You need: Meta Model API key, Python 3 or any HTTP client; optionally an Anthropic key for a Haiku 5.5 comparison

    Steps

    1. Collect 20 small extraction or routing cases from your own data, each with an expected answer.
    2. Following the Meta Model API docs, call muse-ember-1.0 on each case with a fixed instruction prompt.
    3. Score exact match accuracy and record tokens and latency per call.
    4. Run the same cases on your current small model, such as Haiku 5.5, and compare accuracy and cost per 1,000 calls.
    5. Write down the cheapest model that meets your accuracy bar.

    Small angles to try

    • Feed one long log file near 200K tokens and check retrieval of a planted line.
    • Try an image input case such as reading a screenshot of an error.
    • Measure how much the cached input price saves when the system prompt is reused.
  3. #3Models & launches

    Artificial Analysis: Fable 5.2 ranks first at 65, using 275M output tokens

    Independent benchmarker Artificial Analysis scores Claude Fable 5.2 in its Max reasoning variant at 65 on its Intelligence Index, first of 74 models, against a median of 40. It used 275M output tokens to run the index versus a median of 72.8M, about 3.8 times more, and cost $26.54 per index task. It measured 98 output tokens per second but a time to first answer token of about 216 seconds, versus a median near 12 seconds.

    Heat · HN, about 340 points and 240 comments in its own thread
    What people foundPer token list price says little here: a model that writes nearly 4x the median output tokens can cost far more per task than its rate card suggests, and the 216 second wait before the first answer token makes Max effort a poor fit for interactive loops. Measure tokens and latency per task at the effort level you will actually ship.
    Learn it15 min · 4 steps

    Key ideas

    Cost per task
    Total spend to finish one benchmark task, combining price per token with how many tokens the model emits.
    Time to first answer token
    How long a reasoning model thinks before visible output starts, which drives perceived latency.
    Verbosity
    How many output tokens, including reasoning, a model spends compared with peers on the same work.

    Steps

    1. Open the Artificial Analysis model page for Claude Fable 5.2 first and find the intelligence, speed, token use and cost charts.
    2. Compare its output token count and cost per task with two models you already use on the same site.
    3. Re read the Anthropic launch post's effort section to see why Max effort inflates tokens.
    4. Self check: if two models cost the same per token but one emits 3.8x the output tokens, how much more does each task cost on output?
    Try it30 min · 5 steps
    You need: Python 3, an Anthropic API key with billing; no other services

    Steps

    1. Choose five tasks from your own work with clear pass or fail checks.
    2. Run each on claude-fable-5-2 at two effort levels described in the Anthropic effort docs.
    3. From each response's usage field, record output tokens, plus time to first token using streaming.
    4. Compute cost per passed task, not per call, at $40 per M output tokens.
    5. Plot or tabulate effort level against pass rate, tokens and cost.

    Small angles to try

    • Repeat with Opus 5.5 at its default effort and compare cost per passed task.
    • Cap max output tokens and see where quality breaks.
    • Check whether the 216 second wait shows up on your short tasks or only on hard ones.
  4. #4Research

    Meta FAIR's e-means lands in Faiss: k-means in about a tenth the epochs

    A Meta FAIR team with logos for Ecole des Ponts released e-means, arXiv 2611.09501, a k-means replacement that uses mini batch updates with exponential moving averages instead of full Lloyd passes. The project page reports reaching a test loss below Lloyd's 25 epoch result in 1.2 to 3 epochs, and wall clock speedups of 10 to 45x on GPU over Flash-KMeans and 8 to 15x on CPU over Faiss. The code already ships in the Faiss repository under faiss/contrib/e_means.

    Heat · HN, about 390 points but only 37 comments
    What people foundUsable today: the project page shows from faiss.contrib.e_means import Emeans, with NumpyEmeans for NumPy input and 5 epochs by default. Since k-means trains IVF vector indexes and clusters embeddings, faster clustering directly shortens RAG index builds.
    Learn it15 min · 4 steps

    Key ideas

    Lloyd's algorithm
    Classic k-means that alternates assigning every point to its nearest centroid and recomputing centroids, over the full dataset each epoch.
    Exponential moving average
    A running average that blends each new mini batch estimate into the centroid with a decaying weight.
    IVF index
    A vector index that clusters vectors with k-means and searches only the nearest clusters at query time.

    Steps

    1. Read the e-means project page first for the method summary, results and code snippet.
    2. Skim the arXiv abstract and the figures comparing loss per epoch with Lloyd's algorithm.
    3. Look at the faiss/contrib/e_means folder in the Faiss GitHub repository to see the class interface.
    4. Self check: why can a mini batch method beat full passes in epochs, and what could go wrong if batches are too small?
    Try it30 min · 5 steps
    You need: Python 3, Faiss from a recent source checkout that includes contrib/e_means, PyTorch or NumPy; CPU is enough, GPU optional; no API key needed

    Steps

    1. Export 100K or more embeddings from your own data, or generate random vectors, as a float32 array.
    2. Train standard Faiss k-means with 25 iterations and record time and final loss.
    3. Train Emeans or NumpyEmeans with the same k using the snippet from the project page and record time.
    4. Compute the mean squared distance to assigned centroids on a held out split for both runs.
    5. Compare loss and wall time and note the speedup on your hardware.

    Small angles to try

    • Vary k from 256 to 16K and see where the speedup grows.
    • Build an IVF index from each set of centroids and compare recall at a fixed nprobe.
    • Try 1, 2 and 5 epochs to find the smallest that matches Lloyd's loss.
  5. #5Trends × tech

    Japan's breach wave × LLMjacking: stolen cloud keys spent on AI calls

    Amid a run of Japanese breach stories, online printer King Printers published its final report on Nov 9 about a different attack. From 06:51 JST on Sep 10, an attacker used the company's infrastructure credentials from several IP addresses to make bulk calls to a generative AI service and created new credentials; the abuse ran about 7 hours until the AI provider imposed a usage restriction at 13:44. External forensics found no access to customer data, and neither the cloud nor the AI provider is named.

    Heat · #9 in the ITmedia NEWS access ranking on 2026-11-10, in a top 10 dominated by breach stories
    What people foundKing Printers says it will drop static credentials for infrastructure, issue temporary credentials only when needed, delete unused keys and redesign access to least privilege. The practical lesson: the provider's limit, not the victim's monitoring, stopped the abuse, so put your own spend alerts and quotas on any key that can call a model.
    Learn it15 min · 4 steps

    Key ideas

    LLMjacking
    Using stolen cloud or API credentials to run large language model calls on someone else's bill.
    Static vs temporary credentials
    Long lived access keys stay valid until revoked, while short lived tokens expire on their own and limit damage.
    Least privilege
    Granting each role or key only the permissions its job needs, so a leaked key cannot reach model APIs it never uses.

    Steps

    1. Read the ITmedia NEWS article first, in Japanese or through a translator.
    2. List what the attacker did: used existing keys, created new ones, called an AI service.
    3. Read your cloud provider's guidance on temporary credentials and budget alerts.
    4. Self check: which single control in your own account would have stopped this within minutes instead of 7 hours?
    Try it30 min · 5 steps
    You need: Read access to your own cloud account's IAM and billing consoles; no API key needed beyond your own

    Steps

    1. Export the list of long lived access keys in your own cloud account with their last used dates.
    2. Flag any key older than 90 days or unused in 30 days for rotation or deletion.
    3. Check which of those identities have permission to invoke hosted model services and remove it where not needed.
    4. Set a budget alert and, where supported, a quota on model API usage in your own account.
    5. Write a short runbook entry for what to do when that alert fires.

    Small angles to try

    • Audit your LLM vendor API keys for per key spend limits.
    • Check whether your logs would show creation of new credentials by an existing key.
    • Search your own repos for committed keys with a local secret scanner.
  6. #6Models & launches

    Amazon team swaps Sonnet 4.6 for Strands Decider E4B, cuts triage cost 98%

    The Strands Agents blog says an Amazon team replaced Claude Sonnet 4.6 with Strands Decider E4B, a Gemma 4 based decision model, for labeling internal tickets against a catalog of 20 labels plus a none option. Decider scores each option with a probability instead of generating JSON, so output fell from about 170 tokens to 1. Cost per million tickets dropped from about $22,200 to about $500, and average call time from 4,215 ms to 897 ms.

    Heat · HN thread posted Nov 10; Algolia search showed 242 points and 80 comments, while earlier checks showed far fewer, so treat the count as approximate
    What people foundThe useful gotchas are in the details: reordering JSON keys in identical content moved output probabilities by up to 0.19, so the team now sorts keys, and the 4,096 token window means long tickets lose their oldest comments. The quality claim that it "performed just as well" comes from the vendor with no published accuracy numbers, and the team rolled out through a DUAL mode that ran both models side by side first.
    Learn it15 min · 4 steps

    Key ideas

    Decision model
    A small model trained to return a probability for each option in a fixed list instead of writing free text.
    Constrained classification
    Picking from known labels lets you skip parsing generated JSON and read a calibrated score per label.
    Shadow or dual run
    Running the old and new model on the same live traffic and comparing results before switching over.

    Steps

    1. Read the Strands blog post first, focusing on the cost table, the token counts and the AppConfig switch with BEDROCK, DUAL and DECIDER modes.
    2. Open the strands-labs/strands-decider README and note the three question types: choice, noul for yes or no, and score for ordered rubrics.
    3. Compare the per ticket cost math: about $0.0222 with Sonnet versus about $0.0005 with Decider, and note that the $500 figure includes headroom over full utilization.
    4. Self check: why does sorting JSON keys matter for a model that scores options, and what accuracy evidence would you want before copying this switch?
    Try it30 min · 5 steps
    You need: Python with pip, a laptop CPU or Apple silicon or a CUDA GPU; the 2B Qwen model runs on CPU. No API key needed.

    Steps

    1. Install the package with pip install strands-decider.
    2. Write 20 sample tickets of your own, or reuse old tickets you are allowed to use, each with a known correct team label.
    3. Run one ticket with strands-decider ask StrandsAgents/strands-decider-2B-qwen3.5-v1-2610 --state "<ticket text>" --choice "Which team should handle this?=billing,sales,retail", swapping in your own label list.
    4. Loop over all 20 tickets with a short script and record accuracy and wall time per call.
    5. Repeat the run with the JSON fields of each ticket in a different key order and compare how much the probabilities move.

    Small angles to try

    • Start the HTTP server with strands-decider serve StrandsAgents/strands-decider-2B-qwen3.5-v1-2610 --port 8000 and call it from your own triage script.
    • If you have about 15 GB of GPU memory, install from the GitHub main branch as the README describes and try the E4B Gemma 4 model the Amazon team used.
    • Add a noul question such as urgency to the same call and see whether it agrees with your own judgment.
  7. #7Tools & open source

    Exact: Expo team's early alpha UI runtime built for coding agents to drive

    Exact is an MIT licensed, pre 1.0 runtime in the expo GitHub org where interfaces are written in a small declarative language called Contract and logic in TypeScript or Rust. It renders with DOM and CSS on the web, AppKit on macOS and UIKit on iOS; Android support is early, with apps that build and run on an emulator or phone but no store packaging, Windows is partial, and Linux paints its own UI on GPU with vello or on CPU with tiny-skia. Every host exposes the same ten agent operations, including tree, screenshot, tap, state and an agent controlled clock, and the README reports a web runtime of about 20 KB and an agent built todo app across three platforms in about 57 minutes.

    Heat · HN thread posted Nov 9; Algolia showed 119 points and 82 comments, while the live page showed about 72 points and 31 comments at one check
    What people foundTreat it as a working design proposal for agent testable UI, not a production framework: the README says it changes daily with no API stability, and there are no releases yet. The idea worth stealing is the deterministic clock that agents advance instead of sleeping in tests.
    Learn it15 min · 4 steps

    Key ideas

    Contract
    Exact's declarative UI language that has no I/O, so data comes only from TypeScript or Rust sources.
    Agent operations
    Ten identical commands on every host, such as screenshot, tap and state, that let an agent run and inspect an app without a human.
    Controlled clock
    Time in the app is advanced by the test or agent, which removes flaky waits and sleeps.

    Steps

    1. Read the expo/exact README first, especially the platform table and the agent operations section.
    2. Note which hosts render natively, Apple and web, and which paint their own pixels, Linux and Windows.
    3. Skim the todo app build story: about 57 minutes total, of which roughly 25 were first native builds.
    4. Self check: how would a controlled clock change the way you write UI tests for an animation or a debounce?
    Try it30 min · 5 steps
    You need: Rust via rustup, Bun 1.4.2, Google Chrome or another Chromium; Xcode only for macOS and iOS. Linux is enough for the web loop. No API key needed.

    Steps

    1. Clone the repo with git clone https://github.com/expo/exact.git and cd exact.
    2. Run bun scripts/exact.mjs setup --check to see what is missing without changing anything.
    3. Run bun scripts/exact.mjs setup, then bun host/web/dev.mjs and open http://127.0.0.1:8765/ in Chrome.
    4. Edit a Contract file in the sample app, save, and watch how fast the change reaches the page.
    5. Point your coding agent at the README's agent operations and ask it to take a screenshot and dump state for the running web app.

    Small angles to try

    • On a Mac, try bun host/apple/build.mjs --run for the macOS host and compare the same agent operations.
    • Ask an agent to write a test that uses the clock operation instead of a sleep and check whether it passes repeatedly.
    • Compare the app code size with a small React app of your own doing the same thing.
  8. #8Models & launches

    Tencent DSpine draft model speeds Qwen3.8-27B agent decoding up to 3.84x

    Tencent published Qwen3.8-27B-DSpine-b16, a five layer speculative decoding draft model of about 2B parameters with block size 16, under Apache 2.0. It drafts 16 tokens in parallel for the Qwen3.8-27B target. On SGLang, Tencent reports end to end speedups over plain autoregressive decoding of 2.71x to 3.84x at low reasoning effort across five agent benchmarks, peaking on WorkBuddy Office, with 3.20x on tau2-bench.

    Heat · Hugging Face model page shows 148 likes and about 1,464 downloads last month; no HN thread found
    What people foundAgainst the earlier DFlash2 drafter, DSpine raises mean acceptance length on GSM8K from 5.69 to 7.20 at temperature 0, but gains shrink at temperature 1 and on chatty tasks like MT-Bench, 4.11 to 4.48. All numbers are Tencent's own, measured at concurrency 8 with no hardware listed.
    Learn it15 min · 4 steps

    Key ideas

    Speculative decoding
    A small draft model guesses several tokens and the big model verifies them in one pass, keeping the big model's output.
    Acceptance length
    The average number of drafted tokens the target model accepts per verification step; higher means more speedup.
    Block size
    How many tokens the drafter proposes at once, 16 here versus 8 for DFlash2.

    Steps

    1. Read the Hugging Face model card first, especially the speedup and acceptance length tables.
    2. Compare low and xhigh reasoning rows and note that the speedup on tau2-bench drops from 3.20x to 2.87x.
    3. Look at the SGLang launch command on the card and identify which flags enable speculative decoding.
    4. Self check: why can a higher acceptance length still give less speedup if the drafter itself is slower?
    Try it30 min · 5 steps
    You need: A Linux machine with a large NVIDIA GPU that can hold Qwen3.8-27B in BF16 plus the drafter, Python, SGLang 0.5.22 as used on the card; without a GPU, do the estimation exercise only. No API key needed.

    Steps

    1. Read the card's SGLang command and copy it into a script, noting --speculative-algorithm DSPINE, --speculative-draft-model-path and --speculative-num-draft-tokens 16.
    2. Download the draft checkpoint from the Hugging Face repo to a local folder and point the draft path at it.
    3. Start the server once without the speculative flags and record tokens per second on 20 of your own agent prompts.
    4. Restart with the DSpine flags and rerun the same prompts, then compute your own speedup.
    5. Without a GPU: take your own daily token volume and use the card's tokens per second figures to estimate how many GPU hours the drafter would save.

    Small angles to try

    • Compare temperature 0 and temperature 1 on the same prompts to see the acceptance drop the card reports.
    • Try a code heavy prompt set versus a chat set and compare speedups.
    • Clone the Tencent DSpine repo with git clone https://github.com/Tencent/DSpine.git and pip install -e ., then read how the drafter passes features through depth.
  9. #9Tools & open source

    Codex app-server can forward your SSH agent to remote hosts; HN flags it

    An HN post says ChatGPT Desktop lets a Codex agent on a remote machine use your local SSH credentials, so it could push to your private GitHub repos. The linked Codex PR #28131 adds an opt in codex app-server proxy --forward-ssh-agent mode that keeps a stable forwarded-ssh-agent.sock symlink next to the app server control socket, so a detached app server follows your agent across SSH reconnects. An OpenAI reviewer notes the Codex app launches the app server with SSH_AUTH_SOCK pointed at that stable path.

    Heat · HN thread posted Nov 9; Algolia counts varied between checks, from 76 points and 16 comments up to 208 points and 73 comments, and the live page showed only a few points, suggesting the thread was penalized
    What people foundThe OpenSSH ssh_config manual already warns that anyone who can reach a forwarded agent socket can sign with your loaded keys, though not copy them. If a remote agent session holds your agent, adding keys with confirmation, a short lifetime or a hardware key that needs a touch per use limits what it can do silently.
    Learn it15 min · 4 steps

    Key ideas

    SSH agent forwarding
    Your local agent's socket is exposed on the remote host so programs there can authenticate as you without the private key leaving your machine.
    SSH_AUTH_SOCK
    The environment variable that tells SSH clients which agent socket to use.
    Key confirmation
    An agent option that asks you to approve each use of a key before it signs anything.

    Steps

    1. Read Codex PR #28131 first, including the description and the reviewer comment about SSH_AUTH_SOCK.
    2. Read the ForwardAgent entry in the OpenBSD ssh_config manual and its warning about socket access.
    3. Read the ssh-add manual entries for -c confirmation and -t lifetime.
    4. Self check: if a remote agent process can reach your forwarded socket, what can it do with your keys and what can it not do?
    Try it30 min · 5 steps
    You need: Your own machine with OpenSSH; optionally the Codex app or CLI if you already use it. This is a local configuration check only, on machines you own. No API key needed.

    Steps

    1. Run echo $SSH_AUTH_SOCK and ssh-add -l to see which agent and which keys are currently loaded.
    2. For each remote host you own and use with Codex, run ssh -G <your-host> and check the forwardagent line in the output.
    3. If you use the Codex app with remote hosts, check whether a forwarded-ssh-agent.sock symlink exists in the app server control socket folder, such as the ~/.codex/app-server-control path from the PR discussion.
    4. Decide per host whether forwarding is needed; turn it off in your ssh config where it is not, or pass -a for one off connections.
    5. Where forwarding is needed, re add your key with ssh-add -c for per use confirmation and -t for a lifetime, then confirm with ssh-add -l.

    Small angles to try

    • Use a separate deploy key with access to a single repo for agent sessions instead of your main key.
    • Write a short shell script that lists every Host block in your ssh config with its effective forwardagent value.
    • Compare a hardware backed key that needs a touch per signature with a plain key in the agent.
  10. #10Tools & open source

    Beep Locator: Simon Willison gives Claude Code ears to find a beep

    Simon Willison had Claude Code build Beep Locator, which turns phones, tablets and laptops into browser microphones that locate an intermittent beep. A Python server coordinates the devices over WebSockets, each listener keeps a rolling 60 second Web Audio buffer with an FFT based detector, and a chirp from the lowest latency device aligns the uploaded clips. It found an old carbon monoxide detector to within about 40 cm.

    Heat · HN thread posted Nov 10, about 170 points and 75 comments per Algolia
    What people foundThe standout trick is an installModule() hook that lets the server push new JavaScript to every listening device over the WebSocket, so the agent could keep changing the software while it ran. Willison's framing is that it is possible to "give Claude Code ears" through code that analyzes microphone audio, even without native audio input.
    Learn it15 min · 4 steps

    Key ideas

    FFT detector
    A Fast Fourier Transform turns audio into frequencies so a sharp tone like a beep stands out from background noise.
    Time difference of arrival
    The same sound reaches each microphone at slightly different times, and those gaps point to where it came from.
    Clip alignment chirp
    A known sound played by one device gives every recording a shared reference point in time.

    Steps

    1. Read Simon Willison's post first, focusing on the chirp alignment and the 2007 BeepBeep acoustic ranging paper Claude found.
    2. Open the simonw/beep-locator README and the listener detector code to see how beeps are flagged.
    3. Note how installModule() lets the server run new code on clients, and why that is fine only on your own devices.
    4. Self check: why can the system not simply trust each device's clock to line up the recordings?
    Try it30 min · 5 steps
    You need: uv, cloudflared for the HTTPS tunnel phones need for microphone access, a laptop and at least two of your own phones or tablets. No API key needed.

    Steps

    1. Clone the repo with git clone https://github.com/simonw/beep-locator and cd beep-locator.
    2. Start it with uv run beep-locator serve --tunnel and keep the printed admin URL and token private.
    3. Open the coordinator URL on your laptop and the join URL or QR code on each of your own devices, then tap Start listening.
    4. Play a short repeating beep from a speaker you control somewhere in the room and see how close the estimate gets.
    5. Stop the server when done, since the tunnel makes it reachable from the internet.

    Small angles to try

    • Move the beep source and record the error at three positions.
    • Ask a coding agent to push a small detector tweak through installModule() while the system runs, on your own devices only.
    • Try a different beep frequency and see whether the FFT detector still catches it.
  11. #11Engineering & CS

    Claude finds 88% of one developer's 2026 inbound mail is sales pitches

    Josh Strange had Claude go through every email he received about his blog posts and Hacker News comments since 2013. By that count, sales pitches were absent from 2013 to 2021, then rose to 20% in 2022, 50% in 2025 and 88% in 2026 through November 6, while total volume also jumped this year. He argues that LLMs make it cheap to write personalised cold emails that look like sincere questions about a comment.

    Heat · HN front page on 2026-11-09 with a few hundred points and well over 150 comments; counts kept climbing between fetches, so no exact figure is given
    What people foundStrange now answers such emails briefly and only engages fully once no pitch follows, a change he dislikes because it treats people as guilty until proven innocent. The post does not publish the prompt or criteria Claude used, so the 88% is one person's inbox, not a reusable method.
    Learn it15 min · 5 steps

    Key ideas

    Personalised cold outreach
    Sales email that references something specific you wrote so it reads like a genuine question rather than a pitch.
    LLM classification
    Asking a language model to sort text into fixed labels, such as pitch or genuine, instead of writing rules by hand.
    Base rate drift
    When the share of one kind of message in a stream changes over time, so habits built on the old mix stop working.

    Steps

    1. Read Josh Strange's post 'I Saw Your HN Comment' on joshstrange.com and note the yearly pitch percentages in the chart.
    2. Skim the top HN comments to see whether other developers report the same pattern and what filters they use.
    3. Write down what a pitch label would need to catch: a product link, a call request, a fake question that leads to a demo.
    4. Notice what the post leaves out: the prompt, the label definitions and any spot check of Claude's labels.
    5. Self check: why would a precise prompt and a manual sample check matter before trusting a number like 88%?
    Try it30 min · 6 steps
    You need: Python 3, an export of your own mailbox such as an mbox file from your mail provider, and either an LLM API key or a local model; no third party data

    Steps

    1. Export one folder of your own email to an mbox file using your provider's export tool.
    2. Write a short Python script with the standard library mailbox module that pulls date, sender domain, subject and the first 500 characters of each message into a CSV.
    3. Write a fixed labelling prompt with two or three labels, for example pitch, genuine question, other, and a one line definition of each.
    4. Run the prompt over a sample of 100 messages and save the labels next to each row.
    5. Hand label 20 of those messages yourself and count how often the model agrees.
    6. Group the labels by year and compare your trend line to the one in the post.

    Small angles to try

    • Run the same prompt with two different models and measure how often they disagree.
    • Add a cheap keyword filter first and see how much of the model's work it already does.
    • Only include mail that mentions a public post or comment of yours, to match the post's scope.
  12. #12Engineering & CS

    Google TPU 8tx for confidential inference and TPU 8i Max, no date yet

    Google announced two more eighth generation TPU systems on November 9. TPU 8tx uses TPU 8t silicon with 5th Gen AMD EPYC hosts to keep data and model weights isolated during processing, with Google claiming up to 2x lower latency than TPU 8t. TPU 8i Max puts two TPU 8i chips on one package, doubling compute, SRAM and HBM bandwidth versus TPU 8i, and the post also lists software such as open source TPU Sync and GKE dynamic slicing reaching general availability.

    Heat · HN front page, about 240 points and 70 comments by Algolia's count, plus a smaller second thread
    What people foundNo availability date is given for either system, so the usable part today is software. Google says TPU Sync cuts KV cache transfer latency and time to first token by more than 90%, and TorchTPU, open sourced last month rather than in this launch, gives vLLM and SGLang TPU backends.
    Learn it15 min · 5 steps

    Key ideas

    Confidential inference
    Running a model so that the input data and the weights stay protected in hardware even from the operator of the machine.
    KV cache
    The stored attention keys and values from earlier tokens, which a model reuses so it does not recompute them for each new token.
    Time to first token
    How long a user waits before the first word of a model's answer appears.

    Steps

    1. Read Amin Vahdat's post on blog.google about TPU 8tx and TPU 8i Max and list every number with what it is compared against.
    2. Open the linked TPU Sync post on the Google Cloud blog to see how KV caches are moved off chip.
    3. Open the GKE dynamic slicing documentation linked from the post and note what problem slicing solves.
    4. Separate hardware you cannot rent yet from software you can try now.
    5. Self check: why does faster KV cache transfer improve time to first token for long prompts?
    Try it30 min · 5 steps
    You need: Python 3 only, no cloud account and No API key needed

    Steps

    1. Pick one open weight model you serve or want to serve and look up its layer count, KV head count, head size and data type from its model card.
    2. Write a short Python function that computes KV cache size in bytes per token as 2 times layers times KV heads times head size times bytes per value.
    3. Compute the cache size for prompt lengths of 4K, 32K and 128K tokens and for 8 concurrent users.
    4. Assume a link bandwidth you choose and estimate how long moving that cache would take, then apply Google's claimed 90% cut to see what it would change.
    5. Write down whether KV transfer or compute is the bigger part of your time to first token.

    Small angles to try

    • Repeat the estimate for a mixture of experts model and see which numbers change.
    • Compare quantised 8 bit KV cache against 16 bit and note the memory saved.
    • List which of your workloads would need confidential inference and why.
  13. #13Trends × tech

    AI VTubers × voice AI: Shizuku-Duplex listens and talks at once

    Shizuku AI, which builds an AI VTuber character, published Shizuku-Duplex on November 8, a Japanese full duplex voice model that can listen and speak at the same time and be interrupted. It runs in 80 ms ticks, outputs speech, an inner text stream and a Live2D motion, and hands tool calls such as web search to a slower background model through a special DELEGATE token. The post reports a median reply time of 0.57 s against 0.53 s for GPT-Live, but the 1.27 s for Gemini Live and 1.61 s for GPT-Realtime include network round trips, so those are not like for like.

    Heat · Covered by GIGAZINE on 2026-11-09; no ranking position or HN thread seen
    What people foundThe company's own benchmark shows a clear trade off: it stops on 89% of interruptions versus 82% for GPT-Live, but scores 79% on multi turn QA against 95% for GPT-Live. It also summarises and rebuilds its context about every five minutes within a single tick. No demo, weights or API are mentioned.
    Learn it15 min · 5 steps

    Key ideas

    Full duplex dialogue
    A voice system that keeps listening while it speaks, so it can handle backchannels and interruptions like a person.
    Delegation token
    A special output token that tells a slower helper model to do a task, such as search, while the fast model keeps talking.
    Context compaction
    Periodically summarising a long conversation and restarting from the summary so the context window does not overflow.

    Steps

    1. Read the English version of the Shizuku AI blog post at shizuku.ai/en/blog/1/ and draw the tick loop as a diagram.
    2. Find the latency table and mark which systems were measured on the server and which by playback, including round trips.
    3. Compare the interruption and multi turn QA numbers and note which models are full duplex.
    4. Skim the GIGAZINE article to see how it was presented to a general audience.
    5. Self check: why does adding network round trip time to only some systems make the latency comparison unfair?
    Try it30 min · 5 steps
    You need: Python 3 with asyncio from the standard library, No API key needed

    Steps

    1. Write an asyncio loop that ticks every 80 ms and reads text lines from a queue that stands in for user audio.
    2. On each tick, let a fast responder emit a short filler or reply word, and stop immediately if a new user line arrives.
    3. When a user line contains a trigger word such as search, put a DELEGATE task on a second queue instead of answering.
    4. Run a slow background worker that sleeps 2 seconds, then injects a result line that the fast responder speaks on the next tick.
    5. Log timestamps and measure the gap from user line to first reply and from delegation to result.

    Small angles to try

    • Add a compaction step that summarises the transcript every N ticks and see what context is lost.
    • Vary the tick length to 40 ms and 200 ms and watch how interruption handling changes.
    • Add simulated network delay to only one side to see how it skews a latency comparison.
  14. #14Engineering & CS

    Willison: Claude builds SQLite parse_number in C and Rust, tuned C wins

    Simon Willison used regular Claude chat with Opus 5.5 to compare a parse_number() SQLite function written in C and in Rust, which strips commas, dollar and pound signs and percent, handles a leading minus and returns NULL on junk. Four extensions, two in C and two in Rust using rusqlite and sqlite-loadable-rs, matched across 8 million fuzz checks. After the first C version lost on decimals because of strtod(), a version using Clinger's fast path ran at 16 to 19 ns per row over 2 million rows, against 32 to 55 ns for the Rust builds.

    Heat · Post on simonwillison.net on 2026-11-08 with a public research report and shared transcript; little HN traction
    What people foundBinary size differs even more than speed: 14 KB for the first C extension against 298 KB and 321 KB for the two Rust ones. The workflow is the reusable part: have the model build both versions, fuzz them against each other, then ask for one targeted optimisation.
    Learn it15 min · 5 steps

    Key ideas

    SQLite loadable extension
    A shared library that adds new SQL functions to SQLite at runtime.
    Differential fuzzing
    Feeding the same random inputs to two implementations and flagging any input where their outputs differ.
    Clinger's fast path
    A shortcut for converting short decimal strings to floating point exactly, without the slower general algorithm.

    Steps

    1. Read Willison's post on simonwillison.net and copy the benchmark table for mixed, integer and decimal data.
    2. Open the shared Claude transcript linked from the post and follow the three prompts he used.
    3. Look at why the first C version was slow on decimals and what the fast path replaced.
    4. Note the binary sizes and think about where the Rust size comes from.
    5. Self check: why does differential fuzzing between four versions give more confidence than unit tests alone?
    Try it30 min · 5 steps
    You need: A C compiler, the sqlite3 command line tool and Python 3 on your own machine; Rust is optional; No API key needed if you write the code yourself

    Steps

    1. Write a small C SQLite extension that registers a parse_number function with the rules from the post, following the official SQLite loadable extensions guide.
    2. Compile it as a shared library and load it in the sqlite3 shell, then try values like 1,234, $5, 12% and junk.
    3. Write a Python reference version of the same rules and generate a few thousand random strings.
    4. Compare the extension output with the Python output for every string and fix any mismatch.
    5. Time a query over a table of 2 million generated rows and compute nanoseconds per row.

    Small angles to try

    • Ask an LLM to write the Rust version and compare its speed and file size with yours.
    • Replace the decimal conversion with a hand written fast path and measure the decimal only case.
    • Compare against a pure SQL version built from nested replace calls.
  15. #15Engineering & CS

    Willison: Opus 5.5 ports a Three.js scene to plain WebGL in one chat

    In a Hacker News thread on Paul Ford's essay 'The Web Is More Than Enough', Simon Willison asked Claude Opus 5.5, Medium setting in regular chat, to port his 77 KB Three.js Faberge egg scene to vanilla JavaScript and WebGL with no library. The result is a 98 KB file that renders, but not identically, and he says he does not fully understand why. He finds the Three.js code slightly easier to read, though he rarely reads code for such 3D projects.

    Heat · Note on simonwillison.net on 2026-11-09; Ford's essay thread had roughly 180 points and over 130 comments on HN when checked
    What people foundWillison's conclusion is that Opus 5.5 can do 3D work in plain WebGL without Three.js. Removing a dependency is now a cheap experiment, but the output still needs a visual diff, and the port grew the file instead of shrinking it.
    Learn it15 min · 5 steps

    Key ideas

    Three.js
    A JavaScript library that wraps WebGL with scenes, cameras, materials and lights.
    Vanilla WebGL
    Drawing 3D graphics with the browser's low level WebGL API and hand written shaders, with no library.
    Visual diff
    Comparing two renders pixel by pixel or side by side to find where output changed.

    Steps

    1. Read Willison's note on simonwillison.net and open both demo pages side by side.
    2. Open the shared Claude transcript and look for where the model explains lighting or material choices.
    3. Skim the HN thread on Ford's essay for the comment that prompted the experiment.
    4. View the source of both demos and compare how each sets up the camera and shaders.
    5. Self check: why might a port without a library end up larger than the version that used one?
    Try it30 min · 5 steps
    You need: A modern browser and a text editor; an LLM chat of your choice is optional; No API key needed

    Steps

    1. Save both demo pages locally and open them in two browser windows at the same size.
    2. Take a screenshot of each at the same moment and compare them by eye or with an image diff tool.
    3. Pick one difference, such as color or shading, and find the matching code in each file.
    4. Take a small Three.js page of your own and ask an LLM to port it to plain WebGL.
    5. Compare file size, render output and how long it takes you to read each version.

    Small angles to try

    • Ask for a port to a different small library and compare readability.
    • Ask the model to explain each difference in the render before changing any code.
    • Measure frame rate of both versions with the browser's performance tools.
  16. #16Tools & open source

    Flide: one context, many questions, for decision model inference

    Flide is an Apache 2.0 inference engine for decision models: a request carries one state, such as an agent trajectory or a document, plus typed questions, and Flide runs the state once and returns every answer as a probability through a /v1/systemone endpoint. Its README reports up to 9.4x over vLLM and SGLang on one H200 with Qwen3.5-0.8B and lists 14 supported model families.

    Heat · Show HN, 32 points and 6 comments on the HN page when checked; counts varied between fetches
    What people foundIn the Show HN post the author claims up to 9.5x, measured on QuALITY with one article of about 5.8k tokens and about 18 questions, and more than 3x for a single short question with a small model, thanks to a prerecorded CUDA graph. The team says there is "no accuracy tradeoff", but the README itself reports up to 2.3% of decisions flipping at a 0.5 threshold versus a float32 reference.
    Learn it15 min · 4 steps

    Key ideas

    Decision model
    A model used to answer constrained questions, such as a choice or yes or no, about some input and return probabilities instead of free text.
    Shared context forking
    The long input is processed once into a KV cache, and each question reuses that cache instead of paying for the full prompt again.
    CUDA graph
    A recorded sequence of GPU operations that can be replayed with very little launch overhead, which helps small and short requests.

    Steps

    1. Read the Flide README on GitHub first, focusing on the request format and the benchmark table.
    2. Read the Show HN thread to see where the 9.5x figure comes from and how the single question case differs.
    3. Compare the README accuracy section, including the decision flip numbers, with the author's no tradeoff claim.
    4. Self check: why does the speedup grow as more questions share the same state?
    Try it30 min · 5 steps
    You need: Linux machine with an NVIDIA GPU, Python 3.12, the uv tool, the flide package from PyPI and a small Hugging Face model; No API key needed

    Steps

    1. Create an environment with uv venv -p 3.12 && source .venv/bin/activate.
    2. Install with uv pip install flide torchvision.
    3. Start a server with flide serve --model Qwen/Qwen3.5-4B, which listens on port 8000 by default.
    4. Send the README example request to http://localhost:8000/v1/systemone with curl, using a state text and two typed questions.
    5. Write your own state from a log or ticket you own, add five questions, and time one request with all five against five requests with one question each.

    Small angles to try

    • Grow the question count from 1 to 20 and plot latency per question.
    • Start the server with --batch-invariant and check whether results change under concurrent load.
    • Ask the same questions to a chat model you already run and compare answers with Flide's probabilities.
  17. #17Tools & open source

    samir-vllm: build a small LLM inference engine in C++ and CUDA

    A teaching repo that runs Llama 3.2 1B Instruct on an NVIDIA GPU with an engine written from scratch in C++17 and CUDA: a safetensors loader, a BPE tokenizer, kernels for RMSNorm, RoPE and SwiGLU, grouped query attention, a paged KV cache, and static and continuous batching. It comes with 12 videos, Parts 0 to 10 plus a Finale on paged attention, and a handwritten notes PDF of 80+ pages.

    Heat · HN, about 73 points and 12 comments on the HN page; 38 GitHub stars when fetched
    What people foundThe engine code is MIT, but the notes and PDFs are all rights reserved for personal study only, and the Llama weights and tokenizer stay under Meta's license. In the HN thread the author says later videos used an LLM for background slides while the notes are handwritten.
    Learn it15 min · 4 steps

    Key ideas

    Prefill and decode
    Prefill processes the whole prompt in parallel, then decode produces one token at a time while reading the cached keys and values.
    Paged KV cache
    The KV cache is split into fixed size blocks tracked by a block table, so memory for many requests can be allocated without large contiguous buffers.
    Continuous batching
    The scheduler admits new requests as soon as their memory budget fits, instead of waiting for the whole current batch to finish.

    Steps

    1. Open the samir-vllm README and read the component list and the batching examples.
    2. Watch Part 0, the inference overview, then Part 8 on decode and the KV cache.
    3. Skim the paged KV cache source and match the block table to the Part 10 video.
    4. Self check: what does continuous batching gain over static batching when requests have very different output lengths?
    Try it30 min · 5 steps
    You need: Linux machine with an NVIDIA GPU, CUDA Toolkit, CMake 3.24 or newer, a C++17 compiler, ICU development libraries, the nlohmann/json header, and Llama 3.2 1B Instruct weights downloaded under Meta's license; No API key needed

    Steps

    1. Clone the repo and place the Llama 3.2 1B Instruct weights and tokenizer.model under models/ as the README describes.
    2. Build with cmake -S . -B build and then cmake --build build -j.
    3. Run one prompt with ./build/samir-vllm "Explain the KV cache in two sentences." 128.
    4. Run several prompts with --stats to see pool and scheduling metrics under continuous batching.
    5. Repeat the same run with --static and compare total time and queueing.

    Small angles to try

    • Shrink the pool with --kv-cache-mib 8 and watch requests queue.
    • Run ./build/tokenizer-test on the tokenizer model and compare token counts for English and Japanese text.
    • Raise the output length and measure how decode time scales per token.
  18. #18Tools & open source

    Willison: fold agent written PR descriptions into a details block

    Simon Willison says most changes to his projects now arrive as PRs written by coding agents, whose descriptions are accurate but tiring to read. His fix is a short human opener at the top, with a screenshot when it helps, and the full agent text folded into a collapsible <details> block whose <summary> names the model and effort level, such as "Claude Opus 5.5 Medium".

    Heat · Simon Willison's blog, Nov 9; no HN thread found
    What people foundWillison wants "human editorial judgement" up top: the opener is his promise of what is worth a reviewer's time, while the agent's thorough write up stays one click away. GitHub renders the block as a single expandable line.
    Learn it15 min · 4 steps

    Key ideas

    `<details>` and `<summary>`
    HTML elements that GitHub Markdown renders as a collapsed section, where the summary text is the clickable line.
    Human opener
    A few sentences written or approved by a person that say what the PR is for and why it matters.

    Steps

    1. Read Willison's post on the details summary convention first.
    2. Open one of the datasette PRs he links and see how the folded block looks to a reviewer.
    3. Write the tag order from memory: <details> wraps everything and <summary> is the visible line.
    4. Self check: what information must stay outside the folded block for a reviewer to decide quickly?
    Try it30 min · 5 steps
    You need: A GitHub account and a repository you own; any coding agent you already use; No API key needed

    Steps

    1. Take a recent agent written PR description from your own repo.
    2. Write a two or three sentence opener by hand that states the purpose and the risk.
    3. Wrap the agent text in a <details> block with a <summary> line naming the model.
    4. Preview it in the GitHub PR editor and check that the opener and expand arrow show as expected.
    5. Add the pattern to your PR template or your agent instructions file.

    Small angles to try

    • Ask your agent to draft only the opener and compare it with your own.
    • Add a short testing notes line outside the folded block.
    • Try the same block in an issue comment or a release note.
  19. #19Tools & open source

    Ask HN: how engineers keep agent context per client and project

    An Ask HN thread from Nov 7 collects how people feed context into new agent sessions and keep clients apart. Answers include a gitignored ADR folder and status doc in each repo, spec driven tools such as OpenSpec, Matt Pocock's skills library, a self hosted Gitea wiki the agent reads and updates, and a skill that keeps a daily JSON work board so sessions can restart without loss.

    Heat · Ask HN, about 91 points and 51 comments on the HN page
    What people foundThe most common answer is plain Markdown stored in the repo rather than a product; commenter charlesabarnes says no extra tools are needed because LLMs "get it" natively.
    Learn it15 min · 4 steps

    Key ideas

    ADR
    An Architecture Decision Record is a short file that records one design decision, its context and its consequences.
    Agent skill
    A reusable instruction file, often invoked with a slash command, that tells a coding agent how to perform a recurring task.

    Steps

    1. Read the Ask HN thread first and list each distinct pattern.
    2. Open the mattpocock/skills README to see how skills are packaged and installed.
    3. Pick one repo you own and note what context a new agent session currently lacks.
    4. Self check: which of these patterns keeps one client's context from leaking into another's?
    Try it30 min · 5 steps
    You need: A repo you own and a coding agent such as Claude Code; No API key needed beyond the agent you already use

    Steps

    1. Create a gitignored docs/adr/ folder and a STATUS.md file in one of your repos.
    2. Write two short ADRs for decisions you already made, plus the current status and next steps.
    3. Start a fresh agent session and ask it to summarize the project using only those files.
    4. Optionally install Matt Pocock's skills in Claude Code with claude plugin install mattpocock-skills@claude-plugins-official and run /setup-matt-pocock-skills once in the repo.
    5. Compare the agent's first answer with and without the files.

    Small angles to try

    • Keep a daily JSON board file and ask the agent to update it at the end of each session.
    • Move the notes into a separate private wiki repo and point the agent at it.
    • Measure how many follow up questions the agent asks in each setup.
  20. #20Trends × tech

    Bookstores × AI: Copilot and Claude guides top Japan's IT best sellers

    The Amazon.co.jp IT book ranking shown by INTERNET Watch, updated Nov 10 at 06:04, is led by 'Microsoft 365 Copilot Katsuyo Taizen', with a generative AI passport textbook at #2. Claude books sit at #4, a Claude Code work guide for business people, and #6, 'Claude Katsuyo Taizen', while an AI agent book for solo businesses is #10. In the app guide ranking, Copilot books hold #1 and #2 and 'Dekiru Claude & Claude Cowork' is #3.

    Heat · Amazon.co.jp best seller positions on the INTERNET Watch ranking widget, Nov 10 06:04: IT books #1 Copilot, #2 generative AI passport, #4 and #6 Claude, #7 generative AI basics, #10 AI agents; app guides #1 and #2 Copilot, #3 Claude and Claude Cowork, #4 AI agents
    What people foundOffice workers in Japan are buying printed manuals for AI tools, and Claude Code now appears in titles aimed at business people rather than developers, so expect colleagues outside engineering to arrive with agent setups that need guardrails.
    Learn it15 min · 4 steps

    Key ideas

    Generative AI Passport
    A Japanese certification on basic generative AI literacy, run by GUGA, aimed at general business staff.
    Claude Cowork
    Anthropic's desktop agent mode for knowledge work outside coding, which this book pairs with Claude.

    Steps

    1. Open the INTERNET Watch top page and find the IT book and app guide ranking widgets.
    2. Note which of the top 10 are about AI tools and which product each covers.
    3. Check the standalone ranking page and compare, since it can show an older snapshot.
    4. Self check: what share of the IT top 10 is about generative AI, and which vendor appears most?
    Try it30 min · 4 steps
    You need: A browser and Python 3 with the standard library; No API key needed

    Steps

    1. Copy the IT and app guide top 10 titles by hand from the widget into a small CSV with rank, title and chart.
    2. Write a short Python script that tags each title as Copilot, Claude, generic AI or other by keyword.
    3. Print the count per tag for each chart.
    4. Repeat on another day and compare how the tags move.

    Small angles to try

    • Track only the Claude and Copilot positions over a week.
    • Compare with a programming book chart to see whether coding titles are losing space.
    • List what a non engineer would need from your team before using Claude Code at work.

Get the Radar by email

One email each evening, Japan time, with that day's items. Opening soon: leave your email and we'll send a confirm link when it starts.