Item — HN Reader

I think vibe-coding is cool, but it runs into limits pretty fast (at least right now).

It kinda falls apart once you get past a few thousand lines of code... and real systems aren't just big, they're actually messy...shit loads of components, services, edge cases, things breaking in weird ways. Getting all of that to work together reliably is a different game altogether.

And you still need solid software engineering fundamentals. Without understanding architecture, debugging, tradeoffs, and failure modes, it's hard to guide or even evaluate what's being generated.

Vibe-coding feels great for prototypes, hobby projects, or just messing around, or even some internal tools in a handful of cases. But for actual production systems, you still need real engineering behind it.

As of now, I'm 100% hesitant to pay for, or put my data on systems that are vibe-coded without the knowledge of what's been built and how it's been built.

3 comments

There are all kinds of memory hacks, tools that index your code, etc.

The thing I have found that makes things work much better is, wait for it... Jira.

Everyone loves to hate on Jira, but it is a mature platform for managing large projects.

First, I use the Jira Rovo MCP (or cli, I don't wanna argue about that) to have Claude Code plan and document my architecture, features, etc. I then manually review and edit all of these items. Then, in a clean session, or many, have it implement, document decisions in comments etc. Everything works so much more reliably for large-ish projects like this.

When I first started doing this in my solo projects it was a major, "well, yeah, duh," moment. You wouldn't ask a human dev to magically have an entire project in their mind, why ask a coding agent to do that? This mental model has really helped me use the tools correctly.

edit: then there is context window management. I use Opus 4.6 1M all the time, but if I get much past 250k usage, that means I have done a poor job in starting new sessions. I never hit the auto-compact state. It is a universal truth that LLMs get dumb the more context you give them.

I think everyone should implement the context status bar config to keep an eye on usage:

https://code.claude.com/docs/en/statusline

But even spec-first, using opus4.6 with plan, the output is merely good, and not great. It isn't bad though, and the fixes are often minors, but you _have_ to read the output to keep the quality decent. Notably, I found that LLM dislike removing code that doesn't serve active purpose. Completely dead code, that they remove, but if the dead code have tests that still call it, it stays.

And small quality stuff. Just yesterday it used a static method where a class method was optimal. A lot of very small stuff I used to call my juniors on during reviews.

On another hand, it used an elegant trick to make the code more readable, but failed to use the same trick elsewhere for no reason. I'm not saying it's bad: I probably wouldn't have thought about it by myself, and kept the worse solution. But even when Claude is smarter than I am, I still have to overview it.

(All the discourse around AI did wonder for my imposter syndrome though)

Doesn't require Jira but yes, specification-first is the way to get better (albeit still not reliably good) results out of AI tools. Some people may call this "design-first" or "architecture-first". The point is really to think through what is being built before asking AI to write the implementation (i.e. code), and to review the code to make sure it matches the intended design.

Most people run into problems (with or without AI) when they write code without knowing what they're trying to create. Sometimes that's useful and fun and even necessary, to explore a problem space or toy with ideas. But eventually you have to settle on a design and implement it - or just end up with an unmaintainable mess of code (whether it's pure-human or AI-assisted mess doesn't matter lol).

I used to manually curate a whole set of .md files for specs, implementation logs, docs, etc. I operated like this for a year. In the end, I realized that I was rolling my own crappy version of Jira.

One of the key improvements for me when using Jira was that it has well defined patterns for all of these things, and Claude knows all about the various types of Jira tickets, and the patterns to use them.

Also, the spec driven approach is not enough in itself. The specs need sub-items, linked bug reports and fixes. I need comments on all of these tickets as we go with implementation decisions, commit SHAs, etc.

When I come back to some particular feature later, giving Claude the appropriate context in a way it knows how to use is super easy, and is a huge leap ahead in consistency.

I know I sound like some caveman talking about Jira here, but having Claude write and read from it really helped me out a lot.

It turns out that dumb ole Jira is an excellent "project memory" storage system for agentic coding tools.

I self-host OpenProject - free and a little better than Jira.

This will probably make people laugh, but I just had claude make me one. It’s simpler than jira, but it’s good enough without the 10,000 things I don’t need.

I wouldn’t use it for work but it’s good enough to track my projects, note what’s in each release, has simple user and service account key issuance for api access, user roles and access control, project level configuration for kanban lanes and status mapping, claude can access everything via the api, simple project level document library with live preview markdown editing, etc.

I am not personally partial to Jira at all, I just already had a free account, they have a production-ready MCP, and exact Jira usage patterns are very well represented in the training data.

Have you been using Claude Code/whichever tool you use, to read and write from OpenProject directly? I do like self-hosting data like this. I used to self-host Jira back in the day.

It absolutely falls apart more often than not. And requires even better engineering practices than before, because people are just accepting the code changes without understanding the technical debt created by them. On this I agree. There are models that can be run locally, this morning I tested Gemma 4 running on 128 GB of RAM. It was very slow, like 20 minutes to refactor something instead of 20 seconds, but it seems to be as capable as the paid models that run on an expensive cloud subscription on one of these hated data centers. And no data is uploaded to them.

I suggest actually using Claude code and make a sample app using it. It absolutely can make apps even if you don’t know any fundamentals. I think it can work up to 20k LOC from my experience. You do need a human to give feedback but not someone who understands software principles.

That's a one-shot, though. Now try making something you want to build on. It falls apart very, very quickly.

Not to mention that these prototypes and samples all turn out more or less the same. Obviously, given how LLMs work. Like LLM prose, LLM-generated web apps have a distinctive, samey look and feel.