Code415 Radar

Key ideas

Expert parallelism with EPLB

The experts of a mixture of experts model are spread across many GPUs, and an expert parallel load balancer places them so no GPU becomes the bottleneck.

Prefill and decode

Prefill processes the whole prompt in one pass while decode generates tokens one step at a time, so large services often run them on separate GPU pools.

Batch invariant inference

The same request gives the same output no matter which other requests share its batch, which makes deterministic sampling possible.

Steps

1. Read the DeepInfer README on GitHub first, focusing on the Features and Not included sections.
2. Map each listed feature to the concept list above and note which ones only work on NVIDIA.
3. Open the examples guide in the repo and skim how SamplingParams carries seq_seed and so_args.
4. Compare the excluded parts with what a production serving stack needs, such as KV cache reuse and request routing.
5. Self check: why would a lab need 64 decode GPUs but only 4 prefill GPUs for the same model?

Steps

1. Clone the deepseek-ai/DeepInfer repository to your own machine.
2. Open examples/offline_inference.py and trace how a prompt becomes a request, a batch and finally sampled tokens.
3. Search the code for DEEPINFER_BATCH_INVARIANT and list every place it changes behavior.
4. Open examples/_structured_output.py and note how a JSON schema or regex is passed through so_args.
5. Write a short note on which missing component, KV cache or disaggregation, you would add first to turn this into an online service, and why.

Small angles to try

• Ask a coding agent to draw a call graph of the scheduler and check it against the source by hand.
• Compare the deterministic sampling setup with how vLLM or SGLang describe reproducibility in their docs.
• Read build.sh and list what differs between the nvidia and ascend accelerator paths.

Key ideas

Word error rate

The share of words a transcript gets wrong through substitutions, deletions and insertions, so lower is better.

Diarization

Labeling which speaker said each segment of a recording.

Cascaded voice agent

A pipeline where separate speech to text, language and speech models are chained, so each stage can be swapped independently.

Steps

1. Read the Mistral Voxtral 3 announcement first, especially the FLEURS and diarization charts and their footnotes.
2. Note that the 4.1% figure uses a forced language setting and that CER replaces WER for Japanese, Korean, Thai and Chinese.
3. Skim the Mistral speech to text overview to see which features are offline only, such as diarization with segment timestamps.
4. Self check: why can a benchmark WER look far better than what you get on your own noisy call recordings?

Steps

1. Set your key with export MISTRAL_API_KEY="your-api-key" and install the SDK with pip install mistralai.
2. Download the sample file from the quickstart with curl -O https://docs.mistral.ai/audio/obama.mp3.
3. Run the quickstart script that calls client.audio.transcriptions.complete with model="voxtral-mini-transcribe-3" and print the text.
4. Record 60 seconds of your own speech with some jargon from your work and transcribe it the same way.
5. Count the word errors by hand against what you actually said and compare with the Whisper output if you already run Whisper locally.

Small angles to try

• Try a recording that mixes two languages and see whether auto detection keeps up.
• Follow the docs page on context biasing and check whether your jargon errors drop.
• Estimate monthly cost for your team's meeting hours at the published per minute price.

Key ideas

Conformance suite

The upstream compiler's own test cases, used to prove a port behaves the same as the original.

Compatibility matrix

A regenerated table of which upstream tests pass or fail in the port, showing drift over time.

Agentic upstream triage

An agent reads each new upstream change, judges whether it affects the port and files an issue when it does.

Steps

1. Read the Cloudflare blog post on the TypeScript Rust port first, paying attention to the section on keeping up with upstream.
2. Open the oxc-project/tsrs README and note the stated goal of 100% conformance against TypeScript 7.1.
3. List the known differences the authors admit, such as diagnostic order.
4. Self check: what would break first in an AI written port if nobody ran the nightly compatibility matrix?

Steps

1. In a copy of one of your own TypeScript projects, add the package with pnpm add -D tsrs or npm install tsrs.
2. Run a type check only pass with pnpm exec tsrs --noEmit and time it.
3. Run your usual type check with the TypeScript compiler on the same project and time it too.
4. Diff the two sets of diagnostics and sort them, since tsrs may print them in a different order.
5. Note wall time, peak memory from your OS monitor and any real mismatches in a short table.

Small angles to try

• Rerun with --checkerAssignment go --noLazyMembers, which the README recommends for the closest comparison with the Go compiler.
• Build a tiny agent prompt that reads one week of microsoft/TypeScript commits and flags which ones a port would need to follow.
• Try the largest monorepo you own to see where the memory savings show up.

Key ideas

ADB

Android Debug Bridge, a developer channel that lets a computer run shell commands on an Android device, including over the local network.

Disabling versus uninstalling

Disabling a package hides and stops it but keeps it on the device, so it can be turned back on later.

DNS sinkhole

A local DNS server such as Pi-hole that answers ad and tracker domains with nothing, blocking them for every device on the network.

Steps

1. Read the TechCrunch article first for the scope of the trend and the failures.
2. Read the cleanyourtv README, especially its warnings on launcher order, the setup wizard package and open ADB ports.
3. Compare that approach with a network level DNS sinkhole, which never touches the TV itself.
4. Self check: why is disabling the stock launcher before the new one runs a way to end up with an unusable TV?

Steps

1. On your own TV, open the settings menu and switch off ad personalization, usage reporting and auto start options that the menu itself offers, writing down each change so you can undo it.
2. Run Pi-hole in a Docker container on your own computer, following the official Pi-hole Docker instructions.
3. Point only the TV's DNS setting at that computer's local address, leaving the rest of the network unchanged.
4. Use the TV normally for 15 minutes, then read the Pi-hole query log to see which ad and telemetry domains the TV tried to reach.
5. Ask Claude Code to read the cleanyourtv debloat lists and explain what each package does, without connecting it to the TV or applying anything.
6. Undo the experiment by restoring the TV's DNS setting and confirm everything still works.

Small angles to try

• Compare the domains in your Pi-hole log with the packages named in the repo lists.
• Allow one blocked domain at a time and note which TV apps break.
• Try one of the launcher apps TechCrunch lists as a non AI alternative, such as Projectivy Launcher, through the normal app store.

Key ideas

PyTorch backend

A device layer that tells PyTorch how to run its tensor operations on a specific kind of hardware.

ATen kernels

ATen is the core tensor library under PyTorch, and a backend supplies kernel implementations of its operations for its own chip.

torch.compile

A PyTorch feature that captures a model as a graph so a backend can optimize and compile it instead of running one operation at a time.

Steps

1. Read the README of google-pytorch/torch_tpu on GitHub first, noting the feature list, Python version and install notes.
2. Read the TechCrunch story to see the industry context: Amazon TorchNeuron one day earlier and the partners Google named.
3. Skim the TorchTPU user guide at torchtpu.readthedocs.io, especially the getting started pages for a TPU VM and for GKE.
4. Compare eager execution with graph mode in your head: which parts of a model would benefit from a compilation cache.
5. Self check: why does a backend that works with torch.compile matter more for porting existing code than a separate TPU framework?

Steps

1. Create a TPU VM in your own Google Cloud project, following the TorchTPU getting started guide for a VM.
2. Install the package with pip install torch_tpu==0.2.0 --extra-index-url https://download.pytorch.org/whl/cpu, the extra index keeps pip from pulling the CUDA build of torch.
3. Take a small PyTorch model you already have, such as an MLP on random data, and follow the user guide to place it on the TPU device.
4. Run a few training steps eagerly and record step time, then wrap the model with torch.compile as the guide describes and record step time again.
5. Run the same compiled script a second time to see whether the compilation cache shortens startup.
6. Delete the TPU VM when finished so billing stops.

Small angles to try

• Port a small Hugging Face model and list every code change that was needed.
• Compare the same script on a CPU build of torch to check numerical agreement of outputs.
• Read the vLLM TorchTPU backend repo and note how serving differs from training.

Key ideas

KV cache

Stored attention keys and values for past tokens, which grow with every token of conversation history.

Parametric memory

Memory kept as a fixed size internal state or weights inside the model, rather than as retrievable text outside it.

Gated DeltaNet

A linear attention style layer that updates a fixed size state with gates deciding what to write, keep or forget.

Steps

1. Read the abstract on the Hugging Face paper page for MemT-1.0 first, noting the two stage training on 34B tokens.
2. Open the MemT-1.0-Nano model card and read the Native Memory Block description and the benchmark ranking.
3. Sketch how storage grows for a KV cache versus a constant size state as history goes from 8K to 128K tokens.
4. Note where the authors say text memory still wins, and think about which of your own workloads need exact evidence.
5. Self check: why can a constant size state save storage yet still lose to retrieval on questions about specific old details?

Steps

1. On your own GPU machine, install the pinned packages from the model card: pip install transformers==5.12.1 accelerate==1.15.0 safetensors==0.8.0.
2. Load MemTensor/MemT-1.0-Nano with AutoModelForCausalLM using trust_remote_code=True, dtype=torch.bfloat16 and device_map="auto", after reviewing the remote code.
3. Create a session with model.create_session(tokenizer) and tell it a few made up facts over several turns using session.chat with enable_memory=True.
4. Save the state with session.save_state(path), restart Python, reload with model.create_session(tokenizer, state=path) and ask about the facts.
5. Check the size of the saved state file, then add more turns and check whether it stays the same size.

Small angles to try

• Ask about an exact number from an early turn to probe where detailed recall breaks down.
• Run the same conversation through plain chat without memory and compare answers.
• Compare against a simple retrieval setup over the same notes.

Key ideas

Layout analysis

Detecting blocks such as headings, tables and paragraphs on a page so text comes out in the right reading order.

Text layer

Embedded text inside a digital PDF that can be read directly without running OCR on the image.

OpenRAIL-M

A family of model licenses that grant use of weights with behavioral and, in this modified version, commercial restrictions.

Steps

1. Read the datalab-to/indra-ocr model card on Hugging Face first, especially the benchmark table and the limitations list.
2. Read the license section and decide whether your company would qualify under the $20M threshold.
3. Look at the CLI flags for mode, format and cores to see how text layer and OCR paths differ.
4. Self check: for a scanned contract with handwritten notes, which parts would you expect Indra OCR to get wrong?

Steps

1. Create a fresh virtual environment and run pip install indra-ocr.
2. Convert one of your own PDFs to markdown with indra-ocr paper.pdf and read the output.
3. Export structure with indra-ocr scan.png --format json on a photo or scan you own and inspect the boxes and confidences.
4. Force OCR on every page with indra-ocr paper.pdf --mode ocr --timings and compare speed and quality with the default auto mode.
5. Open indra-ocr-viewer --port 8765 locally to view results side by side with the pages.

Small angles to try

• Try a page with a complex table and see how the HTML table output holds up.
• Enable --math on a paper with equations.
• Vary --cores to measure throughput scaling on your own machine.

Key ideas

LLM proxy

A server you run between your apps and model providers that forwards requests and records what passed through.

Virtual API key

A key issued by your proxy to one client or agent, so the real provider key stays in one place and usage is attributable.

Prompt cache miss

A request that fails to reuse a provider's cached prompt prefix, which raises cost and latency.

Steps

1. Read Jared Siegel's essay on jrdsgl.com first and list the features he says a proxy gives you.
2. Skim the HN comments to see which proxies readers say they already run.
3. Read the respan-gateway README sections on config, routes and plugins.
4. Self check: what fields would a log line need for you to explain a sudden cost spike from one agent?

Steps

1. Clone respanai/respan-gateway and build it with cargo build --release -p respan-gateway, or skip the UI and accept the placeholder page at /ui/.
2. Write a minimal gateway.toml with a listen address, one client key and one provider, using env:NAME for the secret as the README shows.
3. Point a small script or coding tool you own at the gateway instead of the provider and send a few requests.
4. Inspect the gateway logs and note which client key, model and status each request recorded.
5. Add a second provider and a route with retries, then switch models by editing the config and reloading with --watch.

Small angles to try

• Issue a separate client key per agent and compare their usage.
• Send the same long prompt twice and look for cache behavior in the logs.
• Try the same setup with any existing proxy you already know and compare effort.

Key ideas

VRM

An open file format for 3D humanoid avatars, built on glTF, widely used by VTubers and avatar apps.

Rigging

Adding a skeleton to a 3D model so its body can bend and move in animation.

Human in the loop checkpoint

A point where an automated pipeline stops and waits for a person to approve or choose before continuing.

Steps

1. Read the Charakuru README on GitHub first, focusing on the workflow checkpoints and the terms of use.
2. Read the GIGAZINE article for the six stage walkthrough with screenshots.
3. Map which steps the agent does and which the user decides, and note why picking 3D candidates stays with the human.
4. Self check: what would break if the app let the agent continue past a checkpoint without review?

Steps

1. Download the kit zip from the Releases page of nanocle/Charakuru, not the Source code archive, and extract it to a writable folder.
2. Open the folder in Codex and ask it to read the root AGENTS.md and help start a character, as the README describes.
3. Open the local app at http://127.0.0.1:8766, or start it yourself with npm start in the folder.
4. Register your own illustration and run the first step, pasting each copied request into Codex and reviewing the 8 generated views.
5. Continue to the 3D candidate step, choose one, and note how long each agent step takes and where you had to intervene.

Small angles to try

• Skip the 3D stages and only study how the app hands prompts to the agent.
• Copy the checkpoint pattern into a small agent workflow of your own in another domain.
• Compare the UI requests in English and Japanese modes.

Key ideas

Agent environment

A managed workspace where an AI model can take actions such as editing files or running tests, not just answer questions.

Role based duties

Rules that assign separate obligations to the people who use, administer and build an AI system.

AISI

Japan's AI Safety Institute, a public body that works on evaluation methods and standards for AI safety.

Steps

1. Read the Digital Agency press release first to get the two environments and the timeline.
2. Open the summary PDF of the Gennai Standards linked from that page and note the three roles it defines.
3. Skim the ITmedia article for background on the May 2026 trial across all ministries.
4. Self check: which role in the Standards would own the decision to let an agent run tests on its own, and why?

Steps

1. Download the Gennai Standards PDF from the Digital Agency page.
2. Translate the table of contents and list every duty assigned to users, administrators and developers.
3. Map each duty onto a coding agent setup on your own machine, such as who approves file writes and who reviews logs.
4. Mark which duties your current setup already covers and which are missing.
5. Write a one page checklist your team could adopt from the gaps.

Small angles to try

• Compare the duties with your company's existing AI usage policy.
• Track the Gennai OSS Ver. 2.0 release planned for around February 2027 and note what it ships.

Key ideas

Memory scope

A boundary that controls which conversations can read and write a given set of remembered facts.

Access lock versus encryption

A lock only gates who can open something in the app, while encryption changes who can read the stored data at all.

Retention

How long a service keeps data on its servers, which a lock in the interface does not change.

Steps

1. Read OpenAI's help article on using locked chats first.
2. Note the list of chats that cannot be locked, such as temporary, archived, group and shared link chats.
3. Read the TechCrunch piece for what locking does not change.
4. Self check: after you unlock a chat, can its content still reach regular Memory?

Steps

1. Start a new chat with a harmless made up fact, such as a fictional favorite color.
2. Open the chat's options menu, choose Lock chat, confirm and create a four digit PIN.
3. Open a regular chat and ask what your favorite color is, to see whether the locked fact appears.
4. Add a second harmless fact inside the locked chat, then check again from a regular chat.
5. Write down the behavior you observed against the help page's memory rules.

Small angles to try

• Try locking a chat that has a scheduled task and note the refusal.
• Sketch how you would design separate memory scopes for your own assistant app.

Key ideas

Passive DNS

Databases that record which hostnames were looked up over time, searchable by anyone with access.

Capability URL

A link that grants access to anyone who has it, so its secret part must never be exposed.

robots.txt

A polite request to crawlers about what to index, which does nothing to block a direct visit.

Steps

1. Read Claroc's GhostShares post first for the method and hostname pattern.
2. Read the Unite.AI or Slashdot summary of the Ars Technica report for Meta's response.
3. List every place a hostname is visible: resolvers, logs, certificate transparency, scanners.
4. Self check: why is a random token in the URL path safer than the same token in a subdomain?

Steps

1. Search your own codebase for code that builds share or preview URLs.
2. Check whether any user written text or secret token ends up in a hostname rather than the path.
3. In a local container, run a resolver with query logging turned on and open one of your own test share links through it.
4. Read the resolver log and confirm exactly what a DNS observer would see.
5. If a secret appears in the hostname, move it into the path and repeat the check.

Small angles to try

• Check whether your share links expire or can be revoked.
• Review whether wildcard certificates or certificate transparency logs expose your share hostnames.

Key ideas

Day N retention

The share of new users who still open an app N days after installing it.

DAU

Daily active users, the number of distinct people using a product on a given day.

Steps

1. Read the TechCrunch article first for the Sensor Tower figures.
2. Open Apple's public top free feed to see where AI assistants rank today.
3. Compare the retention gap with the ad spend figure and decide how much each explains.
4. Self check: why can a product lead on downloads while trailing on retention, and which matters more for daily use?

Steps

1. Fetch the US top free feed at https://rss.marketingtools.apple.com/api/v2/us/apps/top-free/50/apps.json with curl.
2. Parse the results list and print the position and name of each entry.
3. Find the positions of Muse, ChatGPT, Claude and Gemini.
4. Repeat with the Japan feed by replacing us with jp and compare.
5. Save the output daily for a week to see how the AI apps move.

Small angles to try

• Track the top paid chart instead of top free.
• Plot the daily positions as a small line chart.

Key ideas

Attack surface reduction

Removing or gating code a deployment does not need, so unknown bugs in it cannot be reached.

Early reachability

Complex code that runs before authentication or before a protocol reaches the right state.

Configuration interaction

Two options that are fine alone but together silently weaken a security control.

Steps

1. Read Anthropic's post on using Claude to reduce the attack surface of code first.
2. Write down the three passes: default configuration, early reachability and configuration interaction.
3. Study the OpenSSH case and the hostname deny rule that failed open when reverse DNS was off.
4. Self check: why does each pass start with a fresh context, and what single note carries over?

Steps

1. Pick a service you own and list its entry points and its configuration options.
2. In a fresh agent session, ask only for code reachable in the default configuration that no default feature needs.
3. In a second fresh session, ask only what runs before authentication or before the first protocol state check.
4. In a third fresh session, ask for option pairs that silently disable or weaken a security control.
5. Treat every finding as a hypothesis, confirm it by reading the code, and run your test suite against any proposed gate.

Small angles to try

• Use runtime logs to find parsers and features that are never used.
• Check whether conflicting options are rejected when the configuration loads.

Key ideas

MPS backend

Metal Performance Shaders is the PyTorch device that runs tensor work on the GPU of Apple silicon Macs.

Grouped matmul

One kernel call multiplies several groups of tokens by their own expert weights, which is exactly what a mixture of experts layer needs during decoding.

GEMV

A matrix times vector kernel, the shape of work a language model does when it generates one token at a time.

Steps

1. Read the Hugging Face post "MPS in PyTorch 2.15" from the top, noting which numbers come from the text, the chart and the table.
2. Look at the F.grouped_mm example, where 64 tokens are split into groups of 16, 32 and 16 with an offsets tensor, and map it onto how MoE routing works.
3. Study the softmax chart, which compares MPSGraph at about 50 to 74 µs with the new Metal kernel at about 7 to 10 µs across vocabulary sizes.
4. Read the Wan2.2 memory section and note why the driver peak dropped while the allocator reserved peak stayed at 8.070 GiB.
5. Self check: why does a single token decode step favor GEMV and grouped matmul kernels over a regular large matmul?

Steps

1. Create a new virtual environment so the release candidate does not replace your working PyTorch install.
2. Install the release candidate with uv pip install torch==2.15.0 --index-url https://download.pytorch.org/whl/test/cpu.
3. Confirm that the MPS device is available from Python, then copy the post's FP8 example that quantizes two FP32 tensors with per tensor scales and multiplies them with F.scaled_mm into a BF16 output.
4. Run the post's F.grouped_mm example and compare its result with a plain loop that multiplies each token group by its expert weight.
5. Time a softmax over a 1 by 128256 FP32 tensor on MPS in this environment and in an environment with PyTorch 2.14, synchronizing before each timing.
6. If you run a small MoE model locally, record your own tokens per second on both versions instead of relying on either figure in the post.

Small angles to try

• Repeat the softmax timing at several vocabulary sizes to see whether you reproduce the 7x to 8x range from the chart.
• Use the new torch.mps.Stream context manager to overlap two independent workloads and check whether wall time drops.
• Compare memory use of FP8 and BF16 weights for one large linear layer.

Key ideas

τ²-bench

A benchmark from Sierra Research where an agent handles simulated customer service conversations in domains like retail and airline, against a simulated user.

Pass^4

The share of tasks the agent solves in all four of four independent trials, so it rewards consistency rather than lucky runs.

Learned guidelines

Short rules extracted from past successes and failures and placed in the prompt, a form of memory that changes behavior without training.

Steps

1. Read the IBM Research post on the Hugging Face blog, focusing on how guidelines are extracted and the difference between the sup3 and lossless configurations.
2. Compare the held out tables with the leaderboard claims and note which split each number comes from.
3. Check the cost table: lossless guidelines raised retail cost per conversation from $0.084 to $0.139.
4. Skim the τ²-bench repository README to see how tasks and the user simulator are defined.
5. Self check: why can a few hundred rules in the prompt help Pass^4 more than mean accuracy?

Steps

1. Install the package with pip install altk-evolve, or clone the repo and run uv sync inside a Python 3.12 virtual environment as the README shows.
2. Set OPENAI_API_KEY in your shell for the model that will write and use guidelines.
3. From the source checkout, start the web UI and MCP server with uv run evolve-mcp and open the UI at the local address the README gives.
4. Collect ten to twenty logs of your own agent on a small internal task set, marking each as success or failure.
5. Feed those logs through the tool to produce guidelines, append them to your agent's system prompt, and rerun the same tasks several times to compare consistency.

Small angles to try

• Hold back some of your tasks so the rules are judged on tasks they were not built from, as the post does.
• Cap the number of rules and see where cost per run rises faster than success rate.
• Write a handful of rules by hand and compare them with the learned ones.

Key ideas

Foundation Models framework

Apple's Swift API for prompting the on device system language model, with sessions, tools and typed outputs.

Guided generation

The model is constrained to fill a Swift type marked @Generable, so the app gets structured data instead of free text.

Package traits

Swift Package Manager switches that turn on optional backends such as MLX, CoreML or Llama, none of which are enabled by default.

Steps

1. Read the AnyLanguageModel 1.0 post on the Hugging Face blog for the list of new features and providers.
2. Open the GitHub README and read the requirements, the traits list and the provider examples.
3. Compare the MLX and Ollama initializers to see how only the model line changes between local backends.
4. Read the section on reasoning blocks and closure based API keys.
5. Self check: what breaks if a transcript with reasoning blocks is sent unchanged to a provider that cannot replay them?

Steps

1. Create a new Swift package and add the dependency .package(url: "https://github.com/huggingface/AnyLanguageModel", from: "1.0.0").
2. Pull a local model with ollama pull qwen3.5:9b as shown in the README comment.
3. Add import AnyLanguageModel and create the model with OllamaLanguageModel(model: "qwen3.5") as in the README example.
4. Open a session following the README, send a short prompt and print the reply.
5. Define a small @Generable struct, ask the model to fill it, and check the typed result.

Small angles to try

• Enable the MLX trait and swap in MLXLanguageModel(modelId: "mlx-community/Qwen3.5-4B-MLX-4bit") to compare local backends.
• Register one simple tool and confirm tool calling works with the local model.
• Build the same package on Linux to check the new server support.

Key ideas

World model

A generative model that predicts what a scene looks like next given actions, so it can act as an interactive environment.

Proxy rendering

A cheap low polygon render from a normal engine that tells the video model where things are, so it only has to add detail.

Causal distillation

Training a fast generator that only looks at past frames and needs very few denoising steps, so it can stream in real time.

Steps

1. Read the abstract and architecture figure on the Hugging Face paper page for Matrix-Game 4.0.
2. Watch the overview and held out game clips on the project page, using the slider that compares generated frames with proxies.
3. Read the Skywork/Matrix-Game-4.0 model card for the scene checkpoints, the realtime and quality presets, and the license notes.
4. Self check: which kinds of errors does keeping game rules in an engine prevent that a pure video world model would make?

Steps

1. Open the Skywork/Matrix-Game-4.0 model card and note that the weights need the Matrix-Game 4.0 inference source and are not drop in Diffusers pipelines.
2. Check the SkyworkAI/Matrix-Game repo for the 4.0 source and its releases/README.md, which the model card names as the place for exact download commands; at fetch the repo front page still listed releases up to 3.0.
3. Download one scene, for example the racing or castle scene, with the manifest downloader pinned to a Hub commit as the model card advises.
4. Run the realtime preset and log frames per second and memory on your own GPU.
5. Switch to the quality preset and compare visual detail against the speed cost.

Small angles to try

• Without a GPU, read the technical report and sketch how you would split state and rendering in your own simulation.
• Compare one step and two step generation on the same scene.
• Measure input latency by timing a key press until the frame changes.

Key ideas

Prompt caching

The API reuses work for an identical prompt prefix and bills those tokens at a lower cached input price.

Cache TTL

The minimum time a cached prefix stays available, 30 minutes by default and 12 hours with the new option.

Cached tokens

The cached_tokens count under input_tokens_details in the response usage tells you how much of the prompt hit the cache.

Steps

1. Read the Oct 20 entry in the OpenAI API changelog.
2. Read the prompt caching guide, especially the section on prompt_cache_options.ttl, breakpoints and the 1,024 token minimum.
3. Note that earlier models use prompt_cache_retention instead, as the guide explains.
4. Work out a break even: with writes at 2.5x input, how many cache hits per write are needed before the 12 hour option beats the default for your traffic?
5. Self check: why would a prefix that changes its first lines on every request never benefit from either cache?

Steps

1. Build a fixed system prompt and tool list longer than 1,024 tokens and keep it identical across calls.
2. Send a Responses API request with prompt_cache_options.ttl set to "12h" and record the usage block.
3. Send the same request again a few minutes later and check input_tokens_details.cached_tokens.
4. Repeat after an hour or more, longer than the 30 minute default, and confirm the prefix is still cached.
5. Compute the cost of both settings from your logged token counts and the published rates.

Small angles to try

• Run the same schedule with the default TTL to see when cache hits stop.
• Set a per breakpoint prompt_cache_breakpoint.ttl so only the stable part of the prompt uses 12 hours.
• Move a changing timestamp from the start of the prompt to the end and compare hit rates.

Key ideas

Ends versus means of education

The purpose schooling serves, such as citizenship or contribution, as opposed to the subjects and methods used to reach it.

Institutional staying power

Schools persist through endowments, prestige and childcare duties, not only through teaching content.

Steps

1. Read the essay at stevekrouse.com/ends in full first.
2. Write down the purposes he proposes and which one feels closest to why you learned to program.
3. Skim the top HN comments and note one argument that disagrees with him.
4. Self check: which skill you use at work would still matter if an agent could write all of your code?

Steps

1. Pick a topic you know deeply, such as a database you run or a language you teach juniors.
2. Ask the AI assistant to tutor you on it as if you were a beginner for 10 minutes.
3. List what it did well, such as pacing or examples, and what it got wrong or skipped.
4. Draft a one page learning plan for a junior colleague or a child on that topic that keeps the parts AI tutors did well and adds what only a human can supply.
5. Write one sentence on the purpose of that plan, following Krouse's idea of agreeing the purpose with the learner.

Small angles to try

• Repeat the tutoring session with a different assistant and compare the failure modes.
• Ask the learner, if one is available, what they want the skill for before writing the plan.
• Turn the list of AI tutor weaknesses into review questions for your team's onboarding docs.