Docs
Open Babbit

Guides

Work from Claude Code or Codex

You can work on a Babbit project from the agent in your own terminal. It connects through the same door as Babbit's agents, follows the same rules and leaves the same record.

What an outside agent can do

An outside agent is any MCP client you run yourself, such as Claude Code or Codex on your laptop. Once connected, it can:

  • Read your project's spec.
  • Start a change from a sentence, exactly as if you typed it in the app.
  • Read a change: its stage, what it waits for, its proposed lines, pull requests and evidence.
  • Write a change itself, as its outside writer: propose the lines, and after you approve them, push the code.

An outside agent can't record evidence, promote a release or use a secret. Babbit verifies its work the same way it verifies Code Writing's.

Connect your client

  1. In Babbit, open your profile menu and choose Connected apps.

  2. Choose your client. Babbit shows the command to run.

  3. Run the command in your terminal:

    Claude Code
    claude mcp add --transport http newdev https://newdev-mcp.babbit.dev/mcp
    Codex
    codex mcp add newdev --url https://newdev-mcp.babbit.dev/mcp
codex mcp login newdev

  4. Your client opens a Babbit page in the browser. It shows the client's name and where it will return.

  5. Choose the project the client may start changes on, then click Allow.

Your client is now connected. To use another MCP client, choose Other on Connected apps and use the server address https://newdev-mcp.babbit.dev/mcp.

Start a change from your terminal

Ask your agent in plain words. For example:

Prompt
Start a Babbit change: customers should get an email receipt after checkout.

The agent calls change.start. Babbit briefs the change and the Product agent proposes lines, as usual. The answer includes a link to the change. Approve the lines in the app; nothing is built until you do.

To follow the change, ask your agent to read it, or open the link.

Write a change yourself

To write the code with your own agent instead of Babbit's Code Writing agent, start the change with you as its writer:

  1. Ask your agent to start the change with writer outside. Your agent becomes the change's writer.
  2. Your agent reads the spec with spec.read and proposes lines with spec.propose.
  3. Your agent hands the lines off with change.handoff. You approve them in the app.
  4. Your agent writes the code and pushes it to a branch named change/<id> in each repository, where <id> is the change's id.
  5. Your agent calls change.handoff again.

Babbit checks the pushed branch against the same shape rules as Code Writing's work. If something is wrong, the answer says exactly what to fix: fix it, push, and hand off again. Then Babbit opens the pull request, verifies it and lands it.

Your agent can load the same skills Code Writing uses with skill.load, so it works the way Babbit's agents do.

Land directly

A project owner can turn on Land directly on Connected apps. With it on, changes the owner writes as an outside writer are approved and merged at handoff, without verification.

Land directly trades proof for speed. Use it only for urgent fixes you've checked yourself. Changes that land this way show as unverified until a later change proves them.

Revoke a client

  1. Open Connected apps.
  2. Find the client and revoke it.
  3. Confirm.

The client's token stops working at its next call.