How to use Modulo for vibe coding

Vibe coding is the practice of letting AI agents write code iteratively based on natural language prompts. You describe what you want, the agent writes it, you review, you iterate. It is fast, creative, and surprisingly effective for prototyping and small features.

The problem is that vibe coding without governance means you are trusting the agent completely. The agent writes code, tests, and documentation - and if it makes a mistake, the mistake is in your repo before you notice. Modulo gives you a governance layer that sits between the agent and your repository, catching problems before they land.

Here is how to set it up in the simplest possible way.

Option A: single local machine with Docker Compose

This is the fastest path to a working setup. You need Docker Desktop and a GitHub account.

1. Clone the Modulo repository and start the stack: git clone https://github.com/farnalabs/modulo.git cd modulo docker compose up

2. Create a GitHub personal access token with repo scope. This lets Modulo watch your repository for pull requests.

3. Log into Modulo at http://localhost:8080. The default credentials are printed in the container logs.

4. Create a GitHub connector using your PAT. This connects Modulo to your repository.

5. Create a pipeline with three nodes:

   • A trigger that fires on pull request events
   • A sandbox agent node that receives the PR diff and makes changes
   • A gate node that checks the agent's output for secrets, schema violations, and quality thresholds

6. Open a pull request in your repository. Modulo picks it up, spawns the agent, runs the gate, and presents the results for your review.

The whole setup takes about fifteen minutes. You do not need a cloud account, a credit card, or any infrastructure beyond Docker.

Option B: free GitHub services with the hosted demo

If you do not want to run infrastructure at all, use the hosted demo at demo.modulo.run.

1. Create a GitHub personal access token with repo scope.
2. Log into demo.modulo.run with the demo account.
3. Create a GitHub connector using your PAT.
4. Create the same three-node pipeline: trigger, agent, gate.
5. Open a pull request and watch Modulo handle it.

The demo instance is free and resets periodically. It is not production infrastructure, but it is enough to see the governance model in action.

What the pipeline does

When you open a pull request, Modulo captures the diff and spawns an agent in an isolated sandbox. The agent reads the PR description, makes the requested changes, and produces a new diff. Before anything reaches your repository, the gate checks the output:

• Does the diff contain any secrets or credentials?
• Does the output match the expected schema?
• Does the code pass basic quality thresholds?

If the gate passes, you review the evidence and decide whether to merge. If the gate fails, the agent gets a new run with the gate's feedback attached, and the original stays as evidence.

This means you can vibe code at full speed - describing features, iterating on prompts, shipping fast - without wondering whether the agent introduced a problem you will find in production.

The principles behind this: deterministic gates catch failures before they reach your repository, and humans in the loop where it matters means you always have the final say.