azhdar

[Boris Cherny @bcherny]

tbh this is a good debate to have.

Here is what the timeline of the near past/future looks like to me:

1. Models are able to code better than I can
2. Models are able to do coding-adjacent engineering work better than I can: debugging, profiling, optimizing, bug fixing, system design, abstraction design, ui design, idea generation, etc.
3. Models are able to do most things that can be done on a computer better than most people

For the kinds of coding that I do, Claude has achieved 1 and some (but not all) of 2. It is showing early-ish signs of 3.

This is not the case for all coding yet. If you are Anders Hejlsberg and are a world class expert in compilers and type systems, Claude might not be at 1 yet. My bet would be that it gets there quite soon, while at the same time pushing further into 2-3 territory for the rest of us.

You can think of model capabilities as capturing the distribution of human ability. I consider myself an average programmer so Claude has already surpassed me, but the same is not yet true for everyone.

Back in Nov 2025 I fully stopped writing code by hand, though I continue to code (using agents) every day. That is the point where for me and many others around me, it felt fair to say that coding is solved. But engineering is more than coding. Claude’s code is not perfect. It has bugs and inefficiencies. Claude can code, but it cannot yet do everything that goes into engineering.

Opus 4.8 is the first model that felt like it could code better than me. Fable now routinely finds optimizations and debugs issues that I would not have been able to fix myself. And with each generation, the code the model produces continues to improve, and the model is able to do more of the non-coding parts of engineering.

[Boris Cherny @bcherny]

As engineering, product, design, DS, etc. melt into a new kind of role, I was reflecting on what roles might look like in the future. For example, when I look at the Claude Code team I see what I think is five archetypes:

1. Prototyper: comes up with brand new ideas; churns out many ideas, most of which don't ship
2. Builder: quickly turns a prototype/idea into production-grade product/infra
3. Sweeper: cleans up the UI, simplifies the code and system, unships, optimizes performance
4. Grower: takes a product that has been built and iterates on it to improve Product-Market Fit
5. Maintainer: owns a mature system to make it secure, reliable, fast, and efficient as it scales

Many people span across 2 roles, and sometimes 3 roles. I also notice that these roles are not really tied to job function -- eg. across Anthropic, some designers match category 1, some 2, some 3; same for engineers, PM, DS.

A healthy team needs a mix of these, depending on the product:

- A product that is new and pre-PMF needs people that are strong at 1+2+3
- A product that is growing and has found PMF needs 2+3+4 and some 5
- A product that has strong PMF needs 3+4+5 and some 2

Maybe product roles of the future will look more like this, and less like the domain-specific roles of today?

[Max For AI @MaxForAI]

卧槽，终于有人对CAD行业下手了

过去几年，我们见到了很多3D的AI模型，但是那些都是玩具，很难用，基本无法用到到工业生产

但刚刚麻省理工开源了一个将照片转换为可完全编辑的 CAD 程序的 AI 模型GenCAD，它悄然终结了每小时 150 美元的 CAD 建模行业。

GenCAD不只是生成一个3D外形。

它做的是：给一张CAD图像/渲染图，生成对应的参数化CAD命令序列，也就是CAD program，再通过几何内核转成3D solid model。

重要的是它保留了「建模历史」。

所以它不是「AI画了个3D玩具」，而是在尝试把图片变成可编辑、可制造流程能继续接住的CAD模型。

同时它：

→ 无需 SolidWorks 许可
→ 无需数周建模
→ 不需要 CAD 工程师

100% 开源

如果后续这条路线跑通，CAD行业最贵的那部分时间，草图理解、参数化建模、反复改模型，都会被一点点吃掉。

代码、数据和预训练模型入口都已经放出来了。

GenCAD可能是AI真正进入工业设计工作流的一个信号。
项目地址：https://t.co/R9eJ3lMhP4
视频Demo：https://t.co/WY3SGe9yyR
Paper：https://t.co/kBReJW3X8N
github：https://t.co/kKT2uInMBX

[Alex Albert @alexalbert__]

With the help of Claude Mythos Preview, the Firefox team fixed more security bugs in April than in the past 15 months combined.

[Himanshu Kumar @codewithimanshu]

The Head of Claude Code at Anthropic hasn't written code by hand in months.

In 2 days he shipped 49 full features. 100% written by AI.

He just dropped a 30-minute talk on exactly how he does it.

More valuable than any $500 vibe coding course. Bookmark it.

[Claude @claudeai]

Now in research preview: routines in Claude Code.

Configure a routine once (a prompt, a repo, and your connectors), and it can run on a schedule, from an API call, or in response to an event.

Routines run on our web infrastructure, so you don't have to keep your laptop open.

[Antonin Garrone @antonin_garrone]

Les données disponibles sur https://t.co/Yz6AmwMTfb sont désormais interrogeables via un serveur MCP dédié en experimentation, vos retours sont bienvenus !

💻 Le code est ouvert et accessible sur GitHub :
https://t.co/AmY04V22TH

Pour en savoir plus : https://t.co/V7UJrc6uUq

[Yann LeCun @ylecun]

@alexandr_wang Nice. Congrats 👏

[Andrew Farah @andrewfarah]

sharing my first open source project

a CLI for downloading and syncing your X bookmarks locally so your agent can access them. it's free

› npm install -g fieldtheory
› login to your X account in a chrome tab
› ft sync (done!)

bonus:
› ft viz
› ft classify

[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.

[Simon B. Støvring @simonbs]

I’ve been working on something… and it’s now on the App Store! 👀

Introducing brrr 🚀

Push notifications to your own devices. Instantly.

No signup. No dashboard. No nonsense.

Link in 🧵

[Paweł Huryn @PawelHuryn]

73 product releases in 52 days. That's not a launch cadence — that's a different kind of company.

I tracked every Anthropic release from Feb 1 to Mar 23 by going through @bcherny, @trq212, @noahzweben, @felixrieseberg, @lydiahallie, @amorriscode, @feldman, @dickson_tsai, and @claudeai. Built a calendar with first-announcement attribution.

Look at the acceleration. February had bursts with gaps between them. March 9 onward is almost every single day — Code Review, Channels, Dispatch, Computer Use, back to back.

The individual features get coverage. The shipping velocity doesn't. It should.

[Camille Roux @CamilleRoux]

https://t.co/UWgi0SDCVC détecte ton matériel (GPU, CPU, RAM) et te dit quels modèles d'IA tu peux faire tourner en local, directement dans le navigateur.
https://t.co/Pcgx47K23a

[Ryan Leachman @RG_Leachman]

I asked Claude to build my daughter an app that plugs into our piano, can read live key strokes, can show her sheet notes and key view and ends with a Guitar Hero style game. All while giving progressively harder songs. Today she’s using It and crushing It.

[klöss @kloss_xyz]

you paying attention?

Anthropic is closing the gap on the exact infrastructure that made OpenClaw so valuable.

Claude’s recently shipped:

→ dispatch (text your agent from your phone, it works on your machine)
→ scheduled tasks (recurring autonomous workflows)
→ remote control (monitor live sessions from anywhere)
→ agent teams (parallel multi-agent coordination)
→ channels (control Claude Code via Telegram and Discord)
→ auto memory (persistent context across sessions)
→ context compaction (stays coherent over long runs)
→ plugin marketplace (extensible skill system)

not long ago you needed a custom framework or OpenClaw just to get Claude running on a loop. now it’s native.

the moat for open source agent frameworks has fully shifted. it’s no longer “can it run autonomously?”, it’s “who runs it with more swagger?”

the infra always gets commoditized.

what you build on top of it doesn’t.

[Todd Saunders @toddsaunders]

The token cost to build a production feature is now lower than the meeting cost to discuss building that feature.

Let me rephrase.

It is literally cheaper to build the thing and see if it works than to have a 30 minute planning meeting about whether you should build it.

It’s wild when you think about it.

This completely inverts how you should run a software organization. The planning layer becomes the bottleneck because the building layer is essentially free. The cost of code has dropped to essentially 0.

The rational response is to eliminate planning for anything that can be tested empirically. Don’t debate whether a feature will work.

Just build it in 2 hours, measure it with a group of customers, and then decide to kill or keep it.

I saw a startup operating this way and their build velocity is up 20x. Decision quality is up because every decision is informed by a real prototype, not a slide deck and an expensive meeting.

We went from “move fast and break things” to “move fast and build everything.”

The planning industrial complex is dead.

Thank god.

[azhdar @azhdar]

https://t.co/t17CAIj867

[Alex Veremeyenko @alex_verem]

🚨BREAKING: Alibaba tested AI coding agents on 100 real codebases, spanning 233 days each.
the agents failed spectacularly.

turns out passing tests once is easy. maintaining code for 8 months without breaking everything is where AI collapses.

SWE-CI is the first benchmark that measures long-term code maintenance instead of one-shot bug fixes.
each task tracks 71 consecutive commits of real evolution.

75% of AI models break previously working code during maintenance.
only Claude Opus 4 stays above 50% zero-regression rate. every other model accumulates technical debt that compounds over iterations.

here's the brutal part:

- HumanEval and SWE-bench measure "does it work right now"
- SWE-CI measures "does it still work after 6 months of changes"

agents optimized for snapshot testing write brittle code that passes tests today but becomes unmaintainable tomorrow.

Alibaba built EvoScore to weight later iterations heavier than early ones. agents that sacrifice code quality for quick wins get punished when consequences compound.

the AI coding narrative just got more honest: most models can write code. almost none can maintain it.

[Gergely Orosz @GergelyOrosz]

What does it mean for software engineering when we no longer write the code? Here's the take from Boris Cherny (@bcherny), the creator of Claude Code. Timestamps:

00:00 Intro
11:15 Lessons from Meta
19:46 Joining Anthropic
23:08 The origins of Claude Code
32:55 Boris's Claude Code workflow
36:27 Parallel agents
40:25 Code reviews
47:18 Claude Code's architecture
52:38 Permissions and sandboxing
55:05 Engineering culture at Anthropic
1:05:15 Claude Cowork
1:12:48 Observability and privacy
1:14:45 Agent swarms
1:21:16 LLMs and the printing press analogy
1:30:16 Standout engineer archetypes
1:32:12 What skills still matter for engineers
1:35:24 Book recommendations

Brought to you by:

• @statsig  — ⁠ The unified platform for flags, analytics, experiments, and more. https://t.co/ZCSOIcWv31

• @SonarSource – The makers of SonarQube, the industry standard for automated code review. Proactively find and fix issues in real-time with the SonarQube MCP Server: https://t.co/RkEeF7gDc3

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

Three interesting things from this conversation:

1. Boris automated himself out of code review well before AI.

Boris was one of the most prolific code reviewers at Meta company. And he worked hard to minimize time spent on code review. His system::every time he left the same kind of review comment, he logged it in a spreadsheet. Once a pattern hit 3-4 occurrences, he’d write a lint rule to automate it away!

2. PRDs are dead on the Claude Code team: prototypes replaced them.

Instead of writing Product Requirement Documents (specs), they build hundreds of working prototypes before shipping a feature. Boris: “There’s just no way we could have shipped this if we started with static mocks and Figma or if we started with a PRD.”

3. This is the year of the generalist (and maybe the year of those with ADHD)

Boris’s work has shifted from deep-focus single-threaded coding to managing multiple parallel agents and context-switching rapidly. As Boris put it: “It’s not so much about deep work, it’s about how good I am at context switching and jumping across multiple different contexts very quickly.”

[Aakash Gupta @aakashgupta]

The PM skill that matters in 2026 is taste at speed. Boris Cherny just showed everyone what that looks like.

His Claude Code team at Anthropic doesn’t write PRDs. They build hundreds of working prototypes before shipping a single feature. Boris personally ships 20-30 PRs a day running 5 parallel Claude instances. They built Cowork, a full product for non-engineers, in about 10 days.

Everyone in the replies is debating whether PRDs should die. Wrong conversation. The real question is what happens to the PM who can’t evaluate 15 prototypes and pick the 3 worth shipping.

Because here’s what changes when building costs near zero: the bottleneck moves from “can we build it” to “should we ship it.” PRDs existed because building was expensive and you needed sign-off before committing resources. When a prototype takes 45 minutes instead of 6 weeks, nobody needs a document to authorize exploration. They need someone who can look at working software and say “this one, not that one” in real time.

On the Claude Code team, PMs code. Data scientists code. User researchers code. Boris said productivity per engineer grew 70% even as Anthropic tripled in headcount. The coordination cost of translating specs into code disappears when everyone can build. And that changes what a PM is actually good for.

Boris said it himself: “There’s just no way we could have shipped this if we started with static mocks and Figma or if we started with a PRD.” The old process would have spent more calendar time documenting Cowork than his team spent building it.

This is the Claude Code team today. It will be most fast-moving teams within 18 months. The PMs who thrive will be the ones reviewing prototypes at 9am, killing 80% of them by noon, and shipping the survivors by end of week. Pattern matching across user research, technical feasibility, and business model simultaneously while staring at working software.

The PMs who struggle will be the ones still writing 15-page specs for features that could be prototyped, tested, and validated before the doc hits its first review cycle. Taste at speed is the new moat.