Joe Savona

@trevorlasn I orchestrated the port to not just ensure that all tests pass, but to ensure the intermediate representation is identical after every compiler pass (~50 of them). So the logic is right, the gap is around data structure choices and code style.

@en_JS ai cleaning up its own mess, love it. is the gap mostly style stuff or does it actually get logic wrong too?

React Compiler: Rust edition is coming soon. We've ported the majority of the passes using AI. When the initial port finishes we'll do some updates to get the code in a state we're happy to maintain, then extensive testing and look at performance. More to come soon

@trevorlasn it needs a decent bit of cleanup, but i'm just automating that too

@en_JS using AI to port the compiler that will optimize AI-generated code. that's a nice recursive loop. curious how much manual cleanup the AI port actually needed, or if the Rust type system caught most of the issues on its own?

@tomasz_ducin I understand it, since it's close enough to the original code. We definitely expect to iterate on it though, i'll probably go over every single file and make edits (by adding code comments, telling AI to fix)

@en_JS Genuine question: how much does the team understand the new Rust implementation? ("using AI")

@kurtextrem We use our own intermediate representation since the analysis and optimization we do is comparable to that of optimizing compiler for static languages. We'll work with partners to create bindings for all the various build tools.

@en_JS Based on oxc?

@Meligy @yongsk0066 Yeah all the new lint rules are also powered by the compiler so this means the lint rules too

This is awesome news. Thank you so much. Any chance of linting rules are also rust based? Or else, would that rust compiler improve the speed of existing react ESLint hooks plugin? On my monorepo, oxlint without the JS plugin finishes with type aware and type checking in <3s, but with it, 18-26s Double that I think on CI. CC @boshen_c

@bcherny Command approval is so broken. I'll approve two independent commands, and then get asked for permission to do `cm1 && cmd2`, or run an approved command in a loop

5/ Pre-approve common permissions Claude Code uses a sophisticated permission system with a combo of prompt injection detection, static analysis, sandboxing, and human oversight. Out of the box, we pre-approve a small set of safe commands. To pre-approve more, run /permissions and add to the allow and block lists. Check these into your team's settings.json. We support full wildcard syntax. Try "Bash(bun run *)" or "Edit(/docs/**)" code.claude.com/docs/en/permis…

Reflecting on what engineers love about Claude Code, one thing that jumps out is its customizability: hooks, plugins, LSPs, MCPs, skills, effort, custom agents, status lines, output styles, etc. Every engineer uses their tools differently. We built Claude Code from the ground up to not just have great defaults, but to also be incredibly customizable. This is a reason why developers fall in love with the product, and why Claude Code's growth continues to accelerate. I wanted to share a few ways we're seeing people and teams customize their Claudes.

Feels like subconsciously trying to retain control — "sure maybe i won't code but i'll retain control of the tasks". I think we have to let go of code and low-level tasks, direct the architecture and goals.

There are so many takes on the "give the agent a DAG of tasks" idea. But the reality is that task lists were always an attempt to impose order against fundamentally chaotic systems. You find the dependencies by doing tasks as often as you realize them in advance.

@teemu_taskula @rickyfm If i'm reading the Babel docs correctly globs should work in overrides. Can you file a GitHub issue?

Might be a skill-issue but it seems that the docs for React Compiler's "Directory-Based Adoption with Babel Overrides" don't quite work The `test` glob pattern for the override doesn't work but if I change it to be a regex pattern it works @en_JS @rickyfm

@raythurnvoid @rickyfm Can you file a GitHub issue with a repro using playground.react.dev? Thanks!

@rickyfm Why does the react compiler care if i use ref during render? I understand it's not reactive but why skip compilation in this case? I believe i found a bug where the compiler thinks i'm doing this illegal thing but i'm not and as a result the component is de-optimized

@tan_stack This is "kicking myself we didn't build it" level good

🚀 TanStack DB 0.5 is here with Query-Driven Sync Your component's query IS the API call. No custom endpoints. No GraphQL resolvers. Just write your query and DB figures out exactly what to fetch. Details 🧵👇

@Shanshrew @rauchg All good, glad you got it sorted, and thanks for the follow-up!

Literally can't replicate it; In fact seeing the opposite now where it's the same or faster. Feel like I'm in that Blackmirror episode. My deepest apologies @en_JS; Until I can replicate will delete original post Maybe my computer decided to run something heavy right as I swapped from false -> true.

@Shanshrew @rauchg Our recommendation is to default enable, opt-out where necessary. I'd love to learn more about your specific use-case and understand why you saw such a large regression on startup since that is inconsistent with what we've seen generally. Any way to distill down to a repro?

@Shanshrew @rauchg > I have a yet unproven theory that only applications that abuse useMemo / useCallback / memo will benefit from react-compiler We have lots of data that confirms this is not the case. Exceedingly well memoized apps may see less benefit, most apps see an improvement.

@Shanshrew @rauchg A couple things here. First, JavaScript generally allocates objects on the heap - the examples you gave don't use stack allocation. Second, most of the data is still going to be referenced anyway - at minimum the content of the element, etc.

I honestly find this suprising. If you just navigate here which is the react compiler playground playground.react.dev You look at the "return " example; That div now ends up being stored on the heap via $[0], where-as before it was stored in stack memory. The other reason I find it surprising; Is that conceptually there is NO memoization without heap memory. If we retain a reference to something outside of render, it's on the heap. So therefore how can react-compiler possibly be neutral on memory if it's memorizing everything.

@Shanshrew @rauchg We've tested on different products with varied amounts of memoization: overall found neutral memory impact. If you have extreme cases of no memoization you might see a slight increase, but there would also be more of a chance it significantly improves update perf

@en_JS Thanks for getting back to me would love to pick your brain a bit Memory - Are you testing this in applications predominantly where they have a convention to useMemo / useCallback everything? or are you also testing on applications that sparsely (and I would argue correctly) use useMemo / useCallback / memo [if not not at all]

@Shanshrew @rauchg Obv if the compiler made your specific app slower, then maybe don't use it! But overall the points you raised don't align with what we've seen for most apps. We're curious to hear from more folks though, we definitely want to make the compiler work for as many cases as we can :-)

@Shanshrew @rauchg For #4: Separate builds for SSR actually make a lot of sense, since there's a lot of code that is only executed on the client such as effects. A SSR specific build could eliminate dependencies only used by effects, event handlers, etc. This is on our backlog.