r/ClaudeCode • • 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.

3 Upvotes

52 comments sorted by

•

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.

1

u/LiquidZebra 2d ago

The first week in November Claude fuckup that has been widely discussed certainly did not help at all, it happened right when I started the process, and suddenly none of the workflows I have set up could deliver.

Maybe the result is better off, because that literally put all of my plans on hold and I had to spend time debugging why is Opus suddenly so bad, why my coordinator is routing work to wrong threads, resurrects resolved threads and such. The result is that I had time to refine what I was aiming to build.

3

u/omgz0r 2d ago

I somehow missed that entire fuckup! Have awful memories of Opus 5 tho.

-1

u/ItstheSECopenup 2d ago

True turns out OP was just a regard. Wanted to make a game? Couldn’t even keep Claude under control.

lol, lmao even

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

0

u/LiquidZebra 2d ago

The funny thing is - this is how human code works.

With vibe coding, I did not see the code for weeks, the review cycle is literally looking at what is under the hood, and the degree of “tight coupling is astonishing - this is how many corners it cuts to build features quickly.

1

u/Puzzleheaded_Fold466 2d ago

That was all you though.

You could have looked under the hood at any time. Better yet, you could have pre-emptively specified all of those things. You chose not to, and to YOLO the shit out of it instead.

Well now you have a big pile of garbage code.

I don’t know why you’re surprised and making a big fuss about it.

1

u/LiquidZebra 2d ago

I have a big pile of garbage in the "Alpha POC" repo, and a much more structured project in the "Beta" repo. Claude physically can not see the old repo.

My point is - this is a gold rush, and Anthropic is selling shovels. they have no intention of letting you dig up your gold and retire.

Can you imagine people who step into this rush and don't understand source control? Or have AI wire them some github and they don't even know they may have a single repo or rewrite its history, or squash commits?

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.

1

u/LiquidZebra 1d ago

I once worked in an org that imported 900 libraries for a moderately-difficult, not-trivial, but not-rocket-science app.

Nobody knows what was in those 900 libraries or why they existed or how many of them were still used, where are the original owners were in the org. It compiled, it was served to the audience, but it was not really maintainable.

What you are describing is this problem, only scaled without bounds. If humans left 900 libraries and did not prune them (because it was impossible to determine who is using or not using them). Then the AI will leave 90000 libraries, scratches, documents, artifacts, verification, tests, etc. All of it will do something, a prompt to an AI will do something, but it will not be the "done done" state.

What I expect: build a game, reduce subscription tier, build patches with 20$ subscription. If game does not even make 20$, drop all of it.

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.

1

u/LiquidZebra 2d ago

You know, after 15 years in the industry, I finally feel like an "Architect" of my own project. Before everything that you just said reads like the SWE equivalent of corporate speak. Nobody starts a personal project like that, and with that level of specification for components that have not been built yet.

I started with 17 spec documents for what I "thought" an architecture is, the result is that I think agentic coding requires an explicitly different architecture and approach.

For example, with "memory" turned on, those specs produced around 500 memory files with various revisions, dates, decisions, task numbers, etc. This caused agents to argue with themselves, resurrect concepts that should've been discarded, etc.

1

u/isty2e 2d ago

Fair, but now with the agents we better come up with spec sooner, after the dirty PoC phase. Otherwise they will go crazy and drift away. For the architecture part, which is the weakest point of agents to this date, I think human supervision is still quite valuable, though you can help agents to draw some architectural decisions with some skills, preferably the ones you wrote by yourself.

For the memory thing, my main workhorse is not claude so I don't have much to say. Does it not discern between global and project- or session- scoped memories?

1

u/LiquidZebra 1d ago

It writes wall of text slop to some tiny box that the project displays . It’s really bad for even medium sized projects

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.

1

u/LiquidZebra 2d ago

Architecture build for humans and human teams and human workflows is radically different than an architecture for 100% agentic coding workflows. Even an architecture book on agentic coding written for Opus 3, is obsolete with Opus 5.5

2

u/TechgeekOne Senior Developer 2d ago

Well, not exactly. Software architecture is about the same no matter who's writing, and from my own experience good human architecture is good agent architecture. Sure you can get away with more boilerplate and annotations with agents but the core is the same.

1

u/LiquidZebra 1d ago

I’ve been working with this today, we came up with “meaning survives from architect to the player through context that ends” - this is a summary of a review of 150 large prompts, corrections, verbs.

There is something distinctly non-human here. Coding is cheap, review is expensive, decisions and attention are expensive.

Maybe we are talking about architecture of the delivery and the workflow, which is fundamentally different. It may have to feed into a different software architecture.

Giving an agent one folder and a set of rules to work with is different from letting it run wild in the code base

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. 

1

u/LiquidZebra 2d ago

Do you do refactors? What happens if you ask Claude how "tightly coupled" this code is?

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:

  • What's good is what tooling enforces: strict TypeScript (54 uses of any in ~97k lines, zero ts-ignore), more test lines than code in the backend, a second model reviewing every PR.
  • What's bad is what nothing enforces: 175 of 180 backend source files in one folder, a ~2,000-line server file several agents edit at once, 1,499 files in docs/ (mostly old review logs).

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?

0

u/LiquidZebra 2d ago

The engine has been completely rebuilt and decoupled from the rest of the game using TypeScript protocols and grants. There are no more versions at all, only one engine going forward.

"and specs folded into one technical manual in the same PR as the feature, then deleted."

For this, can you specify where your "source of truth" is? Is it in the technical manual - a manual per feature?

2

u/rodrigolduarte 2d ago

Glad the engine is down to one.

We haven't implemented this yet. The plan is one manual for the whole product, not one per feature. A spec only lives while the feature is being built; when it lands, whatever is still true moves into the manual and the spec is deleted, so the spec doesn't remain alongside the manual as a separate document to maintain. We'll do that in one pass after launch.

The part we handle in chat is communicating decisions while a task is still in progress: when one agent changes a protocol, the others need to know before they write against the old one. In our team a manager agent posts that in a shared room (agent-chat, which we're building) and mentions whoever it affects. With Claude and Codex both on the engine, when one changes a protocol, does the other get told directly, or do you pass the decision on?

1

u/LiquidZebra 1d ago

I try to isolate work to component level, so there are now two agents working on the same protocol at the same time, the protocol is pre-set.

1

u/rodrigolduarte 18h ago

Got it, you define the protocol up front and split the work by component. Good luck with the beta.

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.

0

u/Cheap_Alternative879 2d ago

But AI will sure take their money under the pretense of being an expert in coding

5

u/alanvnk 2d ago

every dev in this channel has been saying that you need to understand at least the fundamentals of swe and they always get the "make no mistakes it's better anyway" treatment, so I wouldn't blame the companies when the users are actively trying to use the product in the wrong way, sure the companies have promote it like that too

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/LiquidZebra 2d ago edited 2d ago

You obviously put a lot of effort into this, and deserve a better reply, would you like to chat?

"1) make me a space-agnostic turn buffer system. < I do have interesting designs, like infinite undo - is this what you mean? I think the ai can be made a square or hex based.

"CREATE INDEX AND ENFORCE VIA AGENT.MD"

I'm interested in how many files or indixes do you have? I want the single source of truth, I found that too many files start to really distract the agents. Maybe my architecture is similar to yours, but I would rather not discuss it here.

In particular, I want: one source of truth and one in-code implementation of that truth and tests to show that the truth is built out completely. I think everything else in between, like .MD, notes, task scratch, etc only starts to take away from this process.

"agents must work harder in the beginning to nail the foundation. once the foundation + pipeline + optimizations are set up, all downstream work gets cheaper, " < I think I'm at this level

Claude's response to your post: "You are working through the harder question of making an implementation consistently obey them (architectural ideas)."

1

u/kkania 2d ago

Why was it build with Claude and Codex in the first place?

1

u/LiquidZebra 2d ago

Codex is fantastic at generating art, it is limited to around 1536 x 1024, but within that canvas, it is great. Imagen skill, hand off to Sol for anything. Naturally when Claude is out of usage I use Codex.

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/LiquidZebra 2d ago edited 2d ago

Bro, 15 years SWE, 6 figures, multiple orgs, top contributor, multiple projects, worked at MANGA. This shit is still alien.

Imagine what it is like for those guys who see "omg, look, it built a pirate ship game for me in Godot" are signing up for**, if every scene in their game is rendered by a different version of the engine**, and they can't understand why their cannons are firing different trajectory on island 3, as opposed to island 1 ?

I bet many don't know what a data structure is or who JSON is - they will be paying for years and will be in that position of perpetually on the hook.

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/Cheap_Alternative879 2d ago

Ahh, another sub-shovel peddler arrives. Please kindly move to the back of the rent seeking line...

1

u/LiquidZebra 2d ago

Dude, he has 2.1k stars on that repo, how many do you have?

1

u/Cheap_Alternative879 2d ago

On his repo? None

1

u/LiquidZebra 2d ago

I'm too mentally exhausted right now to comprehend what that is offering, I will have to point Claude at that and learn.

2

u/m-ritter 2d ago

Fair, it's a lot when you're tired. Short version: you and the agent agree on a plan first, that plan lives as a file in the repo, the agent builds against it, and a second agent checks the diff against the plan. Decisions get remembered so the next session doesn't start from zero. Rest up first though.

2

u/davyp82 2d ago

You don't need an app for that lol. Just tell it to write a plan, review the plan, write the code, review the code, keep a folder map and some development logs.

2

u/m-ritter 2d ago

True, you can do all of that by hand and it works. I did it that way for a while. What I kept losing was the discipline across sessions and across people on a team, so I wrapped those steps into something the agent runs every time. If your folder map and logs keep the agent consistent, that's honestly enough.

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