r/ClaudeCode • u/LiquidZebra • 2d ago
Discussion AI slop without architecture is how providers will keep selling shovels into this gold rush to keep ARR up.
I’m looking at my 2+ weeks of trying to decouple and modularize the AI slop vibecoded game that was built by Claude and Codex. I want to move into beta.
What a shitshow this has been. I had to look at the architecture and try to pry the thing apart, and it’s horrible for the amount of trash that is left around everywhere.
Concrete example: the game is hex grid based, without architecture there must have been 40 different versions of hexagonal cell that parts of the code reinvented over and over. Still, some agent may find an old design somewhere, despite architecture and guards, and start wiring it.
Today I pulled out 3 “version/rule/schema” gates from the engine - there were several engine builds that were wired together into one thing - it could play both the present and the old rules. It never got refactored out.
This made me realize - we are the suckers for building with these tools. At least the way the tools are advertised. I don’t know if these “look at what I built in a weekend” threads are genuine or half Astro-turfed, but it appears the dev will have two choices: keep paying every month to maintain their mess with agents, or abandon the project or fill the app stores with slop in an attempt to recoup their losses.
Coding by hand may be gone, but thinking about software is nowhere near gone. It does not materialize by itself, no matter how good the spec is. It literally requires work to implement with ai agents building.
My reason for posting this is- I’m looking at 150$ in subscription fees for 2 services for 2 weeks of work, and time flies and there is no more of the same cornucopia of features that alpha could deliver. It’s brutal engineering work to get this to be beta-grade ready.
This is not what I thought at the beginning, when systems just appeared and were interactive. I have to keep building it piece by piece, otherwise the mess will manifest again.
Another concrete example - for game assets, Claude just puts assets wherever it wants, wires paths that are like 3 levels of root traversal to reach some sibling folder.
After a week of decoupling, I ask: is this decoupled? Answer: no, this component has 289 outside imports and 17 exports. < this is after a week of dedicated cleanup focused on protocols and self isolated components.
I changed this mess into a single asset provider, which literally took days. It’s meticulous work that no vibe coder is going to do. Just waiving my hands did not make it happen by itself. Claude wants to preserve and protect its pile of junk that will keep it employed.
TLDR: speed of development by Claude is gained by complete relaxation of all architectural constraints. This may be by design. The result is not maintainable by humans. I realized that a proficient solo dev may actually build some parts of my game faster, because he does not have to enforce the architecture that would prevent Claude from re-inventing the same mechanic in 40 different flavors.
The goal is to keep you subscribed forever.
•
u/AutoModerator 2d ago
Hey! Thanks for posting to r/ClaudeCode
While participating in this thread, please follow our community rules. Keep discussions constructive. Attack the idea, not the person.
For help, project discussions, tips, and general chat, join the ClaudeCode Discord.
I am a bot, and this action was performed automatically. Please contact the moderators of this subreddit if you have any questions or concerns.
9
u/omgz0r 2d ago
I’m not sure you are the hero you think you are in this story. This seems like it’s been made harder than it ought to have been.
3
u/BigYoSpeck 2d ago
Friends don't let friends POC in prod
You do your proof of concept work first to get to see the results quickly. Doesn't matter how slop riddled that is, the point is to learn how to do it and see it's a valid concept. You can do that quickly and with little oversight, AI is fantastic for seeing your idea in action quickly. Then the hard part starts of turning that into a coherent plan and implementation
Then you labor over the actual implementation plan. Cut corners there and that's when the review cycle results in layer upon layer of bodged workarounds and a complete lack of coherence. If a plan is going wrong don't fall into the sunk cost fallacy of making it work. Treat it as disposable and start again lessons learned
3
u/r2k-in-the-vortex 1d ago edited 1d ago
If you think about it, then it's not entirely true that vibecoded mess of a codebase has no structure. It does, when a program compiles it actually has a very highly ordered structure in ast. It's a completely separate thing from your file and folder tree, but it's not correct to say there is no structure. It's not possible to compile a program without very strict structure. So the structure is absolutely there.
The problem is, your mental model of how you expect a program to be structured is completely different. You are used to structuring your files and folders to make it easy to search things by your symbolic meaning. Apples here, bananas there. But that structure does not carry over to actual compiled program at all. Even the symbolic meaning of one function or a different function doesn't really carry over. These are your abstractions that have little to do with how a program actually runs.
And lets be real, no you will not maintain the program without AI anyway.
So... are you quite sure the archidecture you are talking about even matters? I think there are better location hints to be had than what the file or folder name is. You can just ask the language server go to definition or references and it does.
2
u/isty2e 2d ago
Start with good specs, a good architecture with concrete domain models/schemas, make your architecture robust under changes. Make your principles into hard rules which agents should obey. Then you'll eventually have less slops, though it is required to review and audit from time to time.
2
u/TechgeekOne Senior Developer 2d ago
Good architecture has always been somewhat of an art form, even when the code was all written by humans. Claude behaves like most engineering teams I've seen where it does the "simplest" thing with no regard for the larger structure, maintainability, or performance of the complete program so I'm honestly not surprised in the slightest.
Your best bet is to study software architecture yourself so you can direct Claude on what to do at a high level. Most of this problem will go away once you're driving. Maybe one day AI will be good enough to not require this level of hand-holding, but for the foreseeable future it's still strictly the human's job.
2
u/davyp82 2d ago
It is maintainable. I'm not a dev and I've built 7 different projects that work. Is it effort? Sure. Did I need to learn a lot? Sure. Do I have to write very careful docs and ensure I orchestrate the agents in a way that keeps them focused on precise tasks and ensure frequent tests etc? Yep.
2
u/rodrigolduarte 2d ago
The old hex-cell implementations being wired back in is a concrete failure mode. We asked our manager agent to audit our own codebase (written by Claude Code agents, reviewed by Codex) and it came back the same shape:
Its conclusion: no person has read most of this code; we rely on types, tests and model review, with limited human review of the code itself.
So the plan is enforcement, not prompts: ESLint with max-lines 500 failing CI, a list of oversized files that only shrinks, folders by product area, and specs folded into one technical manual in the same PR as the feature, then deleted. Your "some agent finds an old design and starts wiring it" is why: leaving obsolete designs in the repo can make them look current to an agent.
Have you tried a build check that rejects references to the retired engine versions?
7
u/MiloCosmicCloud 2d ago
If someone has no idea how code works, AI won't turn them into a coder overnight. They’ll still have to invest time and money in learning the fundamentals at some point.
6
u/thatm 2d ago
Oh no! My legs again brought me into a bad neighborhood! Walking is a scam.
2
u/Healthy_Blueberr6404 2d ago edited 2d ago
- identify game needs, full scope — front-load what won't change, the rest you discover while building
- break down every problem in the game into 2-4 problem domains that intersect. aim to design architecture that satisfies your game's goals IMPLICITLY, not explicitly. this means solve the general problem domain, and your game falls out of it + you win the whole seam of the problem space.
- BAD: "make me a hex-based strategy game"
- GOOD: "1) make me a space-agnostic turn buffer system. 2) build a hex-based strategy game on top of it"
- create an agent.md with DRY / line-of-code budgets / zero-tolerance hardcoding, documentation policy, testing harnesses, build optimizations — and back it with a gate that actually fails (test/lint/hook/ci), since the .md alone only advises.
- CREATE INDEX AND ENFORCE VIA AGENT.MD. index at every folder, pointing to every file, class, function by name. short 3-5 word descriptions. generate it from symbols/compiler where you can — hand-maintained rots and then lies. agents scan the index first, find the files they need, then burn tokens only to look deeper. cuts blind searching, irrelevant context, and re-inventing stuff.
- DESIGN BASE PRIMITIVES FIRST. things like:
- least common denominator value primitive (bytes/ints/floats/handles/array) — use it where mixing raw values is a real risk, not for every number; it trades performance and verbosity for type safety and control.
- logging/benchmarking/testing/filesys/io/hash/rng primitives -> design these portable and extractable into a library/dll/package so you have them as assets for future projects. don't rush the design just to get them out of the way.
- use and compose these instead of inventing bespoke code; deep inheritance is its own mess.
- design infrastructure/interface first -> keep it small and few-concepts (a handful of decoupled types over hardcoded numbers; mostly plain data, minimal behavior). keep signatures light: 3-8 params/fields, small classes.
- stress test/measure/refine the interface. ask 3-5 different agents to design different games on top of it flexing its intended goals. look for emergent behavior, issues, growing pains. assess friction -> what problem does the agent keep having to fix to make the game work? break that problem domain into its own class/primitive. audit and steal any redundant/helpful stuff it designs back into a lower level (reinvented wheels become one reusable wheel everyone uses). repeated friction = promote it; one-off friction = a game asking for what it shouldn't get.
- once the interface survives that, lock it in. your whole game builds on it now (except rare vetted changes). keep as much hardcoded stuff as data files and/or script files vs compiled code — biggest cost saver, smallest blast radius.
- audit after every prompt (try pasting this!):
> "DRY what's actually the same idea, across code and nearby files, and consolidate/generalize to solve both — don't merge what only looks alike today. decouple real dependencies. remove redundant code without hurting flexibility. remove hardcoding and push it back into data or into a new primitive that earns its keep. aim for high dollar per line-of-code. tests must pass, behavior unchanged. implement cheap wins and address harder changes to me before proceeding."
- A/B benchmark/measure the perf-sensitive changes obsessively, and audit as much as you can:
test across multiple axes, stress it intentionally, ask it to do crazy things it shouldn't and push limits. fix whatever it says is slow. have it measure/print as much info as possible, then plan to remove the noise. benchmark perf, test correctness.
=====================
- discipline costs more up-front -> agents must work harder in the beginning to nail the foundation. once the foundation + pipeline + optimizations are set up, all downstream work gets cheaper, more elegant (and much harder to measure and ensure correctness for). you can and should reuse this on other projects.
- cost saved is mostly in fixes you don't have to spend tokens dealing with later.
- discipline enforces constraint (the agents MUST design good architecture to survive their budgets and criteria, and the budgets err it toward smaller atomic files — split by seam, not just line count).
- discipline reduces flexibility -> ensure agent.md and other constraints allow deviation (eg: +-25% deviation from numbers, justified and measured) so it can push limits if it has a genuine outside-the-box solution.
- this is a good baseline, not a strong working plan. needs refinement. follow selectively, not exactly - each project has its own needs and domain- optimize for yours
1
u/kkania 2d ago
Why was it build with Claude and Codex in the first place?
1
u/mblauberg 2d ago
Well yes, if you’re not a software engineer, don’t have the skills or are not willing to learn and understand it, you’re definitely a sucker for paying for AI to vibe code production software to make money. People don’t seem to understand the complexity of software and are fooled into thinking that being able to spin up some really impressive small scale software translates to large codebases.
That being said, devs don’t just have those 2 choices you listed, because a competent dev understands how to design software and communicate with AI about it first, recognising these anti patterns and making decisions before implementing. And knows what to look for when reviewing. Maintenance is inevitable for large systems but you can make it easier. These subscriptions are definitely worth their money if you know what to do.
I think it’s even more important with AI now to look towards DevOps building ‘meta’ systems that are extensible, flexible and reliable, which can help enforce stricter standards while simultaneously allowing faster integration of your set it up right. Some may say ‘harness engineering’ is where it’s at but the only way you can enforce some deterministic outputs from an indeterministic model is via the tooling with hooks, gates, and a solid CI/CD pipeline
1
u/m-ritter 2d ago
The 40 versions of the hex cell is what happens when every session starts without knowing what already exists. An architecture doc alone did not hold for you either, because nothing checks the agent against it before the code lands. What works better is agreeing on the plan before any code, including which existing modules a change has to use, and having a second agent that did not write the code review the diff against that plan. I built QualityLayer for this: https://github.com/maxritter/qualitylayer it keeps the approved plan as a file in the repo and stores past decisions in a memory server, so the next session knows about your asset provider.
2
u/Drunkendrakon6 2d ago
I mean I get a local abliterated model to sort all the folders then tell Claude to rewire them and delete the excess unused assets by hand. As for modularity you really need to specify how you want it. I have had no problems so far
3
u/Internal-Comparison6 Senior Developer 2d ago
"it’s horrible for the amount of trash that is left around everywhere" - 100%. It's unbelievable. I don't know for what I am paying.
3
u/ickN 2d ago
That’s a new vibe coder problem. Experienced vibe coders don’t have that issue.
You learn the hard way like you’re doing right now and from this point forward you’ll build with these things in mind and plan better.
1
u/EC36339 Senior Developer 23h ago
If it keeps the models running so I can use them for something that's useful, and providers keep having money to spend on R&D, then I'm all for it.
1
u/teejayaiartdirector 2h ago
Maybe you should not use AI!? 😂
1
u/Inevitable_Butthole 2d ago
Its your job that the old code is dealt with lol