I am not kidding. I have never seen any LLM generated code I would copy into any of my long term projects. And I use AI daily for my job. 
So I challenge all of you prompt engineer vibe coders to convince me otherwise.
Leave a comment containing your AI model of choice, used prompt and the output to an example task (preferably in C#). possible task: <a href="https://kata-log.rocks/banking-kata" target="_blank" rel="noopener nofollow">https://kata-log.rocks/banking-kata</a> 
I will judge harshly.
What I consider good 
(of course that is a highly biased question)
<ul>
<li>good balance between readability, maintainability, reusability, simplicity and performance</li>
<li>prefer immutable design</li>
<li>declarative code</li>
</ul>
tip: I have not yet tested Gemini 3

Barion

A developer challenges the community to prove that LLM-generated code can meet professional standards for production use. They're specifically looking for examples that demonstrate good balance between readability, maintainability, reusability, simplicity, and performance, with preference for immutable and declarative design patterns. The author uses AI daily but claims to have never encountered AI-generated code worthy of inclusion in long-term projects.

I have never seen good AI code (challenge)

I mainly work with C#, Java, TypeScript, and sometimes Python and Rust. AI can produce good code—but only when the problem is clearly defined. Your excample is clear. In real projects you often only know the goal and have to feel your way toward a solution. That’s where AI often fails, and it can even break working code while trying to fix something else.
I’ve also seen AI “cheat” when it can’t solve a problem. For example, a parser test turned green because the AI rewrote the code so that the parser no longer parsed anything—it just returned the expected value.
My conclusion: I use AI-generated code, but very carefully. If you don’t truly understand the code it produces, you’ll run into problems in the long run.

I gave <a href="https://kata-log.rocks/banking-kata" target="_blank" rel="noopener nofollow">https://kata-log.rocks/banking-kata</a> to ChatGPT 5.1 Thinking with no special prompt: This was the first attempt (comments by me)
<pre><code class="language-csharp">using System;
using System.Collections.Generic;
using System.Text;

// should be sealed
public class Account
{
 // should be a sealed record (with ID if required)
 // maybe even a struct
 // A Transaction is a concept beyond just the Account it should be public and live outside of Account
 private class Transaction
 {
 public DateTime Date { get; }
 public int Amount { get; } // int is a poor choice for money, think of all the fractions vanishing
 public int BalanceAfter { get; } // fine for this scenario but might cause problems as the system grows

 public Transaction(DateTime date, int amount, int balanceAfter)
 {
 Date = date;
 Amount = amount;
 BalanceAfter = balanceAfter;
 }
 }

 private readonly List&lt;Transaction&gt; _transactions = new List&lt;Transaction&gt;();
 private int _balance;

 // Deposit and Draw are expected to fail
 // they should be Try... and return whether the call was a success or failure
 // both methods are almost the same, there should be one method to handle the transaction
 // Deposit and Draw can still exist for convenience but should call into that method
 // this is not about DRY but about surface area for bugs which is crucial in critical software like banking
 public void Deposit(int amount)
 {
 if (amount &lt;= 0)
 throw new ArgumentException(&quot;Amount must be positive.&quot;, nameof(amount));

 _balance += amount;
 _transactions.Add(new Transaction(DateTime.Now, amount, _balance));
 }

 public void Withdraw(int amount)
 {
 if (amount &lt;= 0)
 throw new ArgumentException(&quot;Amount must be positive.&quot;, nameof(amount));

 if (amount &gt; _balance)
 throw new InvalidOperationException(&quot;Insufficient funds.&quot;);

 _balance -= amount;
 _transactions.Add(new Transaction(DateTime.Now, -amount, _balance));
 }

 public string PrintStatement()
 {
 var sb = new StringBuilder();
 sb.AppendLine(&quot;Date Amount Balance&quot;); // rigid formatting

 foreach (var t in _transactions)
 {
 string date = t.Date.ToString(&quot;dd.MM.yyyy&quot;);
 string amount = t.Amount &gt;= 0
 ? &quot;+&quot; + t.Amount.ToString()
 : t.Amount.ToString();
 // why concatenate manually? you have a string builder?

 sb.AppendLine($&quot;{date,-12}{amount,7}{t.BalanceAfter,9}&quot;); // rigid formatting
 }

 return sb.ToString();
 }
}

</code></pre>

Could you list which ones you did use?
I can’t complain about Junie, I really can’t. But of course it’s never perfect in the sense how I would write it, or along certain details AI couldn’t infer from my prompts.
Context also matters a lot. Ask an AI to write a very common pattern (ie Statemachine) it will get it right. Ask her to write a game engine 3rd person character controller and it’ll throw in all sorts of crud because it learns from the same massive amounts of oversimplified, highly fragmented, legacy-favoring beginner-level tutorials.

This may have a lot to do with your .NET ecosystem-of-choice here. LLM’s aren’t as optimized for C#, etc. they are for Python, Javascript, Typescript, etc. I work almost exclusively in Python and my results have been outstanding.

AI is a technical debt generator.
I have only copy pasted stuff from it, when the code is isolated and regards something irrelevant to the system’s overall functionality.
Think “Feedback Forms”, “Contact Us!”, stuff like that.