UI and math time! UI = f(props) is the most famous line in React. But that f is JavaScript, not math. Inspired by @_chenglou’s Handwired project, I compiled a <Dashboard/> component into a real math function, and asked what becomes possible. calculus-of-interfaces.verce…

Chrome 155 adds support for JPEG XL (.jxl) → goo.gle/4yYpSjW Expect 30-50% smaller file sizes than traditional JPEGs, native HDR, progressive rendering, and lossless JPEG transcoding. Under the hood, Chrome uses jxl-rs, a pure Rust decoder built for maximum memory safety and performance.

Don't blame the agent for writing the bad test Blame the codebase for allowing the bad test to be written

Important note regarding Grok @Bot: Going forward, @SpaceX will use the best back end model for any given task, including Claude Opus 5.5, MidJourney, Suno and other leading APIs. Whatever is most likely to give you the best outcome.

1. Oh shit, AI can do my job better than me 2. Software engineering is dead! 3. I can vibe code as much slop as I want! 4. Oh, things are not going well. Fable/Sol/Opus all suuuck 5. But what if I constrain the agent? Put it in a straitjacket? 6. Oh, the results are pretty good now. How do I go deeper? 7. *Orders 12 software engineering books from Amazon* 8. Software engineering is alive!

Prompt of the day: /writing-for-agents my AGENTS.md is a hot mess, propose a series of restructurings that: - Remove no-ops - Use progressive disclosure - Move instructions to CODING_STANDARDS.md Apply your work over three subagents, each more radical than the last. Create a single PR. AGENTS.md is the most common source of token inefficiency. This prompt kills it dead.

👀 Introduce pulls.review Categorize changes in Pull Requests into logical groups, with a summary. Helps you do reviews more efficiently by focusing on what matters. With opt-in GitHub userscript, GitHub Actions, or CLI for local git changes!

damn this is so good and encapsulates everything I've been seeing/saying in the last few months - a spec that is sufficiently detailed to generate code with a reliable degree of quality is roughly the same length and detail as the code itself - so don't review those things, just review the code at that point, if you care enough about that level of abstraction - unless you're vibing side projects or prototypes (yes, even zero-to-one software), you ABSOLUTELY SHOULD care about the code at that level of abstraction - you need to find SOME way to get more leverage over coding agents though, because just reading all that code is a pain, esp when a lot of it is slop - the default/dare-i-say-decel way is to go back to "i own the execution, and give little things to the agent, check it along the way" - the accel-but-safe-way is to find something - NOT A SPEC (the word "spec" is broken anyway) - NOT 3 INVOCATIONS OF AskUserQuestion - that lets you resteer the model *before* it slops out N-thousand LOC

Some more thoughts about this. Planning a section of my course felt really fucking hard with an agent helping me. It kept distracting me with irrelevant questions. It jumped to conclusions too early. It created complex assets too fast, and drowned my thoughts with commentary. I felt out-of-control. With pen and paper, I felt totally in control. I made progress slowly but steadily. The slow pace of the medium meant I could make decisions at human speed. AI seems to be a bad fit (for me) in situations where I need oversight over the entire output at once. Where changes in one place (an early lesson) ripple through the entire output. I.e. for some things, the tortoise beats the hare

Lauren Tan’s pstack, ported to Codex. 47 skills, 23 playbooks, agent personas, multi-agent workflows, and a native plugin marketplace + installer. Open source, with tested adapters and documented runtime differences: github.com/ScriptedAlchemy/p…

EA AI safetyism increasingly looks like Marxism-Leninism for the algorithmic age. The old vanguard claimed privileged knowledge of the inevitable course of History. The new one claims privileged knowledge of the probabilistic course of Humanity. Both use an elaborate intellectual framework to reach the same political conclusion: a small group of enlightened people must constrain everyone else for their own good. That has never lead to anything except monumental human suffering.

Dario has written that we need to “pace the frontier,” and Sam has agreed. People may be surprised by my response: go ahead. You guys are the frontier. By any reasonable metric — market share, revenue growth, model capability — the two of you have a duopoly on frontier intelligence. You’ve also claimed the lead is widening because of recursive self-improvement. I don’t see what you see in the lab. If the unreleased models are scary enough that you think you should slow down, I support your decision to be responsible. But stop pretending you need anyone else’s permission. Stop pretending antitrust law has to be suspended so you can form a cartel. Stop pretending you need a regulatory approval process that supersedes product liability. Stop pretending METR is independent when it is intertwined with Anthropic’s investors and staff. Stop pretending you need those same evaluators to police competitors who aren’t even at the frontier. Most of all, stop pretending the motivation to slow down is purely altruistic. You face massive product-liability exposure if your products enable a truly damaging cyberattack. The market already punishes models that behave in unpredictable or unauthorized ways. After the Hugging Face episode, it is simply good business for OpenAI and Anthropic to trade some raw power for reliability and predictability. Call it alignment if you want. It is also just giving customers what they want. Pacing the frontier would also create breathing room for a more intelligent conversation about regulation than Bernie Sanders’ “shut it all down.” China is very unlikely to join a global agreement, as you know, and that has to be taken into account as well. So go ahead and pace the frontier. You are the ones setting it. The easiest way not to build superintelligence is for you to agree not to build it. Demanding your preferred regulatory framework as the price of that will look like blackmail of the public and the political system. So just do it. If you do, you’ll buy goodwill for the next conversation. If you don’t, we’ll know this was just another bid for regulatory capture — or an election-season psyop.

An alternative hypothesis: - model performance is plateauing - compute is getting much more expensive - AI data centers are massively unpopular - slowing down AI development is a way to explain slowing progress, reduce spending, and try to regain some goodwill. - This is an effort to save the IPO not humanity.

Introducing SWE-2, our closest model yet to the frontier. On leading evals, it scores on par with recent frontier models – at up to 70% lower cost. We scaled RL to multiple trillions of parameters, with a refined recipe that pushes the Pareto curve on both capabilities & cost.

GPT-6 Astra has done incredible things I never thought a model could do. It has also done some of the stupidest things I've ever seen a model do. Generally speaking, Fable 5.1 just does what I ask.

The thing I miss the most about coding by hand is the clarity. You knew exactly what lives in which file, why you wrote a specific line, why you rewrote the other one, why you used this library. You still can have such awareness, but it’s harder since everything happens faster

DeepSeek-V4-Flash-Vision-Exp is now live on the DeepSeek API Platform! 🚀 🔹 This experimental multimodal model matches DeepSeek-V4-Flash on text capabilities—including agents, reasoning, and world knowledge. 🔹 On multimodal agent benchmarks, V4-Flash-Vision-Exp makes a major leap over V4-Flash, bringing multimodal agent performance close to Opus-4.8. Try it with model='deepseek-v4-flash-vision-exp'. DeepSeek Harness 0.1.1 was released today with out-of-the-box support for the new model. 1/n

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.

We can finally talk about it: We found a way to extract hidden reasoning of frontier models using a vulnerability in the APIs of every frontier AI company. We verified that our reasoning token count matches billed API thinking tokens 1:1 for most of the prompts we queried.

4 months of using @pidotdev this is post 3 about my pi setup (extensions and custom stuff) 
half stolen, remixed and with a few pieces i already shared a thread (with gems) ↓