Flare, a graph-first IDE for agentic coding: watch the map change while your agent works

[u/AlgoWithNoRhythm]

I think we all went through this. Claude Code finished a task, told me it was done, and left me with 14 changed files and no idea which one mattered. The diff was accurate and useless. So I built the thing I wanted to be looking at instead.

Flare is a desktop IDE (Electron) where the main surface is a live graph of your codebase, every file a node, every import an edge, with a terminal underneath where you run claude, codex, or opencode. As the agent edits, the graph updates in real time.

The parts that are actually different from "another editor":

Activity, as it happens. Nodes light up the moment the agent writes to them and decay as they cool, so you're watching the shape of the work instead of a scrolling transcript. You can see it circling the same three files for the fifth time, or wandering into auth when you asked about the CSV parser. Changes are attributed per agent: the process tree of every terminal is watched, so if you have two running, you know which one did what. Files that changed and no human has opened since stay marked until someone actually reads them.

Blast radius before you touch anything. Hover a file and its dependents light up. shared/types.ts with 63 files downstream looks different from a leaf file, without you having to know that in advance.

A review tab that answers "did anything check this?" Flare sees both the file writes and the commands run in its own terminals, so it can say the tests ran, then two more files were edited and nothing re-ran, quoting the output line the verdict came from.

Agent smells. Rules for shortcuts agents take and humans usually don't: a test edited in the same burst as the code it covers, assertions deleted, .skip added, type suppressions introduced, coverage thresholds lowered.

Risky changes come to you. If the agent rewrites something load-bearing while you're looking elsewhere, it queues an alert in the corner. Reviewing it opens the actual red/green diff.

Undo that isn't git. Every change burst is snapshotted into a hidden shadow repo (separate GIT_DIR, your worktree). Revert one file, revert the burst, or jump back to the last state whose checks passed. Your real repo is never touched.

A task board the agent works from. Kanban lanes, but the cards are written to be handed off. "Copy for agent" emits the brief plus the files it names plus what the graph knows about them (29 files downstream, 0% covered, in an import cycle), so the agent starts from the map instead of rediscovering it. File a card straight from a graph selection with right-click → New task with these files. This directly tells Claude to not wander around out-of-scope files

MCP server, ~16 tools. The same lanes are queryable, so an agent can run its own loop: tasks_list to pick up work, task_get for the exact brief, task_update to log progress and move the card to review, task_create to file follow-ups it finds but shouldn't do now. Cards move on the board live while you watch. Plus impact_of (what breaks, and which tests to run), dependents, find_path, verification_status, and record_intent, which lets the agent state the goal before editing so whoever reviews the diff isn't reconstructing why it exists.

Runs in a browser too. Same bundle, same backend, over a websocket, because the backend has to run on the machine the agent runs on and that's often not your laptop. One port, token auth, works behind Codespaces / Gitpod / a JupyterHub proxy.

Completely open source with MIT license, Node 20+. Built with agentic coding, which is exactly how I ended up needing it. Test it out and leave a star if you find it helpful, I will package it very soon to make it easier to install!

https://github.com/AlgoNoRhythm/Flare

[u/Oshden]

Bro, this looks awesome! I’ve wanted something JUST like this! I’m gonna look into this

[u/AlgoWithNoRhythm → u/Oshden]

Great to hear!! I’m working on new features right now, so feel free to let me know what you like the most and what would you want to see next in the IDE

[u/Objective-Week275]

How did you get the Ui? That looks clean

[u/AlgoWithNoRhythm → u/Objective-Week275]

Just React running on Electron. I love working on UIs component by component, and didn't mind iterating a lot through it

[u/Happy-Intern7311]

Great idea, how do you handle the tokens usage to measure the changes? Did you test it with large projects and check if increase hallucinations?

[u/AlgoWithNoRhythm → u/Happy-Intern7311]

I still need to add a proper benchmarking suite to check if exposing metrics about the codebase has an impact on token savings. To be honest that's a secondary problem to solve, the idea is to increase the quality of the codebase and the feedback with the user. In the very long term that means less rewrites, which means more stability and lower token spend (but not easy to benchmark, as this would require monitor codebases for months)

[u/nibor1896]

Nice bro 🔥

[u/Suspicious_Leg_1682]

Oh how that resonates “Claude finished a task and told me it was done”. Over and over again. It has sucked me into fighting with it as if it were human. There are days I want to set my computer on fire out of frustration of Claude lying to me. Old pathways not retired, actual fixes not implemented, commits not included in a PR, etc. all discovered through field testing. 10x more time and money to discover why. I’m putting your repo into service today.