AI coding you can still explain

Less vibe coding. More understanding.

Pair is your AI coding partner for working alongside agents without outsourcing judgment. The agent proposes, explains, and verifies inside your workflow. You keep the direction, the decisions, and the shape of the code.

Read the vision

Proposal-firstthe agent drafts, you apply

Scoped worksmall enough to understand

Real reviewread the diff where you work

pair tasks_api.py active scope: create_task

scope decide propose approve verify stop

neovim

from datetime import date
from fastapi import FastAPI
from pydantic import BaseModel

app = FastAPI()
tasks: list[dict] = []

class TaskCreate(BaseModel):
    title: str
    due_date: date

@app.post("/tasks")
def create_task(payload: TaskCreate):
    task = payload.model_dump()
    tasks.append(task)
    return task

from datetime import date
from fastapi import FastAPI, HTTPException
from pydantic import BaseModel

app = FastAPI()
tasks: list[dict] = []

class TaskCreate(BaseModel):
    title: str
    due_date: date

@app.post("/tasks")
def create_task(payload: TaskCreate):
    if payload.due_date < date.today():
        raise HTTPException(
            status_code=422,
            detail="past due date",
        )
    task = payload.model_dump()
    tasks.append(task)
    return task

normal tasks_api.py create_task

pair agent

01 scope

Goal: reject tasks with due dates in the past.

I will stay inside create_task and add one focused test.

02 decision

Past due date: reject or normalize?

Reject with 422 so clients fix the input.

03 proposal

Proposal touches 1 function and 1 test.

No direct writes until you approve the diff.

04 approval

approve diff

Applied. Neovim is focused on the changed method.

05 verify

Scope validation passed.

Running the focused test file now.

06 stop

Decision: reject past due dates.

Changed: create_task guard and test.

Risk: timezone/date boundary.

Stop before expanding scope.

proposal.diff waiting for approval

- from fastapi import FastAPI
+ from fastapi import FastAPI, HTTPException

  def create_task(payload: TaskCreate):
+     if payload.due_date < date.today():
+         raise HTTPException(status_code=422, detail="past due date")
      task = payload.model_dump()

+ def test_rejects_past_due_date(client):
+     response = client.post(
+         "/tasks",
+         json={"title": "ship", "due_date": "2026-05-03"},
+     )
+     assert response.status_code == 422

pytest tests/test_tasks_api.py -q 4 passed

AI made code cheap to produce. It did not make code cheap to understand.

Pair exists for the developer who wants leverage without turning into a reviewer of mystery diffs. The point is not to make the agent do your work somewhere else. The point is to work alongside AI while your mental model stays intact.

The agent proposes. You own the decision. Scope is visible, changes are reviewable, and verification is a stop point instead of a checkbox at the end.

Good software is not the biggest patch a model can generate. It is the change a person can explain, verify, and maintain.

pair.computer

Vision

Agent speed, human understanding.

Pair turns AI coding into a small, legible loop: scope the work, surface the decision, inspect the proposal, apply deliberately, verify the result, and stop before context turns into noise.

It is not anti-agent. It is anti-opaque automation. The product is designed around one constraint: the developer should never lose the ability to explain what changed and why.

Workflow

A loop that keeps the human in the work.

Scope
Start with the method, file, or behavior that can be held in memory.
Decide
Make the tradeoff explicit before a patch appears.
Propose
Let the agent draft a bounded change, not a sprawling rewrite.
Review
Read the diff in the real editor before anything is applied.
Verify
Run the check that proves this specific change is understood.
Stop
Pause before continuing so the system model stays current.