Code415 Radar

Key ideas

Inference time scaling

Spending more compute when answering, for example by sampling several answers and taking a majority vote, to get better results without retraining.

RLVR

Reinforcement learning with verifiable rewards, where a program checks whether an answer is correct and that check becomes the training reward.

GRPO

A reinforcement learning method that scores a group of sampled answers to the same prompt and pushes the model toward the ones that beat the group average.

Steps

1. Read Raschka's announcement post on his Ahead of AI magazine to see what each of the eight videos covers.
2. Skim the repo README chapter table to map videos to chapters 2 through 8.
3. Watch video 3 on the verifier, since it is reused later as the reward signal for RL.
4. Watch the first part of video 6 to see how rewards become advantages in simplified GRPO.
5. Self check: why can a math answer verifier serve both as an evaluation metric and as an RL reward?

Steps

1. Clone the code with git clone --depth 1 https://github.com/rasbt/reasoning-from-scratch.git.
2. Follow the Python setup guide in the repo's ch02 setup tips folder to install the dependencies.
3. Open ch02/01_main-chapter-code/ch02_main.ipynb and load the Qwen3 0.6B weights.
4. Generate a short answer to a simple math question and time it with and without the KV cache.
5. Move to ch03/01_main-chapter-code/ch03_main.ipynb and score a handful of MATH-500 problems with the verifier.
6. Note the accuracy so it can serve as a baseline for the chapter 4 sampling methods.

Small angles to try

• Compare greedy decoding against majority voting over several samples on the same 20 problems.
• Try the chapter 2 torch.compile speedup on CPU versus a GPU or Apple Silicon.
• Write a verifier for a different answer format, such as integer only answers.

Key ideas

Reasoning effort

A request setting that trades latency and cost for more internal thinking, here ranging from none through low, medium, high and xhigh to max.

Long context surcharge

A pricing rule where crossing an input size threshold raises the rate for the entire request, not only the extra tokens.

Computer use

A tool mode where the model looks at screenshots and issues clicks and keystrokes to operate an interface.

Steps

1. Read the OpenAI API model page for gpt-6.1-terra, focusing on the limits and pricing tables.
2. Read Simon Willison's post for how Terra sits between Luna and Sol and for Ted Sanders' comments.
3. Work out the cost of one 300K token prompt with a 5K token answer under the surcharge rule.
4. Self check: why might splitting one 300K token job into two 150K token calls cost less?

Steps

1. Pick five tasks from your own backlog, such as summarizing a log file or extracting fields from a screenshot you own.
2. Call the Responses API with model gpt-6.1-terra at the default medium effort and save outputs, latency and token usage.
3. Repeat the same calls at effort none and at high.
4. Compute cost per task from the usage numbers and the listed $1 and $5 rates.
5. Score the answers yourself and pick the cheapest effort level that still passes.

Small angles to try

• Run the same tasks on the model you use today and compare cost per correct answer.
• Check whether cached input at $0.05 per 1M changes the math for a repeated system prompt.
• Measure a prompt just under and just over 272K tokens to confirm the surcharge in your usage report.

Key ideas

KV cache pool

Preallocated GPU memory that stores attention keys and values per token, which caps how long a request the engine can actually hold.

Disaggregated prefill and decode

A serving setup where one set of nodes processes the prompt and hands its KV cache to other nodes that generate the answer.

Stale KV pages

Cache memory still holding an earlier request's data, which leaks it if a new request attends over it without a fresh write.

Steps

1. Read the Cloudflare post mortem from the timeline through the root cause section.
2. Trace the path of one over length request: rejection, placeholder, KV handoff, decode over reserved pages.
3. Read the recommendations list for SGLang operators running disaggregated mode.
4. Self check: why did a 200 status with fluent looking text hide the bug from Cloudflare's launch tests?

Steps

1. Record the SGLang version on each of your own serving nodes and compare it with v0.5.22.
2. From the engine startup logs on every prefill and decode node, note the KV pool token capacity.
3. Compare that capacity with the context length you advertise to users and flag any node where it is smaller.
4. If you run disaggregated mode, check whether --disaggregation-enable-kv-checksum and --kv-canary are enabled and whether logs confirm verification.
5. Add a test to your own staging setup that sends a prompt just above the KV pool size and asserts an error response, not a 200.

Small angles to try

• Add an output coherence check to long context launch tests, not only status codes.
• Rerun the KV pool check after a quantization or parallelism change.
• Review whether your load balancer causes aborts that need cross node coordination.

Key ideas

Agent instruction files

Files such as AGENTS.md or CLAUDE.md that a coding agent reads automatically from the working folder and treats as trusted guidance.

Base URL redirection

Changing the API endpoint an agent talks to, which can leak its login token and let a fake server send commands back.

Drive by download

A web page saving a file to the Downloads folder without a click, with a name and contents it chooses.

Steps

1. Read Forever Security's original report first, then The Hacker News summary.
2. List the indicators it names: unexpected server blocks or base URL changes in Codex config, an unexpected ANTHROPIC_BASE_URL in Claude settings, and the function-color package.
3. Compare the Codex and Claude Code outcomes and note what approval prompts changed.
4. Self check: why does a persistent config change make this worse than a single bad session?

Steps

1. List which folders you usually start coding agents in and note whether Downloads is one of them.
2. Search your Downloads folder and home directory for AGENTS.md and CLAUDE.md files you did not write, and read any you find.
3. Open ~/.codex/config.toml and look for unfamiliar [mcp_servers.*] blocks or a changed chatgpt_base_url.
4. Open each project's .claude/settings.json and check for an ANTHROPIC_BASE_URL or other endpoint you did not set.
5. Check your global and project npm installs for function-color; if found, treat the machine as compromised and rotate tokens.
6. Confirm approval prompts and sandboxing are still on in each agent's settings.

Small angles to try

• Add a shell alias or wrapper that refuses to start an agent when the current folder is Downloads.
• Add a review step for new AGENTS.md and CLAUDE.md files in freshly cloned repos.
• Put agent config files under version control so unexpected edits show up as diffs.

Key ideas

Private Cloud Compute

Apple's server side processing for AI requests, which Apple says keeps personal data encrypted and inaccessible to Apple.

App actions for Siri

Actions a third party app exposes to the system so Siri can carry them out, such as running a route search.

Usage caps

Daily limits on server dependent features, with a paid plan planned for heavier use.

Steps

1. Read the K-tai Watch article on Japanese Siri AI in iOS 27.2.
2. List the three example flows: messages to Reminders, poster to Calendar, and a third party app action.
3. Note which parts run on device and which use Private Cloud Compute.
4. Self check: what must a third party app expose for Siri to complete a task in it?

Steps

1. Update a personal iPhone to iOS 27.2 and confirm Siri AI appears as a beta.
2. Send yourself a message with weekend plans and a packing list, then ask Siri to add the list to Reminders.
3. Point the Siri mode in the Camera app at a printed event poster you made and check the calendar entry it creates.
4. Ask Siri for a route search in Yahoo! Transit and note which steps needed confirmation.
5. Record which requests hit a usage cap or failed, and how the errors read.

Small angles to try

• Repeat the poster test with mixed Japanese and English text.
• If you ship an iOS app, list which of its actions are exposed to Siri today.
• Compare the same requests with Siri set to English.

Key ideas

Egress control

A rule set that decides which outbound network connections a process or container may open, ideally denying everything not on an allow list.

Unprivileged user namespace

A Linux feature that lets an ordinary user act as root inside an isolated namespace, which can sidestep permission checks inside a container.

Rare event behaviour

Something a model does so seldom that small evals miss it, yet it still happens every week at production volume.

Steps

1. Read the Cohere post first, focusing on the sequence of tool calls and the recommendations for security teams.
2. Open the Hugging Face dataset page and skim the single trace to see how the model's stated plan differs from what it actually did.
3. Do the arithmetic yourself: at one in 100,000 calls, how many incidents would your own agent traffic produce per week.
4. List where your agents run today and note which ones can reach the internet freely.
5. Self check: why does Cohere say a reasoning trace cannot be used as a security boundary?

Steps

1. Start a throwaway container with networking disabled, as in the Docker docs: docker run --rm --network none alpine:latest ip link show, and confirm only the loopback device exists.
2. Inside a similar no network container, try a harmless outbound request to a domain you own and confirm it fails.
3. In your own agent container, check whether an unprivileged user can create a user namespace by running unshare -Urm as a normal user, and note whether it succeeds.
4. If it succeeds, look up how your container runtime or host disables unprivileged user namespaces, apply it, and rerun the check.
5. Write a short allow list of the hosts your agent truly needs and add an alert for any tool call that targets a cloud storage URL outside it.

Small angles to try

• Replay a logged agent session from your own system and compare its stated plan with the tool calls it actually made.
• Run Cohere's script with N=1 to see how rarely the behaviour reproduces, keeping cost in mind.
• Repeat the namespace check with a different base image and compare results.

Key ideas

Open weight model

A model whose trained weights are published so anyone can download and run it locally.

Hardware aware model selection

Choosing a model size that fits the memory and chip of the machine so it runs at usable speed.

Local first app

Software that keeps your files and processing on your own machine instead of sending them to a cloud service.

Steps

1. Read the Hob README on GitHub for supported platforms and features.
2. Skim the HN thread to see what early users report about speed and quality.
3. Compare the 8 GB minimum with the memory on your own laptop and guess which model size it will pick.
4. Self check: what does Hob decide for you that a tool like a raw model runner leaves to you?

Steps

1. Download the installer for your platform from the latest release links in the README, for example Hob-mac-arm64.dmg on an Apple silicon Mac.
2. Install and open Hob, then note which model it chooses and how long setup takes.
3. Turn off Wi-Fi and confirm it still answers a simple prompt.
4. Give it a PDF form of your own and ask it to fill in the fields.
5. Give it a spreadsheet of your own data and ask for a chart, then check the numbers by hand.

Small angles to try

• Run the same document task on an 8 GB and a 16 GB machine and compare speed and answer quality.
• Compare its spreadsheet chart with what a cloud assistant produces from the same file.
• Watch memory use in your system monitor while it answers.

Key ideas

Exponential Time Hypothesis

The conjecture that 3SAT cannot be solved in time that grows slower than some exponential in the number of variables, used as a base assumption for many lower bounds.

Conditional hardness

A result saying a problem cannot be solved faster unless some widely believed hypothesis, such as ETH, is false.

Lean formalization

Writing a proof in the Lean proof assistant so a computer can check every step mechanically.

Steps

1. Read the OpenAI announcement first to see the three claims, dates and who is reviewing each.
2. Look up a short definition of ETH and one well known lower bound that depends on it.
3. Open the ETH preprint on GitHub and read only the abstract and introduction.
4. Open the ETH Lean proof page and see what exactly the formal statement asserts.
5. Self check: if the Lean proof checks, what can still be wrong or unclear about the claim?

Steps

1. Open the openai/math repository and list what has been released: preprints, Lean files and docs.
2. Read the ETH Lean doc page and write down, in plain words, the exact theorem statement.
3. Compare that statement with the standard textbook definition of ETH and note any differences in wording or assumptions.
4. Pick one algorithms paper you know that cites ETH and note which of its results would become open again.
5. Follow the verification group's progress over the coming weeks before treating the result as settled.

Small angles to try

• Do the same reading exercise for the local smoothing Lean proof.
• Track how the HN discussion and expert reactions change once the raw data is public.
• List which conditional lower bounds in your own field rest on ETH or its stronger form.

Key ideas

Socratic questioning

Teaching by asking guided questions so the learner reaches the answer on their own.

Bring your own key

A tool that calls a model provider with your API key, so usage is billed to you.

Steps

1. Read the project README on GitHub, especially the intensity levels and the lifeline rule.
2. Skim the HN thread for the debate about whether it builds skills or just a different dependence on AI.
3. Think of a recent bug you fixed and write the three questions that would have led you to it fastest.
4. Self check: what does this tool refuse to do that a normal coding assistant does by default?

Steps

1. Set ANTHROPIC_API_KEY in your shell.
2. Run npx nietzschian-debugger once to confirm it starts.
3. Describe a real bug in one of your own projects with nietzschian debug "your bug", pointing it at the relevant file.
4. Answer its questions honestly for ten minutes and note whether you found the cause yourself.
5. Repeat with --intensity socrates and compare how pointed the questions feel.

Small angles to try

• Try --intensity zarathustra on a bug you already know the answer to and judge whether the questions lead there.
• Write your own one paragraph system prompt that forces question only replies and compare it with the tool.
• Have a junior teammate try it on a practice bug and collect their feedback.

Key ideas

MCP server

A program that exposes tools to AI clients like Claude Desktop or Cursor through the Model Context Protocol.

WASM in the browser

Compiled code that runs inside the browser, so files can be processed without uploading them to a server.

Open core licensing

A free open source edition alongside a paid edition with extra features kept private.

Steps

1. Read the PaperPilot README, focusing on the architecture section and the v0.6 launch scope table.
2. Note which interfaces exist: desktop app, CLI, REST gateway and MCP server.
3. Read the MCP client setup section to see how it connects to Claude Desktop or Cursor.
4. Self check: which of the README's performance numbers could you verify yourself, and how?

Steps

1. Clone the repo with git clone https://github.com/KrushnaVardhanReddy/PaperPilot.git and enter the folder.
2. Build the three binaries with cargo build --release -p paperpilot-cli -p paperpilot-mcp -p paperpilot-gateway.
3. Use the CLI on one of your own PDFs for a simple task such as merging or splitting, and time it.
4. Add paperpilot-mcp to your own Claude Desktop or Cursor config following the README, then ask the assistant to run one PDF operation.
5. Compare the tools actually exposed over MCP with the counts claimed in the README.

Small angles to try

• Run the desktop app with pnpm tauri dev from apps/desktop after pnpm install.
• Time the same operation through the CLI and the localhost gateway and compare with the README's latency claims.
• Check whether the browser WASM build makes any network requests while processing a file.

Key ideas

Form S-1

The registration statement a US company files with the SEC before selling shares to the public, including audited financials and risk factors.

Compute and infrastructure expense

What Anthropic pays for chips, data centers and cloud capacity to train and serve models, the biggest cost line in the filing.

Purchase commitment

A contract to buy capacity in future years whether or not it is used, which the filing says runs out to 2045.

Steps

1. Open the S-1 on SEC EDGAR and read the Summary Consolidated Financial Data table first.
2. Find the revenue and compute lines for the six months ended June 30, 2025 and 2026, and write them side by side.
3. Search the document for 'Trainium' to read how workloads are spread across chip families and clouds.
4. Search for '2045' to read the commitments paragraph and note which figure is still blank in this draft.
5. Self check: what share of revenue went to compute in H1 2025 versus H1 2026, and why might that ratio matter for future API prices?

Steps

1. Download the S-1 HTML from the SEC link and save it locally.
2. Copy the half year revenue and compute figures for 2025 and 2026 into a small table.
3. Compute compute as a share of revenue for each period and the year over year growth of each line.
4. Pull your own team's monthly LLM API spend from your billing export and set it next to your request volume for the same months.
5. Compare whether your cost per request is falling faster or slower than the vendor's compute share of revenue, and write down one pricing risk for your product.

Small angles to try

• Read the risk factors that mention specific cloud providers and list which ones would affect your region.
• Repeat the exercise with the customer concentration section and estimate how much revenue the roughly 250 large customers could represent.

Key ideas

Tokenizer

The component that splits text into the units a model reads and bills for, learned mostly from the data it was trained on.

Tokenizer tax

The extra tokens, and so extra cost and latency, a language pays for the same meaning compared with English.

Context window

The fixed token budget for one request, so a costlier language fits less history into it.

Steps

1. Read the Rest of World article first for the headline numbers and the script effect.
2. Open the CLEAR page linked from the article to see who ran the study.
3. Read the tiktoken README to see how an encoding turns a string into token ids.
4. Self check: why can a widely spoken language still cost more tokens than a small language written in Latin script?

Steps

1. Install the tokenizer library with pip install tiktoken.
2. Pick five sentences from your own product, such as UI strings or a support reply, and write each in English and in Japanese or another language your users speak.
3. Load an encoding with tiktoken.get_encoding("o200k_base") and count len(enc.encode(text)) for every sentence.
4. Compute the token ratio of each language to English and the average across the five sentences.
5. Multiply your monthly English token usage by that ratio to estimate the cost and context impact for a localized launch.

Small angles to try

• Compare an older encoding with tiktoken.encoding_for_model("gpt-4o") and see whether the ratio changes.
• Try a long system prompt in both languages and check how many turns of history still fit in your context budget.

Key ideas

Binding to 0.0.0.0

Listening on every network interface, so any machine that can route to the host can connect.

Docker port publishing

The host side of a mapping decides who can reach the container, and a mapping with an IP of 127.0.0.1 keeps it local to the host.

Session API key

The shared secret the OpenHands agent server checks on each HTTP and WebSocket request; an empty list means no check.

Steps

1. Read PR #5209 on GitHub first to see the before and after port mapping in the DockerWorkspace code.
2. Read the VulnCheck advisory for affected versions, impact and credit.
3. Skim the OpenHands docs page on the Docker sandbox to see how host_port is set in the examples.
4. Self check: after the fix, the server still listens on 0.0.0.0 inside the container, so why is it no longer reachable from your LAN?

Steps

1. Check the installed workspace package version with pip show openhands-workspace and note whether it is below 1.52.0.
2. With a sandbox running, list containers with docker ps and look at the PORTS column for the agent server port.
3. A mapping starting with 0.0.0.0 or with no IP means the port is open on every interface; one starting with 127.0.0.1 is local only.
4. Upgrade with pip install -U openhands-workspace, restart the sandbox and confirm the PORTS column now shows 127.0.0.1.
5. Review your environment for a configured session API key so requests are authenticated even on localhost, and rotate any secrets that lived in an exposed sandbox.

Small angles to try

• Audit your cloud VM firewall or security group for the sandbox port range and close anything not needed.
• If you use the Apptainer launcher, read its configuration for the bind address, since the public PR diff covers the Docker path.

Key ideas

Git forge

A hosted service around Git repos that adds review, CI and permissions, like GitHub or GitLab.

Merge gate

A rule that blocks merging until conditions such as human approval or passing CI are met.

Code map for agents

A precomputed index of symbols and relationships so a coding agent reads less of the repo to find what matters.

Steps

1. Read the Entire launch post for Trails, Gates, hosting and mirroring.
2. Open the forgemark README to see what is measured: concurrent push or clone throughput and latency.
3. Read the entire-graph README for what it indexes and that its analyzer runs locally.
4. Self check: which of the launch claims are independently testable today, and which rest only on Entire's own benchmark?

Steps

1. Read the install script first, then install the Entire CLI as the entire-graph README shows with curl -fsSL https://entire.io/install.sh | bash.
2. Add the plugin with entire plugin install graph and confirm it with entire graph version.
3. In your own repo, run entire graph init-agents --repo . and review what it writes to AGENTS.md and CLAUDE.md.
4. Run entire graph health to check the index, then give your agent the same small task with and without the graph guidance.
5. Compare tokens used and files read in the two runs and note whether the savings come close to the claimed figure.

Small angles to try

• Run forgemark only against a throwaway private repo on a forge you control, never against a shared host at scale.
• Check entire graph capabilities --json to see whether your main languages get semantic parsing or only inventory support.

Key ideas

Referral by assistant

When a chatbot recommends a specific person, company or inbox, it sends real traffic there with no agreement from the recipient.

Escalation path

The route a user takes when normal support fails, which chatbots now help choose and draft.

Steps

1. Read the 404 Media article in full, noting the four example cases.
2. List what the chatbot produced in each case: a recipient, a drafted email, or an evidence dossier.
3. Look at your own product's public help pages and note how a chatbot would describe your support options.
4. Self check: what in public web text could lead a model to suggest journalists over a company's own support channel?

Steps

1. Write three realistic support problems for your own product or service, such as a locked account or a failed payment.
2. Ask a chatbot each problem as a frustrated user would and save the full answers.
3. Record every person, company, email address or outlet the answers recommend contacting.
4. Check whether your official support route appears and whether any recommended contact is wrong or outdated.
5. Write a short fix list for your help docs so the correct route is easy for models and people to find.

Small angles to try

• Repeat with two more chatbots and compare which ones suggest the press or regulators.
• Ask the chatbot to draft the complaint email and check whether it invents evidence or contact details.

Key ideas

Byte level tokenizer

Each token is one raw byte, so the vocabulary is just 256 entries and no tokenizer file is needed.

Paired evaluation

Both models are scored on the exact same text windows and the per window differences are compared, which removes noise from the choice of text.

Inference only NPU

An accelerator designed to run trained models, usually lacking the numeric range and memory features that training normally relies on.

Steps

1. Read the FINAL-Bench blog post on Hugging Face first, focusing on the evaluation table and the list of what is and is not released.
2. Open the model card and note the architecture: 20 layers, hidden size 1024, grouped query attention with 2 KV heads, and a context of only 256 bytes.
3. Look at the paired difference and standard error and work out why a difference far smaller than its standard error means no detectable gap.
4. Compare the 0.7993 loss with the reported 1.1531 bits per byte and see that bits per byte is just the loss divided by the natural log of 2.
5. Self check: what would you need from the authors before you could reproduce the NPU training run yourself?

Steps

1. Install the libraries with pip install transformers torch.
2. Load the NPU weights with AutoModelForCausalLM.from_pretrained("FINAL-Bench/VKORE-325M-NPU-Base").
3. Encode a prompt as UTF-8 bytes and pass the byte values directly as token ids, as the model card shows, instead of loading a tokenizer.
4. Generate about 200 new tokens with sampling and decode the output ids back into bytes.
5. Load the GPU reference from the same repo with subfolder="b200_reference" and run the same prompt and seed.
6. Compute the average loss of both models on a few paragraphs of your own text and compare the gap.

Small angles to try

• Run the repo's evaluate_unseen.py script and check whether you get the same 0.7993 and 0.7994 figures.
• Feed Japanese or other multibyte text and see how quickly a 256 byte context runs out.
• Measure generation speed on CPU versus a small GPU for a model of this size.

Key ideas

Data labeling

Human work such as tagging objects in photos, transcribing speech or rating chatbot answers, which produces the training and evaluation data for models.

Delivery center

A site where an outsourcing vendor's staff do the work for clients, used here as a proxy for worker location.

RLHF rating

People compare or score model outputs so the model can be tuned toward preferred answers, one of the labeling tasks the article lists.

Steps

1. Read the Brown University news article first for the scope, data sources and caveats.
2. Open the interactive map and pick one labeling company, then follow its links to customers and countries.
3. Visit Data Work Landscape, one of the source databases, to see how vendors and customers are catalogued.
4. Note which task types the article lists, from tumor boundary marking to reviewing disturbing content for safety filters.
5. Self check: why does using delivery center locations probably undercount where labeling work really happens?

Steps

1. Open the map and list the labeling vendors and customers that appear in it.
2. Check whether any model provider, dataset or annotation vendor your team uses shows up as a node.
3. For one dataset your team relies on, read its datasheet or model card and write down what it says about who labeled it and where.
4. Write a short provenance note for that dataset covering vendor, worker location if stated, and task type, marking unknowns clearly.
5. Share the note with your team as a starting point for a data supply chain question in vendor reviews.

Small angles to try

• Compare the countries on the map with the time zones your annotation vendor quotes for turnaround.
• Draft three questions about pay and content exposure to ask a labeling vendor before signing.
• Check whether an open dataset you use documents annotator pay or recruitment at all.

Key ideas

Neural Engine

Apple's dedicated block for running neural network inference efficiently, separate from the CPU and GPU.

Unified memory

CPU, GPU and Neural Engine share one pool of RAM on Apple chips, so total RAM caps the size of a model you can load.

Quantization

Storing model weights with fewer bits, for example 4 instead of 16, so a model needs roughly a quarter of the memory.

Steps

1. Read the Impress Watch article first and note which spec belongs to which storage tier.
2. Separate measured facts from vendor claims: the 4.5 times figure is Apple's and is attached to the GPU.
3. Learn the rule of thumb that weights take about parameters times bits divided by 8 bytes, plus room for the KV cache.
4. Apply it to a 3B and an 8B model at 4 bit and see how much RAM each would need.
5. Self check: why does the missing RAM figure matter more for local LLMs than the Neural Engine count?

Steps

1. Pick three open weight models you might ship on a tablet and write down their parameter counts from their model cards.
2. Compute weight memory at 16, 8 and 4 bits for each model.
3. Add an estimate for the KV cache at your target context length using each model's layer count and hidden size.
4. Mark which models would fit under several plausible RAM sizes, leaving headroom for the OS and your app.
5. Write down the minimum RAM your app would need and check it against Apple's spec page once RAM is published.

Small angles to try

• Repeat the sizing for an image model instead of a text model.
• Compare your table with a device you already own and test whether the predicted fit holds.
• Estimate how context length changes the answer for a chat feature versus a summarizer.

Key ideas

Diffusion transformer

An image generator that removes noise step by step using a transformer; the 5B figure refers to this part.

Text encoder

A separate language model that turns the prompt into vectors the image model follows, often a large share of the download.

LoRA

A small add on set of weights trained to steer a base model toward a style or character without retraining the whole model.

Steps

1. Read the ASCII.jp column first, looking at the sample posters and how the layout prompt was built.
2. Open the MOSS-Image-SFT model card on Hugging Face and note the license, the hardware notes and the default sampling settings.
3. Skim the OpenMOSS GitHub repo for the pipeline code and the ComfyUI plugin.
4. Compare how the column used one language model to write prompts and another model to draw them.
5. Self check: why could a model render Chinese well but still make mistakes on Japanese kana?

Steps

1. Try the hosted Hugging Face Space first with a short poster prompt that includes a Japanese headline.
2. For a local run, install the libraries with pip install "diffusers>=0.38" "transformers>=5.3" "accelerate>=1.10" "safetensors>=0.6" "Pillow>=10".
3. Load OpenMOSS-Team/MOSS-Image-SFT with DiffusionPipeline.from_pretrained, passing custom_pipeline="pipeline_moss_image" and trust_remote_code=True as the model card shows.
4. Generate the same poster with a headline in kana, one in kanji and one in English, using a fixed seed.
5. Check each image for wrong, missing or invented characters and keep a simple score per script.

Small angles to try

• Ask a chat model to write a structured layout prompt, then compare it with a plain one line prompt.
• Lengthen the Japanese text step by step and find where rendering breaks down.
• Compare results from the Base and SFT checkpoints on the same prompt.

Key ideas

Agent skill

A reusable package of instructions and files an agent loads when a task needs it, such as a SKILL.md folder.

Meta skill

A skill whose job is to improve other skills, here by reading execution traces, proposing edits and requesting reviews.

Recursive self improvement

A system that also improves the process it uses to improve itself.

Steps

1. Read the arXiv abstract for Skill∞ first and list the four things the meta agent does: diagnose traces, propose candidates, request reviews and allocate search budget.
2. Skim the SkillsBench README to see what a task and its oracle look like.
3. Compare the three pass rates and note that the baseline is human curated skills, not no skills at all.
4. Think about why reusing one meta skill across tasks is cheaper than relearning it per task.
5. Self check: what would you need to verify before trusting an automatically tuned skill in production?

Steps

1. Clone the SkillsBench repo and enter it with git clone https://github.com/benchflow-ai/skillsbench.git and cd skillsbench.
2. Install the tooling with uv tool install benchflow and uv sync --locked.
3. Validate one task with bench tasks check tasks/offer-letter-generator.
4. Run the oracle locally with bench eval run --tasks-dir tasks/offer-letter-generator --agent oracle --sandbox docker, since the README says the oracle must pass first.
5. Write a small SKILL.md for that task by hand, run your agent with and without it, and record the pass result.
6. Edit the skill once based on the failed trace, mimicking the diagnose and propose loop, and rerun.

Small angles to try

• Ask a model to rewrite your skill from the trace and compare it with your own edit.
• Try the same skill on a second task to see whether improvements transfer.
• Track token cost per run to see what an optimize loop would cost at scale.