I don't agree here. Yes Claude is great at following patterns, and for very standard tasks (e.g. "add this HTTP handler" which can copy existing patterns for database transaction management, session management, authentication, etc etc) it does great! The problem is that when you do something that doesn't quite fit int an existing pattern, Claude will optimize for solving the task at hand, producing code that doesn't use a sensible architecture. Doing things like checking user credentials or establishing a database connection deep in domain logic.

If you're a good dev, you can totally prompt Claude to not do this and correct itself, that's not an issue. The issue is that bad devs won't even notice this is happening in the first place.

Strong disagree. A lot of AI development still requires good engineers to keep tight leash on it so I'm seeing more bad developers create a feature until we need to iterate on said feature and we find AI did such a bad job that it becomes extremely difficult to do so.

AI is very good at making the bad dev's PR look plausible and be green in CI. And thus, merged.

It can but you need to be careful.

At my org we use Github Copilot as our AI tool for devs, both internally and for vendors (Including a WITCH =/).

Where it gets ugly, is that we have a -lot- of WITCH provided code already in our systems, and as a result GHCP winds up often preferring the existing (terrible) patterns.

I've done some things to help mitigate at least; Adding instruction/skill/agent files, tossing in some LLM-built .NET analyzers to catch the worst anti-patterns to warn on build and error on CI, and making sure to call out when the vendor people are obviously not even reviewing what the LLM generated for them [0]

[0] - Simplest case being, EF Core mappings where the datatypes do not even exist in the target DB...

A bad developer with any current frontier model will happily produce syntactically correct code that is unreadable, in a spaghetti architecture, and write an elaborate test suite that tests all of the wrong things.

> AI tends to write less sloppy code than bad devs, and test/validate it more rigorously

I've often had it test and benchmark against the wrong things = no test.

It also writes over-engineered code. So yes sort, maybe.

Jury is still out here

Less sloppy in that it's clean and consistent looking but much more sloppy in the AI good looking non-sense way.

Just like compiler-generated machine code, then.

no, not like that at all.

If those bad engineers are in a very well defined box. Give bad engineers greenfield and watch it implode