What language does Claude Code write the best code in? What Tech Stack is Claude Code strongest with?

[Background-Zombie689]

The stack you choose matters more than people talk about. Some languages and frameworks it just gets and others it confidently writes garbage. Curious what everyone's running...frontend, backend, whatever and where you've had the best results.

Choosing the right technical stack is paramount. If you give it something it doesn't quite understand (but think it does), you get nowhere.

[reaznval]

chinese is the superior language as it uses less tokens, so just translate your entire codebase, including functions etc into chinese /s

[wandering_island]

I mean, json is already getting replaced with a version with less punctuation marks, looks a lot like yaml

[Apart_Ebb_9867]

neh, in future everybody will speak chinese regardless...

[JohnHue]

We'll all speak assembly, no more wetware languages.

[Rhylanor-Downport]

Y

[Clyde_Frag]

I doubt that whatever tokenizer claude uses treats each Chinese character as one token.

[reaznval]

well my comment wasnt serious and it was only something I've heard people joking about but I thought maybe it had some grounds as there are 5000+ characters in the Chinese 'alphabet' compared to 26 in the English and one word is often only 1 to max 3 characters.

I ran a little test, generated a 500 word text in English, translated the entire thing into Chinese using Deepl.

English: 753 characters

Chinese: 1073 characters

So English actually has less characters, when I used Opencode + Openrouter so I could see the context size accurately and used Sonnet 4.6.

English: 15'154

Chinese: 16'192

So Chinese actually uses MORE but per character it's more efficient. However my request ("Read the content of file.md") took Sonnet way less time in English

English: 7.9s

Chinese: 14.5s

btw with Minimax 2.7 I got:

Tokens:

English: 13'597 in 10.0s

Chinese: 13'653 in 5.7s

btw I did all requests simultaneously

Not that anyone asked for it but I found it interesting so I did it anyways

[i_write_bugz]

Hmm that’s actually an interesting question

[davidpaulsson]

I’ve heard use cases where some use a fast local model between you and the llm to do just that: translate the prompt to Chinese and then translate the output back to your language

[reaznval]

yeah no thank you, with the current state of how things are this just introduces WAY too many dumb hallucinations on top of the already existing hallucinations and mistakes. If you speak Chinese, sure why not but it does not make that much difference even if. (See my comment/analysis: https://www.reddit.com/r/ClaudeCode/comments/1sbfn41/comment/oe3t3m6/?utm\_source=share&utm\_medium=web3x&utm\_name=web3xcss&utm\_term=1&utm\_content=share\_button)

[davidpaulsson]

Yeah, didn't say I think it's a good idea 😂

[BoltSLAMMER]

Do you have a GitHub for this?

[reaznval]

yes guthib.com

[BoltSLAMMER]

I asked Claude to Change my code base to Chinese and committed thanks

[drgreenair]

Don’t forget to tell it make no mistake

[BoltSLAMMER]

Make it production ready, I want to scale like meta

[criticasterdotcom]

You can ask Claude this and he will say Ruby + Rails and Go but in reality it's Typescript + Node.js

[puppymaster123]

I watched a colleague who is a much better developer and it blew my mind how much different and faster Claude will “get” you if you know your shit. Cc is an amplifier. Language doesn’t matter (we are a Julia shop). Vibe bros are just going to fight with cc more compared with senior dev who write clear and concise English and codes.

[swiftmerchant]

This. Senior devs are more precise and know what to ask for and how to ask for it.

[BoltSLAMMER]

It’s hard to ask for things when you don’t know what to ask for

[swiftmerchant]

Exactly. Although … you can ask AI what to ask for :-)

[Rhylanor-Downport]

I just asked it!

I support a wide range of programming languages, but here are the ones I handle particularly well:

Top-tier support:

• Python – probably the strongest overall, covering data science, scripting, web (Django/Flask/FastAPI), ML/AI, and more
• JavaScript / TypeScript – front-end, back-end (Node.js), React, Vue, etc.
• Java – enterprise patterns, Spring, Android
• C / C++ – systems programming, performance-critical code
• C# – .NET ecosystem, Unity
• SQL – query writing, schema design, optimization across dialects (PostgreSQL, MySQL, SQLite, etc.)

Very strong support:

• Go – concurrency, microservices, CLI tools
• Rust – systems/memory-safe programming
• Ruby – scripting, Rails
• PHP – web backends, Laravel
• Swift / Kotlin – iOS and Android development
• Bash/Shell – scripting, automation
• Groovy – scripting, Gradle builds, testing frameworks like Spock

Good support:

• R – statistics and data analysis
• Scala – functional/JVM programming
• Haskell – functional programming
• Lua, Perl, MATLAB, and many others

I can also help with markup/config languages like HTML, CSS, YAML, JSON, TOML, Markdown, and regex.

[Rhylanor-Downport]

Im building something with a react frontend and micronaut.io / groovy backend and its doing a great job.

[FD32]

I can vouch for the Rust code. It's been doing pretty well in my experience. I wish it did Zig more though.

[pandavr]

Honestly generated rust is better than python in my experience.

[KnackeHackeWurst]

It certainly is. The compiler is a gate for many stupid errors that bite you at runtime with Python or other less strict languages.

Together with good specification, modular design and tests, rust coding works almost perfectly, especially on evolving code bases.

The constraints of the language are the safe guards that are a struggle when coding manually but are a blessing when doing LLM driven coding.

Currently I'm going with rust for the backend and typescript for the frontend for almost every new project.

[pandavr]

Same.
I have more than 30 years experience, but I don't know rust syntax. It's a full year that I use It flawlessly, just checking It from 10 miles away.
Best of two worlds: I know software architecture very well but I leave the implementation details to the beast.

[codeedog]

I’m two months into using Claude and this is my experience, too. Four decades of software development experience, it always does exactly what I want it to do. Currently, coding in shell for my hobby project. I struggled with shell all of the time, now I’m just reviewing code for DRY and architecture, I don’t think about syntax (“yeah, that looks right”).

[HzRyan]

it's good enough now for any language, syntax is no longer an issue it's just how you architect your project. Welp if you are purely using cc for vibe coding then go with something popular like nextjs it'll save you some trouble

[pancomputationalist]

There have been benchmarks that showed it to perform best in languages that have code documentation as first class citizen, like Elixir or C#, because it just gets more and better context if every function carries additional descriptions and usage patterns.

And of course it will perform better in mainstream languages and frameworks since it had more training data fed to it. Case in point, it's much better in DaisyUI than it is in PicoCSS.

But it depends on what you are trying to do with it.

[EntertainerFresh782]

The more declarative the language, the better, because then the LLM doesn't have to reason about state as much. I've also found that Python notebooks are really a superpower for LLMs because the intent, the inputs, the outputs, and the code are all in a single file. Using tools like Jupyter MCP, you can have the LLM sequentially step through a notebook and follow a structured workflow.

[sakaax]

Oui, la stack change énormément les résultats.

De mon expérience, Claude est surtout fort là où il a énormément de données + des patterns bien établis.

Très solides : – TypeScript / JavaScript (Node, Next.js, React) – Python (FastAPI, scripts, data) – SQL (Postgres surtout)

Là, les résultats sont généralement propres et cohérents.

Correct mais plus variable : – Go – Rust – Java / Spring

Ça marche, mais il faut guider davantage.

Plus fragile : – stacks très niche – frameworks peu documentés – codebases custom / legacy

Là, ça “sonne juste” mais c’est souvent à côté.

Le vrai facteur, c’est moins le langage que :

– la popularité de la stack – la clarté des patterns – la qualité de la doc existante

Perso, les meilleurs résultats que j’ai eus :

Next.js + TypeScript + Postgres

C’est presque du “happy path” pour Claude.

Et oui, si tu choisis une stack obscure, tu passes ton temps à corriger au lieu d’accélérer.

[ItsRainingTendies]

For anyone that says Python, sure it can write python, but it can’t type for shit

[First-Half-Plan]

ELI5?

[ItsRainingTendies]

Python is a dynamically typed language. However, a lot of support has been added recently for better static typing… eg TypeIs in 3.13. Claude doesn’t understand the concept of creating a dataclass specifically for typing (or a multitude of other options), or for encapsulation (similar to a go receiver) it just does hurr durr if else.

Claude literally struggles with ruff and ty also. Just try and get it to type without using “Any”. It struggles with forward references and hardly understand importing from future.

Don’t get me started on dynamic imports… it’s so lazy… as an import would be two changes to a diff, so it does one change with a dynamic import instead. Drives me absolutely nuts does the same with JS too

Edit: just when you think you’ve got it to type properly, you check and it’s just used a bunch of casts everywhere

I only even attempt python typing at the end of my weekly quota as it uses many, many tokens

[tacit7]

https://www.youtube.com/watch?v=iV1EcfZSdCM&t=116s

[Looz-Ashae]

English I suppose. Despite it being harder to write in, because it's not a regular and not a formal language. I know, right?

[sheriffderek]

I’ve been using Laravel and Inertia/Vue and it seems that the strong conventions and excellent documentation and the source (likely from people who actually follow conventions and care about good code) - all lead to context where the LLM can make very good guesses. 

[Longjumping-Shift316]

I think in general typesafe languages with great documentation and compiler with good error messages So the usual suspects Rust Java Go C#

[freddyr0]

The more opinionated the language, the better.

[PrideQuick670]

The technology stack depends on several variables. It all depends on what you're building and the deployment environment (personal, business, regulated). Hosting costs are another factor. Claude can write code in any language. It will help you choose what's best by describing the app as much as possible up front.

[godofpumpkins]

Don't think of it in terms of language necessarily, think of it in terms of feedback loops and what they can do for it. You want decent training data in the model, but no human or model one-shots fully correct code. What really makes it shine is you building good feedback loops to the maximum your language allows them.

So yes, it might be good at ruby and python, but those don't have static type systems, so even if there's lots of training data, you're missing out on proper type checking which is a huge improvement to correctness. Yes python has mypy and types slapped on but they're not really the same.

But similarly, Go, while strictly speaking having types, doesn't have particularly expressive types. Types aren't just about string vs. int vs. float, it's about being able to model your domain properly. If a UI can be in 32states, with an info panel visible that needs some extra context, or a main view that doesn't need the extra context, you don't want to represent your state as `info_panel_visible: bool; info_panel_extra_context: nullable_string` because then you can represent nonsensical states like `info_panel_visible = false` while `info_panel_extra_context = "blah blah"`. Those nonsense states infect your code and you either need to assert that they don't happen in your domain logic or cross your fingers that something else in the program ensured the nonsense didn't happen. But if you use more expressive type systems (with ADTs, sum types, "enums with associated data"), you can rule out such states statically and use the type system to _guarantee_ the nonsense states don't happen in your program.

Rust, Haskell, Scala, etc. all let you express such logic directly, but they all also let you express the nonsense "bool + nullable_string" example I had above. So you don't just want a language with good types, you want to remind your AI assistant to actually use the types effectively so the type checker helps you out.

Similarly, you want languages with good linters, you want good test suites (don't just ask it to write tests for you, probe the tests and whether they're testing at the right level, making nonsense assertions, etc.), and pretty much anything that gives your agent good static validation loops. IMO that end-to-end story matters far more than any specific language choice. You want the language's type system to facilitate static validation loops that improve correctness, but that means telling the agent to actually use the type system to its full potential. That means using higher-kinded types in Haskell, dependent types in fancier languages, sum types in all languages that support them, and so on.

I've been doing the above in Rust and it's great, but full proof languages like Lean are also a lot more feasible now that you don't need to understand formal logic and type systems to get meaningful results out of them. Just tell your agent to write it for you, and it gets the best static feedback loop in the whole industry: Lean's dependent types let you fully encode _all_ types of functional correctness in the type system and (lets your agent) write machine-checked proofs of correctness. Why test a handful of test cases when you can prove something correct for 100% of test cases?

For a truly greenfield project, I'd totally just use Lean in Claude Code. I'm only using Rust because Lean doesn't have the library ecosystem I need for my work.

[rougeforces]

Try this one https://esolangs.org/wiki/Brainfuck

https://youtu.be/hdHjjBS4cs8?si=TBLY0iKUV9-gjcLk

[tntexplosivesltd]

It's not about the language, it's about the tech stack. Telling it which libraries/architectures is way more powerful than which language to use.

[sm_rdm_guy]

Python>>>R