Victor Sigler

Building things…

[Tibo @thsottiaux]

To calibrate you all on which reasoning effort to use for Astra, know that GPT-6 Astra on low performs better than GPT-5.6 Sol on high.

If you were using high reasoning efforts with Sol and were happy, I suggest you move down to low or medium for Astra.

[Bradley Bernard @bradleybernard]

PSA: GPT-6 Astra is out and it's time to audit your AGENTS.md and SKILL files, due to the new model!

Here is the Model guidance doc which should help: https://t.co/92b9UQgskB

Point Codex at that doc and let it rip in your repo, to improve Astra's performance!

[Addy Osmani @addyosmani]

Software quality now depends on the constraints you set around your agents.

When humans manually wrote most of the code we could look at the code itself for signs of quality. Is it clean? Is it thoughtful? Is it fast? Can another engineer understand it? Does it have tests?

Agents can now generate more code than people can read. When code generation scales beyond review, quality - checks for one or more of correctness, maintainability, security, performance etc - increasingly has to live somewhere else.

It moves into the harness, environment and operating system around the agent.

This can be the tests and deterministic checks that decide what the system is allowed to do (amongst others). Your constraints are what may eventually enable loops of agents to deliver production software reliably. They can include unit tests, property tests, acceptance tests, mutation testing and quality metrics.

This back-pressure lets the system resist bad work before it becomes somebody elses problem.

Set your constraints. They decide whether the code your agents generate is good enough to ship.

[Uncle Bob Martin @unclebobmartin]

Socialism is for kids, and people who never grew up. Capitalism is for adults. Deal with it.

[Robotaxi @robotaxi]

¿Qué lo que Miami?

Robotaxi now available in Miami

[Gergely Orosz @GergelyOrosz]

Anders Hejlsberg (@ahejlsberg) is a living legend: he created Turbo Pascal, Delphi, C# and TypeScript (and today TypeScript is the most-used programming language, globally, as per GitHub.)

Timestamps:

00:00 Intro
02:48 How Anders got into programming
05:40 Building his first compiler
07:44 Turbo Pascal
12:25 Delphi
14:53 Joining Microsoft
19:41 Building C#
29:11 Async/await
34:01 The rise of JavaScript
37:52 Building TypeScript
42:58 How the TypeScript compiler works
48:30 JavaScript’s strengths and weaknesses
52:18 How Anders uses AI
56:03 What language features work well with AI
1:02:49 How software craftsmanship is changing
1:07:49 Performance and efficiency
1:09:29 Anders’ tool stack
1:11:30 A 30-year career at Microsoft
1:13:40 Book recommendation

Brought to you by:

@AntithesisHQ – verify your system’s correctness without human review or traditional integration tests – and avoid bugs or outages. https://t.co/AKYm4cctss

@WorkOS – Everything you need to make your app enterprise ready. https://t.co/jhFNq3aFcF

@turbopuffer – a vector and full-text search engine built on object storage. It’s fast, cheap, and extremely scalable. https://t.co/w9y67GsFZJ

Four things that stood out to me:

1. “10x better for 1/10th of the price” is a proven winner.

This is what Turbo Pascal did: it sold for $49.95 when competing compilers cost $500, and it was faster and more interactive than competitors’ products. Conveniently, the low price tag also killed off piracy

2. C# might have not existed without a famous court case.

Microsoft originally hired Anders to architect its Java tools (Visual J++), but the Sun versus Microsoft lawsuit (1997-2001) meant Microsoft could not build on top of Java, as the company that owned Java’s IP (Sun) sued MS for alleged unauthorized changes to the Java language. Microsoft realized it had to build a new language that combined VB’s productivity with C++’s power. This led to C# and .NET.

3. TypeScript exists because Anders refused to build Script# for the Outlook .com team.

Microsoft’s Outlook .com team asked Anders’ C# team to productize “ScriptSharp,” a language to cross-compile C# to JavaScript. Anders and the C# team pushed back, suggesting that a better approach was to fix JavaScript. Anders felt strongly that to be attractive to the best-of-breed developers in the JavaScript ecosystem, you want people to write JavaScript, and not another language like C#.

4. Designing a programming language is a 10-year play.

As Anders puts it: “Version one is great, but has all sorts of issues. You’ve got to do version two, but it’s not until version three that it really starts to be great. Then you’ve got to convince people to adopt it.”

[Dwarkesh Patel @dwarkesh_sp]

Did a very different format with @reinerpope – a blackboard lecture where he walks through how frontier LLMs are trained and served.

It's shocking how much you can deduce about what the labs are doing from a handful of equations, public API prices, and some chalk.

It’s a bit technical, but I encourage you to hang in there - it’s really worth it.

There are less than a handful of people who understand the full stack of AI, from chip design to model architecture, as well as Reiner. It was a real delight to learn from him.

Recommend watching this one on YouTube so you can see the chalkboard.

0:00:00 – How batch size affects token cost and speed
0:31:59 – How MoE models are laid out across GPU racks
0:47:02 – How pipeline parallelism spreads model layers across racks
1:03:27 – Why Ilya said, “As we now know, pipelining is not wise.”
1:18:49 – Because of RL, models may be 100x over-trained beyond Chinchilla-optimal
1:32:52 – Deducing long context memory costs from API pricing
2:03:52 – Convergent evolution between neural nets and cryptography

[ClaudeDevs @ClaudeDevs]

Over the past month, some of you reported Claude Code's quality had slipped. We investigated, and published a post-mortem on the three issues we found.

All are fixed in v2.1.116+ and we’ve reset usage limits for all subscribers.

[Ethan Evans @EthanEvansVP]

For skeptics, it is not a fluffy, abstract piece about being “nice.” It is a step-by-step guide on how you can control your emotions and mindset going into turbulent times, based on practices used by Olympic athletes and special forces operators.

I recommend everyone read it here: https://t.co/MCqkV7ttke

[Sahil Bloom @SahilBloom]

Major cheat code for life: Increase your recovery speed.

You will get rejected. You will lose money. You will embarrass yourself. The goal isn't to avoid the fall. It's to shorten the time between the fall and the reset.

The ultimate life hack is the ability to quickly reset and recover.

From a poor decision. From a bad interaction. From a missed workout. From a bad day. You can start over whenever you want. You can't always control what happened, but you can control how long you carry it.

Fast recovery compounds.

[Boris Cherny @bcherny]

I wanted to share a bunch of my favorite hidden and under-utilized features in Claude Code. I'll focus on the ones I use the most.

Here goes.

[Rob Zolkos @robzolkos]

Claude Code can use a .worktreeinclude file in your project root to automatically copy gitignored files (e.g. .env, .env.local, config/secrets.json) when Claude creates a worktree.

[Sahil Bloom @SahilBloom]

I’m increasingly convinced that 15 minutes of prep on Sunday evening will save you 2 hours of work on Monday morning.

[Thariq @trq212]

https://t.co/taVRqwm4dG

[Andrej Karpathy @karpathy]

A few random notes from claude coding quite a bit last few weeks.

Coding workflow. Given the latest lift in LLM coding capability, like many others I rapidly went from about 80% manual+autocomplete coding and 20% agents in November to 80% agent coding and 20% edits+touchups in December. i.e. I really am mostly programming in English now, a bit sheepishly telling the LLM what code to write... in words. It hurts the ego a bit but the power to operate over software in large "code actions" is just too net useful, especially once you adapt to it, configure it, learn to use it, and wrap your head around what it can and cannot do. This is easily the biggest change to my basic coding workflow in ~2 decades of programming and it happened over the course of a few weeks. I'd expect something similar to be happening to well into double digit percent of engineers out there, while the awareness of it in the general population feels well into low single digit percent.

IDEs/agent swarms/fallability. Both the "no need for IDE anymore" hype and the "agent swarm" hype is imo too much for right now. The models definitely still make mistakes and if you have any code you actually care about I would watch them like a hawk, in a nice large IDE on the side. The mistakes have changed a lot - they are not simple syntax errors anymore, they are subtle conceptual errors that a slightly sloppy, hasty junior dev might do. The most common category is that the models make wrong assumptions on your behalf and just run along with them without checking. They also don't manage their confusion, they don't seek clarifications, they don't surface inconsistencies, they don't present tradeoffs, they don't push back when they should, and they are still a little too sycophantic. Things get better in plan mode, but there is some need for a lightweight inline plan mode. They also really like to overcomplicate code and APIs, they bloat abstractions, they don't clean up dead code after themselves, etc. They will implement an inefficient, bloated, brittle construction over 1000 lines of code and it's up to you to be like "umm couldn't you just do this instead?" and they will be like "of course!" and immediately cut it down to 100 lines. They still sometimes change/remove comments and code they don't like or don't sufficiently understand as side effects, even if it is orthogonal to the task at hand. All of this happens despite a few simple attempts to fix it via instructions in CLAUDE . md. Despite all these issues, it is still a net huge improvement and it's very difficult to imagine going back to manual coding. TLDR everyone has their developing flow, my current is a small few CC sessions on the left in ghostty windows/tabs and an IDE on the right for viewing the code + manual edits.

Tenacity. It's so interesting to watch an agent relentlessly work at something. They never get tired, they never get demoralized, they just keep going and trying things where a person would have given up long ago to fight another day. It's a "feel the AGI" moment to watch it struggle with something for a long time just to come out victorious 30 minutes later. You realize that stamina is a core bottleneck to work and that with LLMs in hand it has been dramatically increased.

Speedups. It's not clear how to measure the "speedup" of LLM assistance. Certainly I feel net way faster at what I was going to do, but the main effect is that I do a lot more than I was going to do because 1) I can code up all kinds of things that just wouldn't have been worth coding before and 2) I can approach code that I couldn't work on before because of knowledge/skill issue. So certainly it's speedup, but it's possibly a lot more an expansion.

Leverage. LLMs are exceptionally good at looping until they meet specific goals and this is where most of the "feel the AGI" magic is to be found. Don't tell it what to do, give it success criteria and watch it go. Get it to write tests first and then pass them. Put it in the loop with a browser MCP. Write the naive algorithm that is very likely correct first, then ask it to optimize it while preserving correctness. Change your approach from imperative to declarative to get the agents looping longer and gain leverage.

Fun. I didn't anticipate that with agents programming feels *more* fun because a lot of the fill in the blanks drudgery is removed and what remains is the creative part. I also feel less blocked/stuck (which is not fun) and I experience a lot more courage because there's almost always a way to work hand in hand with it to make some positive progress. I have seen the opposite sentiment from other people too; LLM coding will split up engineers based on those who primarily liked coding and those who primarily liked building.

Atrophy. I've already noticed that I am slowly starting to atrophy my ability to write code manually. Generation (writing code) and discrimination (reading code) are different capabilities in the brain. Largely due to all the little mostly syntactic details involved in programming, you can review code just fine even if you struggle to write it.

Slopacolypse. I am bracing for 2026 as the year of the slopacolypse across all of github, substack, arxiv, X/instagram, and generally all digital media. We're also going to see a lot more AI hype productivity theater (is that even possible?), on the side of actual, real improvements.

Questions. A few of the questions on my mind:
- What happens to the "10X engineer" - the ratio of productivity between the mean and the max engineer? It's quite possible that this grows *a lot*.
- Armed with LLMs, do generalists increasingly outperform specialists? LLMs are a lot better at fill in the blanks (the micro) than grand strategy (the macro).
- What does LLM coding feel like in the future? Is it like playing StarCraft? Playing Factorio? Playing music?
- How much of society is bottlenecked by digital knowledge work?

TLDR Where does this leave us? LLM agent capabilities (Claude & Codex especially) have crossed some kind of threshold of coherence around December 2025 and caused a phase shift in software engineering and closely related. The intelligence part suddenly feels quite a bit ahead of all the rest of it - integrations (tools, knowledge), the necessity for new organizational workflows, processes, diffusion more generally. 2026 is going to be a high energy year as the industry metabolizes the new capability.

[Ron DeSantis @GovRonDeSantis]

We are giving Florida families the information they need and the ability to choose the best infant formula for their babies.

We’re grateful to @SecKennedy and HHS for allowing WIC to cover a wider variety of infant formulas, so that families can more easily make the switch to a non-toxic product for their baby’s well-being.

[Dan Go @CoachDanGo]

Every pound you lose takes 4 pounds of pressure off your knees and 6 pounds off your hips.

A 5% reduction in body weight can result in a 50% reduction in joint pain.

Many people think they have knee or hip issues when it's a weight issue.

[rahul @rahulgs]

yes things are changing fast, but also I see companies (even faang) way behind the frontier for no reason.

you are guaranteed to lose if you fall behind.

the no unforced-errors ai leader playbook:

For your team:
- use coding agents. give all engineers their pick of harnesses, models, background agents: Claude code, Cursor, Devin, with closed/open models. Hearing Meta engineers are forced to use Llama 4. Opus 4.5 is the baseline now.

- give your agents tools to ALL dev tooling: Linear, GitHub, Datadog, Sentry, any Internal tooling. If agents are being held back because of lack of context that’s your fault.

- invest in your codebase specific agent docs. stop saying “doesn’t do X well”. If that’s an issue, try better prompting, https://t.co/SOjpn47yxo, linting, and code rules. Tell it how you want things. Every manual edit you make is an opportunity for https://t.co/S1ZvtYQwta improvement

- invest in robust background agent infra - get a full development stack working on VM/sandboxes. yes it’s hard to set up but it will be worth it, your engineers can run multiple in parallel. Code review will be the bottleneck soon.

- figure out security issues. stop being risk averse and do what is needed to unblock access to tools.

in your product:

- always use the latest generation models in your features (move things off of last gen models asap, unless robust evals indicate otherwise). Requires changes every 1-2 weeks - eg: GitHub copilot mobile still offers code review with gpt 4.1 and Sonnet 3.5 @jaredpalmer. You are leaving money on the table by being on Sonnet 4, or gpt 4o

- Use embedding semantic search instead of fuzzy search. Any general embedding model will do better than Levenshtein / fuzzy heuristics.

- leave no form unfilled. use structured outputs and whatever context you have on the user to do a best-effort pre-fill

- allow unstructured inputs on all product surfaces - must accept freeform text and documents. Forms are dead.

- custom finetuning is dead. Stop wasting time on it. Frontier is moving too fast to invest 8 weeks into finetuning. Costs are dropping too quickly for price to matter. Better prompting will take you very far and this will only become more true as instruction following improves

- build evals to make quick model-upgrade decisions. they don’t need to be perfect but at least need to allow you to compare models relative to each other. most decisions become clear on a Pareto cost vs benchmark perf plot

- encourage all engineers to build with ai: build primitives to call models from all code bases / models: structured output, semantic similarity endpoints, sandbox code execution. etc

What else am I missing?

[Years Progress @YearsProgress]

2025 is 99% complete.

[Pedro Piñera @pepicrft]

Week off, so I dove into approachable Swift concurrency after years of postponing.

Thanks to @mattiem's impressive work + coding agents for real-world analogies, I built mental models and made: https://t.co/8AJRcHz0yS

Probably got things wrong, feedback welcome!