ES EN PT

Vibecoding IPIVC

The coordination standard for AI-assisted human teams.

Download v1.1 (Git Only) Download v2.0 (LokiVector) See How It Works

The "Chaotic Swarm" Problem

🌪️

Invisible Collisions

5 developers using 5 different AIs (ChatGPT, Trae, Cursor) touching the same files at the same time without knowing it.

🧠

Context Amnesia

Your AI doesn't know what your teammate's AI decided 5 minutes ago. Result: Incompatible code and immediate technical debt.

💥

Merge Hell

When everyone pushes auto-generated code, resolving conflicts becomes an impossible human task.

The Solution: IPIVC Protocol

A lightweight system that lives inside your Git repository and acts as a traffic light for your distributed team.

# 1. Install the standard in your existing project

$ python install_standard.py


# 2. Before coding, coordinate with your team

$ python tools/session_manager.py

> [1] Check Team Status (Sync)

> [2] Lock Files (Lock)


# 3. When finished, verify and release

$ python tools/session_manager.py

> [3] End Session (Unlock)

1

Investigate & Plan

Sync with the team and reserve your work zone (Lock). The system notifies the rest via Git/LokiVector.

2

Implement

Feed your AI with CURRENT_CONTEXT.prompt.md. The AI generates code respecting the boundaries.

3

Verify & Correct

You review the code using verify_task.py. If it passes tests, release the lock (Unlock) and push.

The I.P.I.V.C. Protocol

A strict lifecycle to ensure that AI speed doesn't compromise project stability.

I

Investigate

Before touching a line of code, the human syncs the team state. Who is touching what? What architecture must I respect?

P

Plan

The human defines the scope and LOCKS the necessary files. The intention is announced to the team remotely.

I

Implement

AI enters the game. The human feeds the agent with context and supervises code generation within safe limits.

V

Verify

The human acts as "Gatekeeper". Runs tests, linters, and checks that the AI hasn't hallucinated dependencies or touched forbidden files.

C

Correct

If verification fails, the human iterates with the AI. Only when everything is green, the lock is released and the final push is made.

The Human: Orchestra Conductor

In the IPIVC standard, AI is not a replacement, it's an instrument. The human is the only entity with responsibility and authority.

✅ Your Responsibility

  • • Sync team state before starting.
  • • Lock explicitly the resources you will use.
  • • Filter the code your AI produces.
  • • Release locks upon finishing.

❌ Forbidden

  • • Letting AI commit directly to main.
  • • Ignoring lock alerts from other colleagues.
  • • Copy-pasting code without reading it (Blind Trust).
  • • Assuming "the AI knows what it's doing".

Detailed Implementation Guide

Step 1: Task Start (Human Responsibility)

1. Check the Terrain:

$ python tools/session_manager.py
> Option [1] Check Team Status

The system will auto-sync via Git/LokiVector. If you see someone touching the module you need, STOP and talk to that human.

2. Reserve and Specify:

$ python tools/session_manager.py
> Option [2] Start Session

Create your session (e.g., @user - Feature X). CRITICAL: Edit the generated file and complete the Functional Specifications before continuing.

Step 2: AI Orchestration (The Magic)

Now that you have the "lock", you can unleash your agents.

  1. Run python tools/context_generator.py to create the master prompt.
  2. Copy the content of CURRENT_CONTEXT.prompt.md.
  3. Paste it into your AI chat (ChatGPT, Claude, Trae, Cursor).
  4. Pro Tip: Also paste AGENTS.md if your AI lacks file system access.

Step 3: Verification & Closure (The Filter)

Your AI has generated code. Is it safe? Does it meet specs?

$ python tools/verify_task.py

This script will generate an AI_FEEDBACK_REPORT.md.

  • ❌ If it fails: Give the report to the AI to correct.
  • ✅ If it passes: Release the lock (Option 3 in Session Manager) and push.

🚨 Conflict Management

If you need to touch a file already reserved by another human:

  1. DO NOT ask your AI to overwrite it.
  2. Contact the human owner of the session (their user is in the lock file).
  3. Agree on who does what or wait for them to finish.

Key Features

🤖 AI-Agnostic

Works with ChatGPT, Claude, Trae, Cursor, Copilot, or any future tool. Control remains with the human.

🔒 Hybrid Locking

Uses Git for persistence and LokiVector for real-time semantic conflict detection.

📄 AGENTS.md Standard

Implements the open standard for machine-readable documentation. Your agents will know how to behave.