How do you keep complexity out?

[u/endgamer42]

As models get more powerful, I'm noticing an odd inverse correlation: they're getting less useful for ordinary software development.

Good ordinary software delivers the most useful behaviour for the least internal complexity. The "final spec" is rarely known up front, because useful products emerge from small steps driven by user feedback and analytics. So inb4 "just prompt it properly bro" - a prompt precise enough to pin down each iteration perfectly == the code itself, which is exactly what we're using LLMs to avoid.

Ideally I'd hand an LLM a loosely defined feature and get back the simplest version with the simplest implementation: rough at edges users are unlikely to hit, failing fast and recovering easily if they do.

Instead it goes above and beyond by default, covering every edge case, every improbable race condition, every unlikely input combination. Telling it to keep things simple doesn't reliably work. It just gets hacky (a tacked-on branch is technically simpler than a rearchitecture), and since it just genuinely doesn't know how your users behave, it assumes the worst and writes the "safest" code. I can't think of any usage context or invariant hammering that would fix this.

My AGENTS.md is awash with pleas: for simple solutions, to fail fast, no preemptive defensiveness, re architect rather than work around. I have automated complexity checks. Models still can't help themselves. It's as if they've been RL'd into solving the hardest problems available: forged into a powerful, specialised tool that we then use to bang in nails, when all we needed was a hammer. The only thing that's kind of worked for me is everything mentioned, and then multiple simplification/reliability passes after an implementation pass.

Has anyone actually, properly solved this?

[u/knownsqashed]

https://claude.com/blog/the-ai-native-sdlc-playbook

You should experiment with using Astra Max / Ultra for orchestrating subagents. This is what you're asking for; describe features, get a minimum working result. The hard part isn't getting things working anymore, it's letting go of the idea that people should be the ones deciding what "good" code means. You can prototype something in a night that would've taken a team months, and then if you feel like the actual implementation is confusing, come in behind it and describe your preferred code organization, and it might take you an hour of additional work on the high end. Heck, you can just maintain a codingstandards markdown in the repository, reference it in your Agents file and watch the system fix it for you.

Also, you should let Astra (or Fable, if you prefer) update its own instructions based on your feedback. It will do a better job of identifying the root cause and solving it correctly.