Show HN: I vibecoded a 35k LoC recipe app

Since I wrote the blog post, I actually added automated tests which Windsurf / Claude Code runs before committing any change. It saved me a lot of headaches when the LLM decided to make random logic changes for no reason.

Yeah, without trying to be dismissive I'm a bit unsure where the 35kLOC are going?

The 35k lines of code is what made me think this was either a joke or the state of vibe coding, but no it turns out they're serious

I have entire codebases of embedded software in C without the shortcuts of modern programming languages in way fewer than 35k lines

> 35 kLOC is quite a bit. I wonder how straightforward and maintainable this app ended up to be. This would require taking a look at the sources. While good Rails code tends to be very terse, frontend may be quite voluminous.

I think people will have to recalibrate on this. The LOCs do things that you otherwise would not do. Features and details that simply would not happen — because they are too code/time intensive for most projects. It just won't matter anymore.

> But why would non-technical people would even think in terms of log tailing and version control

They won't! They won't have to. The obvious good stuff that everyone thinks the AI tool should be able do, will just work, because the people building the tools, will mostly obviously focus on making them work.

Yeah 35k of code is a red flag. There's no reason for this to be that large.

> Preheat oven to 950 Kelvin

I believe I'm going to need a new oven...

Try out the Gluten Free Shark Teeth once you feel better!

https://www.recipeninja.ai/recipe/r_ttOB5xyqpOLXCL/gluten-fr...

Aw no it's gone!

bro that is part of the vibe, you just gotta roll with it

'Silicon Valley' was a practically a documentary. It's just a gold mine of absurdity out here.

I have similar thoughts and I have come to conclusion that that's the beauty and the curse of this technology. If one relies too much on it - it's gonna be a curse. However, if technology is used with care - it's a beauty. Not only does it keep SWE jobs "secure" - it really helps a lot for those who know what they are doing.

I think in the end AI will be more advanced tool, but a tool nonetheless. Like methodologies and principles, good practises etc. - they only work if you use it with care and added thought and adaptation to your case. DRY it a great principle. But sometimes it's better if you repeat yourself. For one reason or another. And these are the the tradeoffs that human in the loop should be making imho.

Hands-free voice control and being able to access recipe ingredients and steps without 5 pages of SEO-optimised prose.

https://news.ycombinator.com/item?id=43554945

To correctly vibe code something useful, I find that I need to religiously give faith to the tool and forget all about SWE principles and best practices and instead treat it like a child who makes mistakes and corrections while the adult must not intervene or admonish too much but rather nudge it to right direction.

Also vibe code has a parallel feature, while the code is generating, you are also doing live review and correcting it towards right direction, so depending on your experience, the end product can be a bad mess or wonderful piece of creation and maintenance dream.

The issue with seasoned SWE is that, the moment a mistake(or bad pattern) is made, the baby is thrown with bath water.

For a tiered app like the one presented, 35k LOC is not really that impressive if you think about it. A generic react based front end will easily need a large number of LOC due to modular principle of components, various amounts of hooks and tests(nearly makes us 25-40% of LOC). A business layer will also have many layers of abstractions and numerous impl. to move data between layers.

The vibe code shines, when you let it build one block at a time, limit the scope well and focus. Also, 2-3 weeks is a lot of time to write 35k LOC. at start of any new project, LOC generation rate is very high. But in maintenance phase it significantly falls as smaller changes are more common.

Full Disclosure: I'm building a LLM chat app for software developers and domain experts

> I struggle to find much utility in terms of actually writing code.

I personally feel you need to give up some control and just let the LLM do its thing if you want to use it to help you build. It honestly does a lot of things in a more verbose way and I've come to the conclusion that it is an LLM writing code for another LLM. As long as I can debug it, I'm okay with the code, as I can develop at a pace that is truly unreal.

I finished my "Recent" contexts feature in a half a day, today. Without the LLM, this would have taken me a week I think. I would say 98% of my code in the past few months has been AI generated. You can see a real life work flow here:

https://app.gitsense.com/?chat=eece40e2-6064-46d2-9bf1-d868c...

I truly believe if you provide a LLM with the right context, it can meet your functional specs 90% of the time. Note the emphasis on functional and not necessary style. And if *YOU* architecture your code properly, it should be 100% maintainable.

I do want to make it clear that what I am doing right now is not novel, but I believe most problems are not. If the problem is not well understood, it can be a challenge like my my chat bridge feature. This feature allows you import Git repos for chatting but I will probably need to rewrite 50% of the LLM code since the solution it built is not scalable.

> LLMs are super useful but currently, the primary use case is teaching, not doing.

For code? Autocomplete on steroids is the killer-app.

The other things the LLMs give me are prone to be over-engineered/overly verbose code or similar.

I went through a lot of "Why are you also doing $FOO then $BAR? Doesn't seem necessary if we skip them and do $BAZ which will make one or both of those redundant" and it responding "You're right! Lets use $BAZ instead".

And giving them code to make a small change to was pointless - they would often, but not always, make an incidental change far from the point where you asked for the change.

But autocomplete? That works just great and because I've already got context of the code I am writing I can check it in (at most) two seconds and move on.

I have very similar experience.

After seeing how people like Andrej Karparthy used vibe coding to generate applications https://x.com/karpathy/status/1903671737780498883?s=61 I realize that

you need to be clear on what you want the LLM to do break down the tasks and give byte sized tasks to llm to do specific thing and sometimes I had to tell it not go and change random files because it found the need to refactor them.