Connecting to dev server...

Circuitry Logo
Circuitry
Open Editor

Circuitry as an Agentic IDE

If you're arriving from Cursor or VS Code with Copilot, this is the page for you. Circuitry is built for how senior developers actually work with AI today — not typing more, but orchestrating more.

Why a new kind of IDE

A few years ago AI coding meant "help me finish this function." Today it means "build the auth flow, the API routes, the UI, and the tests." The chore that's left isn't typing — it's directing: deciding what to build, in what order, with what shape, and inspecting the output to make sure the model didn't drift.

Circuitry is the IDE for that kind of work:

  • Visual planning before generation. Sketch the system as a flow or a diagram first — the agent reads it when you reference it in chat. The model has structure to follow instead of wandering.
  • A real IDE for inspection. Read what the agent wrote. Set breakpoints, step through it, accept or reject diff hunks. You spend less time typing code and more time reviewing it — Circuitry is built around that.
  • One app for the whole loop. Plan, generate, inspect, iterate. No tab-switching between a planning doc, your IDE, your terminal, and a chat window.

This is the opposite of vibe coding. Vibe coding hands the wheel to the model and hopes; Circuitry gives you the wheel back, with a diagram of the road and the engine you can pop the hood on.

What you get out of the box

  • Open a project folder — point Circuitry at any directory on disk; it opens like a workspace, with a file tree and tabbed editors.
  • Tabbed code editing — syntax highlighting, IntelliSense, breakpoints, and diff decorations.
  • Visual planning canvases — workflow editor, design canvas, drawing canvas, and chatflow editor live in the same project as your code. Sketch the system, then reference it in chat: "implement this flow."
  • Multi-document split-screen — drag a tab to the right pane to put two documents side-by-side. The chat agent activates whenever a chat is paired with a code file or workflow.
  • MCP server for CLI tools — Claude Code, Codex, and Gemini CLI plug into Circuitry through its MCP server. They read your sketches, designs, and workflow state — the same context the in-app agent has — and their file edits round-trip through diff approval.
  • External file change detection — if any external tool (a CLI, your other editor, a script) edits a file you have open, Circuitry shows the changes as accept/reject diff hunks instead of silently overwriting.
  • Inline AI — ghost-text completion (Tab to accept) and Cmd+K inline prompt (with diff approval). See Inline AI in the Code Editor.
  • Agent chat with plan + diff approval — pair a chat with your code; the agent sees your file path, selection, and containing function automatically. Plans are approved before they run; edits land as diff hunks. See Agent Chat in Split-Screen.

What you can do here that you can't in a traditional AI IDE

1. Talk to the agent about your diagrams

Plain AI coding still works ("create a website that lists my products"). What's new is that when a sketch, flowchart, or workflow is in the right pane, the agent sees it — and you can reference it in chat the way you'd reference it with a teammate:

  • "Implement this flow." — agent reads the diagram, generates code, lands as diff hunks.
  • "Show me a flowchart of the login flow in my code." — agent reads the code, draws the flow on a canvas.
  • "I modified the flow — update the code to match." — agent diffs old vs new diagram and regenerates the affected files.

For complex features the diagram cuts the difference between "the model went a direction I didn't want" and a clean first pass. The model has structure to follow instead of extracting intent from a wall of text. For simple changes, skip the diagram entirely — just type the request.

2. Workflow-aware completion

Circuitry editors live next to your data flows. When you open a Code node downstream of a DataGrid, Circuitry knows the actual columns of that DataGrid. Type // sum the price column in the code editor and the AI completes with code that references the real price field — not a guess.

3. One review surface for every source of change

When you Cmd+K a selection and apply, the result lands as diff hunks. When the agent edits a file, the result lands as diff hunks. When Claude Code (running on its own outside Circuitry) edits a file you have open, the result lands as diff hunks. One review surface for all sources of change — critical when you're orchestrating multiple agents or running a CLI tool alongside the in-app agent.

4. On-device AI option

Apple Intelligence is wired in as a model option. Pin it as your inline-completion model on Mac or iPad and your code stays on the device — no cloud round-trip, no API key, no keystrokes shipped to OpenAI.

A typical session

  1. Open Circuitry. Click "Open Project Folder" and pick ~/Code/myproject.
  2. Open a workflow or design canvas in the right pane (optional — for the kind of feature where a sketch helps). Boxes, arrows, a few notes on the constraints.
  3. Open a chat in the bottom pane: "implement this flow" — or, if you skipped step 2, just "add a logout endpoint with a token revoke." The agent sees the diagram (when there is one) and the open code files.
  4. Review the proposed plan. Approve the parts you want, reject the rest. Edits land as diff hunks — accept the good ones, kick the rest back.
  5. Step through the new code with the debugger. If something looks off, fix it inline with Cmd+K, or kick it back to the agent with a more specific instruction. "I modified the flow — update the code to match."
  6. Done. Save, commit, ship.

How to think about Circuitry

  • You direct, the AI executes. Type less code, plan more, inspect more. The IDE is built around inspection and direction, not keystrokes-per-minute.
  • A diagram is a prompt with structure. When intent is complex enough that prose gets fuzzy, sketch it. The agent reads the sketch the same way it reads code. Skip the diagram for simple changes — plain chat still works.
  • It's one app. Workflow editor, design canvas, drawing canvas, code editor, debugger, agent, terminal — all in one place, all aware of each other. The compounding value is in the connections.

Getting started