SeekMoon: From IDE to ADE

MoonBit has open-sourced SeekMoon, a development environment it brands as an Agent Development Environment—an ADE, not an AI-flavored IDE. The core is implemented in MoonBit. The pitch is a clean split of labor: the developer defines a goal; an agent analyzes the codebase, creates a plan, edits files, and runs validation; and the human spends the session browsing, searching, and reviewing diffs.

The launch post frames this as a response to a shift already underway. Coding agents can independently complete complex development tasks and generate code at scale. As more implementation work is delegated, developers spend more of their time understanding code, reviewing changes, and making technical decisions. Traditional IDEs, MoonBit argues, are still designed around writing code by hand and have not adapted to this model of collaboration.

A workspace built around the task

SeekMoon’s workspace is organized around an ongoing development task. Once a goal is set, the agent’s process and results stay in the task context. Alongside the task, the developer can browse the project, search and read files, or open Diff Review at any time to inspect whether the changes meet expectations and to give the agent further instructions.

The review surface is the product. MoonBit groups it into three categories:

• Token Diff and Syntax Tree Diff to understand changes, while retaining IDE navigation such as Go to Definition and Find References in the review interface
• Code visualization so documentation comments and architecture diagrams render beside the code, with automatic folding of top-level implementations
• Syntax-tree search for MoonBit, with results that can be added directly to the agent’s context

Token Diff and Syntax Tree Diff

Token Diff compares lexical tokens and de-emphasizes formatting such as line breaks and indentation so substantive edits stand out. The post walks through a change from SeekMoon’s own development. After the argument no_console_window=true was added to @process.collect_stdout("hostname", []), formatting expanded one line of code into five. A line-based diff therefore showed one deleted line and five added lines. Token Diff matched the existing code across line boundaries and highlighted only the new argument and the required comma.

Syntax Tree Diff is for structural work: extracting a function, renaming a variable, rearranging branches. Compared with a line-based diff that shows only added and removed lines, it presents differences according to MoonBit’s syntax structure. In a HashSet refactoring in the moonbitlang/core project, set-construction logic was extracted into a helper named make_int_set, a local variable was renamed from map to set, and the assertion style was updated. In a line-based view those edits appear together as large blocks of deleted and added lines. In Syntax Tree Diff, the extracted function and related edits are easier to distinguish, so a reviewer can check that behavior remains consistent before and after the refactoring.

Once the differences are clear, the developer still has to decide whether the changes are correct and what else they touch. SeekMoon keeps familiar IDE capabilities inside Diff Review, including hover information, Go to Definition, and Find References. In one example, a references list for MoonDiffMode opens in the review interface with related code previewed alongside the diff, so the developer does not switch views to look something up.

Diagrams the agent can keep in sync

Diagrams are often more intuitive than prose, but in traditional development they take extra effort and fall out of sync when the code changes. MoonBit’s claim is that an agent can implement a change and update the accompanying comments in the same task, so the structural explanation and the code come from the same context. In addition to prose, an agent can use diagramming languages such as Mermaid in comments to generate flowcharts and architecture diagrams. SeekMoon also mentions D2.

Reading raw Mermaid or D2 source is not intuitive if the environment shows only the text. SeekMoon renders MoonBit documentation comments directly and displays their diagrams alongside the relevant code, while preserving access to the original comments. When a regular MoonBit source file is opened for the first time, the environment also folds top-level implementations automatically, prioritizing declarations, documentation, and the overall outline. Developers can understand structure first, then expand only the implementation they need to verify.

Search that defines the change, then hands it over

Besides conventional character-based text search, SeekMoon provides syntax-tree search for MoonBit, so developers can find code with the same structure even when the concrete syntax differs. In a test-code refactoring, some tests in moonbitlang/core determined whether a condition held by comparing a result with true. A syntax-tree search pattern:

@test.assert_eq($(actual:arg), true)

Here $(actual:arg) is a placeholder that can match different argument expressions. The search found 43 calls with the same structure across nine files, each listed with surrounding context.

The developer can review those results, exclude tests that still need to be preserved, and pass the remaining matches together with a change request to the agent—in the example, converting them consistently to assert_true. After the agent finishes, the edits go back through Diff Review.

MoonBit is explicit that SeekMoon is not simply adding a few AI features to a traditional IDE. It redesigns the environment around a collaboration model in which the agent drives implementation and the developer understands the result and takes ownership of it. That, the team says, is what an ADE is. Code produced by an agent is only the starting point. A task is truly complete only when the developer can clearly understand the code and confidently take ownership of it.

SeekMoon is now open source under moonbitlang/openseek. The post invites readers to explore the code, build it, and try it as the development environment moves from IDE to ADE. Token Diff and Syntax Tree Diff, as described here, are MoonBit-specific views; this account follows the vendor’s own launch post.

If you ship agent-generated code, read the full SeekMoon post, then build moonbitlang/openseek and walk Diff Review on a real refactoring: Token Diff on a formatting-heavy one-line change, Syntax Tree Diff on an extraction. That is the fastest way to test whether an ADE—goal in, review out—matches how you actually take ownership of agent-written work.

Sources

• From IDE to ADE — MoonBit