Last time we talked about how to start vibing; today let's talk about how to maintain a vibe project long-term.
As a vibe project moves forward and grows bigger, a lot of problems show up.
The Initial Context Problem
When you start a new conversation with the AI to update the project, there's a very serious problem:
The AI reads your entire project first, fully understands it, and only then starts developing.
This means it burns a lot of time right at the start, and eats up a ton of context. Once the project gets big, the AI can fill the entire context just by reading the project (yes, I'm talking about you, damn gpt6 Thunder Thinking + Defensive Programming).
How do you avoid this? The simplest way is /init.
Once your project architecture is more or less in place, you can consider /init. What this command does is have the AI go through the project once and produce a concise agentmd that explains the project's structure and what it is. With that in place, when you work on things later, the AI reads agentmd instead of the whole project, so it doesn't have to read everything every time — it saves a ton of tokens and speeds things up.
How to Keep the Project from Spiraling Out of Control
A big problem with AI is that it loves to shit everywhere, especially when you're using a non-flagship AI or a lower thinking mode.
For example, building a web page: you may have already designed a button earlier, but every time a new button comes up, the AI designs yet another control instead of reusing the existing one.
And these controls end up scattered everywhere — some in this folder, some in that folder.
Pile up this shit mountain long enough and the project spins out of control.
The /init above can help with this to some degree, but when you're actually doing the work, you still need to consciously watch for it and make the AI reuse things and follow consistent conventions, structure, etc. (you can codify these in agentmd).
Docs and Architecture
With vibe, you no longer manage the actual code — you manage the docs.
Docs are the spec you give the AI, telling it how to do things. Here's the structure I recommend:
agentmd (hard constraints) -> readme (project intro and rough architecture) -> readme points to dedicated docs for each part
This way the AI reads agentmd -> readme, then based on the task and the conventions in the readme, loads the docs for each part on demand.
Loading on demand is a big deal: it gives the AI constraints while effectively preventing it from reading too much and losing focus.
For example, you can write how to self-test the project as a separate doc and point to it from the readme. During normal work it isn't read in full; only when the project needs self-testing does the AI go read that doc in full — that's loading on demand.
Of course, this kind of architecture is a matter of opinion, but the ideas of strict conventions and loading on demand don't change.
No comments yet
Share your thoughts and keep the conversation clear and kind.
Write a comment
Sign in with GitHub first, then you can comment.