Anup

AI Engineer @ Oxford Dynamics

AI Engineering Newsletter -

[Anup @Anup]

Claudialect: the words Claude Code (@ClaudeDevs) uses and why each one lasts about three months.
https://t.co/UBK3mDpqKl

@claudeai

[Anup @Anup]

Rex is changing the tui / multiplexer game ❤️

[Mitchell Hashimoto @mitchellh]

A quick demo of floating panes in Rex, some of their features, and how I use them in my daily workflow. I think our implementation of floating panes looks great and feels great and I think you'll love it! These are also all scriptable and API driven, too, of course!

[Anup @Anup]

If a better AI model comes out next month, does your product get better or worse?

I've been thinking about why the harder AI engineering problems are moving beyond the model itself.

Wrote about harnesses, data, evals, memory and security.

https://t.co/nAIf6on50x

[ClaudeDevs @ClaudeDevs]

We just let in every Pro and Max user from the Claude Code Projects waitlist!

If you're new to Claude Code Projects, here's a 4 minute walkthrough to get you started:

[Anup @Anup]

Reflection has just launched Beam, an open-weight 501B MoE model (with 23B active parameters) designed for coding and agents.
They claim it achieves performance comparable to GLM-5.2 in reasoning but uses three to four times less inference compute. The weights haven't been released yet, although they've shared scores, and Kimi and DeepSeek still come out on top on several evaluation benchmarks.
That said, a genuine open model from the West with an efficiency advantage is worth keeping an eye on. The weights are expected this month. https://t.co/NoWzTwzUpj

[ℏεsam @Hesamation]

found this free Harness Engineering course on GitHub with 14 lectures + 8 hands-on projects. it covers:

> how Claude Code, Codex, DeepSeek build their harness
> loop & graph engineering
> automated agent loops
> observability, testing and verification
really good source for learning harness essentials by doing.

https://t.co/ebOTeIRKuy

[Anup @Anup]

New agent eval unlocked: awareness of the page you’re currently embedded in 😄
The chatbot on LangChain’s Deep Agents docs page asked me where it could find the Deep Agents documentation.
@LangChain this one made me smile :)

[Prince does AI @princedoesai]

Holy crap.

Rick and Morty just explained Jev AI to me better than any tech demo could.

[Dario Amodei @DarioAmodei]

We Must Pace the Frontier: I’ve written a new essay on why the AI industry should slow down, with a three-part plan for doing so.

Anthropic is unilaterally committing to the first of these steps. We’ll provide third-party evaluators with permanent, employee-level access to our systems, so that they can verify adherence to our safety measures, report on incidents, and assess models’ alignment during training.

You can read the full post here: https://t.co/OGyPb7yaYt

[Theo - t3.gg @theo]

If you don't want to keep up with all the Astra vs Fable 5.1 content that is incoming, here's a quick summary

[Anup @Anup]

I’ve been coding with Claude Code for over a year, and my workflow is now much less “give it a prompt and hope for the best”.

I plan first, red-team the plan, review it myself, build in small PRs, and smoke-test everything locally.

I wrote up the full process here: https://t.co/HuVMRHdKLy

[Anup @Anup]

This only landed yesterday and it’s already doing the rounds.

Shopify CEO Tobi Lütke has open-sourced walgit, a Git server packaged as a single Rust binary and backed by S3 or GCS.

There’s no database, no leader and no local state you need to care about. The object store is the source of truth, while each server is effectively a disposable cache.

It’s based on the architecture Cursor described in its recent “Git at any scale” post, but designed to handle repositories larger than the machines serving them.

Already past 1,200 stars. Well worth a look if you work with large monorepos or distributed systems.

https://t.co/j3Sv5kCKkE

[Jacob @jacobpeake]

sharing a new long-form blog post: ai chip architectures

it covers the leading chip architectures (nvidia, amd, tpus, trainium, cerebras, groq) across architecture, scaling (scale-up and scale-out), and software stacks.

it helps build an intuition for the architectures and their trade-offs.

https://t.co/7eZMh3ddZS

[jietang @jietang]

Thoughts About Scaling Law

Scaling, but not only of parameters. Every model release now ends with the same question: how many parameters? It isn't a question that can be answered on its own. Parameter count is only meaningful alongside three others — how much data you have, where you intend to spend your compute, and who will run the model, under what conditions.

The field learned this the hard way. Kaplan et al. (2020) fit an exponent that told everyone to grow parameters faster than data — roughly 2.7:1 — and the industry complied: GPT-3, Gopher, MT-NLG. Hoffmann et al. (2022) redid the experiment across four hundred models and found the compute-optimal split is closer to 20 tokens per parameter, and that with sufficient compute the two should grow at the same rate rather than drifting apart. The error in the earlier fit compounded with every order of magnitude of compute, which is why the largest models of that generation were the most misallocated. The trillion-parameter round was, in retrospect, a detour the whole field took together and then reversed.

Chinchilla wasn't the end either. It optimized training compute for models that would be trained once and evaluated. Today a model is called billions of times a day and inference dominates lifetime cost. Put inference into the objective and the optimum moves toward smaller models trained far longer — deliberate over-training, which is what Llama-2-7B and Gemma-2-9B were doing at roughly 290 and 889 tokens per parameter.

Sparsity moved the target again. In a MoE model two quantities have to be kept apart: total parameters govern roughly how much the model can hold — knowledge, facts, the long tail — while activated parameters and effective depth govern roughly how far it can think, how many steps of a causal chain it can carry before it comes apart. A dense 20:1 ratio does not transfer. And the ratio isn't a single number at all: Roberts et al. (2025) find the optimal tokens-per-parameter is task-dependent, with memorization favoring more parameters and reasoning favoring more data. Follow-up work on MoE observes that at fixed TPP, pushing total parameters higher actually degrades reasoning, while activating more experts reliably helps it.

This matters for what we are building toward. Finding a vulnerability is not a retrieval problem. It doesn't come from having memorized more CVEs; it comes from carrying a twenty-step chain of inference to the end without losing the thread. That capability does not live in total parameter count.

Which brings us to this release. Total parameters appear to matter up to a threshold — enough to hold the world — after which additional capability comes from scaling elsewhere: effective depth per forward pass, and above all post-training. GLM-5.3 is our controlled experiment on that claim. Same base, same architecture, same total and activated parameters as GLM-5.2. One month of scaling long-horizon environments and RL. The gains are not marginal. Well, scaling has more than one dial. We turned the post-training one this time because it had the most slack left in it — not because the others are finished. Base model size, pretraining data, compute spent per forward pass: all of them are still on the table, and we will come back to each. What this experiment taught us is that the dials do not have to be turned together, and that the one worth turning next is rarely the one that was worth turning last. We are not done scaling. Next time, maybe mid-training, pre-training, and even more.

[Anup @Anup]

from @TheEconomist

[Anup @Anup]

@yangli_ @CosineAI Congrats

[Anup @Anup]

One agent or many? Start with the task, not the architecture. Use one agent for sequential, stateful work. Test several when the task splits cleanly or benefits from independent verification. Keep the complexity only if it materially improves the result.
https://t.co/yFmCk2tMYt

[Anup @Anup]

How Loop Engineering Builds on Prompt, Context, and Harness Engineering https://t.co/jUZ27gIzkn

[Anup @Anup]

Prompt engineering asks: how do I get a better response?
Loop engineering asks: how does the system know the work is actually done?
I just published an introduction to loop engineering, including how it builds on prompt, context, and harness engineering, and what reliable agent loops require in practice.
The key idea: the boundary is not model capability. It is verifiability.
https://t.co/7UkoJhCM2o
#AIEngineering #AgenticAI #LoopEngineering