Chain-of-Vibes
April 14, 2025
Despite the breathless hype from some corners of the internet, vibe-coding - fully autonomous AI coding - isn’t going to replace engineers in the near future. Anyone who’s tried it on a significant coding problem will have likely watched the AI charge down a questionable path, make a mess, and get stuck.
The good news is that engineers CAN still lean on AI to significantly accelerate our productivity in real-world codebases. We CAN still use vibe-coding techniques for bigger problems. We just need to keep ourselves in the loop.
In my previous post I covered some tips for vibe-coding (using agentic AI systems to write software), but focused on the sort of simple, relatively small coding tasks that current models are able to handle.
Today we’ll look at how to scale up agentic AI to tackle much bigger software development challenges, using a workflow called Chain-of-Vibes.
AI isn’t ready for unsupervised coding
LLMs aren’t quite ready for “free-soloing” on anything beyond very small greenfield codebases. When you try using agentic AI to add non-trivial functionality to an existing codebase you will quickly discover that the current state-of-the-art models have major limitations:
- They don’t have great judgement or taste when it comes to bigger technical decisions.
- They tend to focus on short-term fixes, leaving issues which will be “fixed later on”.
- They tend to double-down on incorrect approaches and get stuck deep in rabbit holes.
- Bad judgement tends to compound - the AI isn’t able to spot that it made a bad design decision, and then back up and take a different approach.
- Coding AIs have a tendency to gold-plate and over-engineer their solutions.
- They don’t like to work incrementally - they want to deliver everything in one go.
Taken together, these limitations mean current state-of-the-art agentic AIs can’t autonomously handle substantial changes in complex codebases. The key word here is autonomously. Much like “full-self-driving” remains mostly hype, fully autonomous vibe-coding isn’t here yet. However, we can still effectively use vibe-coding techniques on bigger problems - we just need to be ready to put our hands back on the wheel when needed.
Introducing Chain-of-Vibes
I’ve found that a workflow I call Chain-of-Vibes lets me maximize how much I can lean on AI for coding.
This approach consists of driving the AI through a series of separate, fully-autonomous (“vibe-coded”) changes which build upon each other, with human-in-the-loop feedback between each change.
This mirrors how you might work with a junior engineer — you collaboratively develop an overall approach, then they tackle each step independently, periodically checking back in for code reviews to ensure they’re on the right track.
Start with an implementation plan
Now, let’s break down the details of how you would work on a software development task using Chain-of-Vibes.
Kick things off by working with the AI to develop an implementation strategy. The purpose of this step is two-fold. We’re creating a succinct, concrete plan that we can refer to in subsequent AI prompting. At the same time, we’re also using this planning phase to refine the solution the AI initially comes up with.
A back-and-forth chat conversation at this high level of planning is a very efficient way to iterate through ideas and course-correct any bad decisions from the AI, without investing too much time or going too far down any rabbit holes. This is a critical benefit of Chain-of-Vibes versus a pure “vibe-coding” approach where you just give an initial problem statement to the AI and only provide feedback after the entire solution has been built.
When prompting the AI for this plan, be sure to point it to helpful context - areas of the code that it can use in its solution, parts of the database schema that are relevant, architectural documents, style guides, etc, etc.
If the problem you’re working on is already defined in a Technical Design Doc (or ADR, or RFP, or whatever) then you should definitely provide that to the AI. Don’t be afraid to ask for clarifying questions, it gives you and the AI more opportunities to align on a better solution.
If your problem is less well defined, you can start the planning by asking the AI to create a design doc for you! After iterating on that together, you can then move on to asking the AI to formulate an implementation plan.
Chunk through the plan
You and the AI should exit the planning phase with a concrete sequence of implementation steps. Now it’s time to chunk through those steps, one by one.
That last part is important - we do not want to hand the entire plan to an AI agent and ask it to implement it. The AI would be very happy to do so - these models really want to tackle everything in one shot. But vibe-coding the entire implementation will not give us enough opportunity to provide incremental feedback to the AI as it works.
Instead, we will spoon-feed the plan to the AI, and have it vibe-code each standalone step in isolation. Once it’s done we’ll review the AI’s work, and make any adjustments or fixes as necessary. Once we’re happy that the implementation for that one step is complete, we’ll commit those changes then start again, asking the AI to vibe-code the next chunk of work.
You’ll likely need to explicitly focus the AI to only work on one specific part of the implementation plan. One good trick is to tell the AI that you want it to make small git commits as it works; this gives you a natural checkpoint for human review. As a bonus, it also gives you a series of “save game” points that you can revert to if (when!) your AI companion goes off the rails - more on that in a moment.
For each step we will let the AI work autonomously until it completes the chunk that it’s been assigned, but at that point we will carefully review its changes. After review, you have four choices:
A) Accept and commit
accept the changes and commit
B) Prompt to adjust
prompt the AI to fix issues
C) Manually fix up
manually fix issues yourself
D) Revert and re-prompt
discard changes and try again
Sometimes - quite often, actually - you will discover that the AI started off with a poor decision and just kept going, and made a bit of a mess. In these situations it’s best to just revert the entire changeset, reset context, and restart the mini vibe-coding session with a better prompt.
On its face this sounds really wasteful, but turns out to often be the most efficient approach. The AI doesn’t have feelings; don’t be afraid to throw away all its work and tell it to try again.
Some Chain-of-Vibes pro-tips
Clear Context Frequently
Developers working with AI have noticed performance degradation as coding sessions lengthen and context windows grow. With Chain-of-Vibes you can very easily reset context between each task (i.e. start a new chat session, or restart your CLI tool). This reduces the “cognitive load” for the AI, preventing it from being distracted by implementation details from the previous task. As an additional benefit, you’ll likely lower your LLM bill, by reducing the number of tokens used to maintain unnecessary context.
Use the Right AI for Each Task
Don’t limit yourself to a single tool or model. By breaking the overall work into standalone tasks you are now able to use different tools for different tasks.
For high-level design planning, prioritize reasoning capabilities over IDE integration. A model that has deep research capabilities - extended reasoning and the ability to search the internet - is useful if you’re still doing broad exploration of the solution space. Something like ChatGPT’s Deep Research, or Claude’s web chat.
Once you’ve dropped down into implementation tasks, you’ll want to favor tools that are deeply integrated with your codebase over slower (though more powerful) reasoning models. Cursor, Claude Code, Windsurf, etc.
Chain-of-chain-of-vibes
This workflow has a fractal quality - There’s no reason you shouldn’t take one task in a Chain-of-Vibes and break that down into its own chain. Start by asking the LLM to plan what’s needed to implement that one task, then chunk through each sub-task, commiting and resetting context as you go.
Why Chain-of-Vibes works
A workflow like Chain-of-Vibes is extremely exciting because it starts to bring the wild productivity boosts of agentic coding to much more of my actual day-to-day engineering work.
I continue to find value in the metaphor that coding AIs are like weirdly knowledgeable, hyper-productive junior engineers. They know a lot of stuff, they’re very eager to impress, but they make some bad decisions at times, particularly design decisions. Trying to apply vibe-coding to a meaty programming task is like emailing a description of that task to a junior engineer, telling them “come back to me when everything is done”, and then expecting the resulting implementation to be ready to merge. This doesn’t end well. Experienced engineers will use a much more collaborative approach: have the junior engineer come up with a plan, then work with them a whiteboard to refine that plan. Have them go off and work on the implementation, but check in frequently and give feedback as they go. If you don’t, you might end up having to tell them to throw the whole implementation away.
In exactly the same way, a naive vibe-coding approach often doesn’t scale to real-world programming tasks, but if we as engineers work to keep ourselves in a tight feedback loop with the AI then magical things start to happen. We can do more of the thinking, and leave the tedious typing to the machines!
This post covered the essential components of a Chain-of-Vibes approach, but there’s a lot more detail that could be covered in future posts. In particular I’d like to share more hands-on examples of what prompts look like, how to generate an plan that the AI can use effectively, and much more.
More resources
If I’ve left you excited and hungry for more, I highly recommend these resources:
- Harper Reed deserves credit for the overall structure of this approach - my starting point in developing this workflow was his LLM codegen post
- The prolific Simon Willison offers practical tips in this post, backed by extensive hands-on experimentation
- Birgitta Böckeler’s series of memos on LLM experiences at ThoughtWorks includes a thoughtful analysis on the role of developer skills in agentic coding
I can help!
I provide hands-on consulting support around AI adoption. If your engineering org wants to improve AI coding practices, get in touch!