How Effectively Agents Write D

[strawberry9]

On Friday, 6 November 2026 at 15:23:33 UTC, Peter Alexander wrote:
> Hey folks, long-time D user here and active contributor many 
> years ago. I recently quit full-time employment to pursue some 
> personal projects and expect to be doing a bunch of D-related 
> work as well on the side in addition to using it for my main 
> projects.
>
> I've long felt that D could be a good language for LLM coding 
> due to its fast compilation times, good runtime performance, 
> safety, and expressive language features. Fast builds in 
> particular feel more important when writing code is no longer 
> the bottleneck.
>
> This is just a feeling though, and I'm keen to start measuring 
> it and sharing what I find with the community.
>
> I've published an initial attempt to get data around agentic 
> effectiveness with D at 
> https://pja.name/2026/11/06/how-effectively-agents-write-d.html. Certainly not a perfect study by any means, but could serve as an initial starting point to iterate on the "agentic experience" of D.
>
> The main takeaway from this study is that there are quite a lot 
> of tooling-based improvements and changes to defaults that 
> could significantly improve how agents use D. There are also 
> some potential language changes, but I assume those are likely 
> more difficult to make.
>
> Keen to hear any and all feedback. Also interesting in what 
> other ideas people have for how to measure D for agents.

What is relevant here (for humans and LLM's alike), is the amount 
of useful, correct, maintainable functionality that can be 
produced relative to the effort required.

A genuinely good language makes simple problems simple, complex 
problems manageable, and dangerous mistakes difficult to make.

C and Rust illustrate this difference in how much responsibility 
each language places on the programmer versus how much it 
attempts to manage through language mechanisms. This was one of 
the primary motivations for me creating CobaltC - 
https://github.com/strawberry9/CobaltC

My 15 years experience with D's complexity was another motivating 
reason ;-)

Interestingly I've discovered that LLM's have very little 
difficulty, almost none actually, in writing complex programs in 
CobaltC, without any initial knowledge of it, other than what 
they can learn from the repository itself.

So the question for D in this new age of AI, is: does D make 
simple problems simple, complex problems manageable, and 
dangerous mistakes difficult to make?