Vibki's Workflow - Run Plan

After we understand how to create a solid plan - link to post, the next natural question is: who actually executes it? In this blog post, you'll see how the Run Plan command takes a structured plan file and turns it into real, working code automatically, step by step, using multiple specialized agents. The command lives in the open-source repo here.

Why Do We Need a Custom Run Command?

You might wonder can't I just ask my AI coding assistant to "implement the plan"? Technically, yes. and actually it will work pretty the same, But, this flow give more structure to the process and make the context mor clear, here are the main concepts:

• Agent Specialization: Different tasks require different expertise. Frontend work should go to a frontend-aware agent. Database migrations should go to a Supabase expert. A custom run command enforces those boundaries automatically, rather than dumping everything into one bloated context.
• Sequential Execution with Validation Gates: When you implement a feature step by step, you want to be sure each phase is correct before the next one starts. The run command builds this in each main phase is automatically followed by a validation phase before moving forward.
• Failure Recovery: Things break. The run command doesn't just stop when something fails it analyzes the error, generates a fix phase, adds it to the plan file, and tries again. This turns a fragile one-shot process into a resilient, self-healing loop.

Explanation of run-plan.md

Let's walk through what this command actually does at a high level.

Goal: Read a Markdown plan file, parse its phases and tasks, assign them to the right agents, execute them sequentially, validate each phase, and handle failures gracefully all while tracking progress through a live todo list.

Here are the key steps:

1. Read and Parse the Plan File: The command starts by reading the plan file you point it to. It extracts phases from headers like ### Phase N: Description, detects which agent is assigned to each phase via **Agent:** <name>, collects unchecked tasks (- [ ]), and skips completed ones (- [x]).
2. Create a Todo List: Before a single line of code is written, the command builds a complete todo list covering every task in every phase including validation tasks. This gives you (and the system) a clear map of what needs to happen, and it gets updated in real time as tasks move from pending → in progress → completed.
3. Execute Phases Sequentially: For each main phase, all tasks are executed one at a time using background agents (different context). Each agent gets the right context for its role the frontend agent works with React/TypeScript best practices in mind, while the Supabase agent thinks in terms of migrations, RLS policies, and edge functions.
4. Run Validation Automatically: After every main phase completes, the corresponding validation phase is triggered automatically. You don't have to remember to do it it just happens. The frontend-validator checks code against the project's own frontend standards, and the security-scanner looks for OWASP vulnerabilities. If validation passes, the system moves on. If it fails, recovery kicks in.
5. Handle Failures Gracefully: When a task or validation phase fails, the command doesn't just crash. It reads the error, creates a new auto-generated fix phase directly in the plan file, executes the fixes, and re-runs validation. If the fix works, execution continues. If it fails again, you're asked whether to continue, skip, or abort keeping you in control without breaking the flow.
6. Agent Mapping: The command maps human-readable agent names from the plan file to the actual tool types it uses under the hood. If a phase doesn't specify an agent, the command stops and asks you before proceeding it never guesses.

Conclusion

Here we saw the execution layer of Vibki's workflow the part that takes a plan and makes it real. By combining sequential execution, agent specialization, automatic validation, and failure recovery, the run command transforms a simple task list into a robust, multi-agent pipeline. Paired with the planning command covered in the previous post, this gives you an end-to-end AI coding workflow that's consistent, reliable, and easy to adapt to your own team's needs.