Hero
What it looks like
Seriously?
Wow/SpacetimeDB!
The End

Dissect — Devpost Submission

About the project

Inspiration

AI coding agents are becoming extremely good at writing software, but that creates a new problem: developers can now produce code much faster than they can build a mental model of what that code actually does.

It is increasingly easy to fall into "vibe coding": ask an agent for a feature, watch hundreds of lines change, skim the diff, and move on without really understanding the system being built.

We built Dissect around a different idea:

Bring the coding agent you already use. Dissect helps you understand the code it leaves behind.

Instead of replacing Claude Code, Codex, OpenCode, Copilot, or other coding agents, Dissect sits on top of the existing agent workflow as a comprehension layer.

What it does

Dissect is an agent-agnostic coding workspace that helps developers understand both an existing codebase and the changes their coding agents make to it.

Analysis is always on demand. Dissect does not continuously send code to another model in the background.

Dissect

When the developer clicks Dissect, the current repository is analyzed and transformed into an interactive mental model of the project.

Dissect produces:

an interactive architecture map
explanations of major folders and modules
file-level summaries
semantic explanations of code blocks
contextual Q&A about specific parts of the project

The architecture-level dissection is performed using the Grok API.

For example, clicking an /auth node in the architecture map opens a focused explanation of what that module does, how it connects to the rest of the application, and what each file inside it is responsible for.

Clicking a file opens the actual source code. At this level, Dissect uses the Gemini API to perform detailed code-level dissection, splitting the file into meaningful semantic blocks and explaining what each block is doing.

Instead of explaining syntax in isolation, Dissect builds a hierarchy of understanding:

Codebase
  -> architecture
      -> module
          -> file
              -> code block

Dissect Diff

After a coding agent changes the repository, the action becomes Dissect Diff.

Dissect does not trust the agent's description of what it intended to do.

Instead, it compares the actual repository state against the previous Dissect snapshot and explains:

which areas of the project changed
which files changed
what the changed code blocks do
why those changes matter
how the architecture or data flow changed

The repository itself is always the source of truth.

Explanations that grow with the developer

One of the main ideas behind Dissect is that explanations should not stay static.

A beginner might need to know what async/await means.

A more experienced developer probably does not. They may instead need to understand how a new asynchronous database operation affects request latency, error propagation, or architecture.

We use SpacetimeDB to maintain a persistent, dynamic model of the developer's knowledge and project state.

Developers can explicitly signal things such as:

I know this
Explain more

Dissect stores both:

global knowledge, such as familiarity with JWTs, promises, REST, or middleware
project-specific knowledge, such as whether the developer already understands this project's authentication system or event pipeline

That state evolves over time and is fed back into future dissections so the explanations can progressively move from syntax-level teaching toward architectural and engineering-level reasoning.

For the hackathon, this knowledge model stays behind the scenes rather than becoming another dashboard the user has to manage.

How we built it

Dissect is a full fork of the open-source Paseo coding-agent workspace.

Paseo gave us the foundation we needed for agent execution, sessions, workspaces, terminals, Git integration, worktrees, files, and diffs. Instead of rebuilding another coding-agent runner, we focused our work on the comprehension layer.

The system roughly looks like this:

Existing Coding Agent
Claude Code / Codex / OpenCode / Copilot / Pi
                     |
                     v
              Local Repository
                     |
                     v
             User clicks Dissect
                     |
          +----------+----------+
          |                            |
          v                           v
      Grok API              Gemini API
 Architecture-level        Code-level
    dissection              dissection
          |                     |
          +----------+----------+
                     |
                     v
          Structured Dissect Model
                     |
          +----------+----------+
          |          |          |
          v          v          v
       Mermaid     Files     Code Blocks
       Graph      Summaries  + Explanations
                     |
                     v
               SpacetimeDB
          Developer + Project State
                     |
                     v
          Future explanations adapt

Grok

We use the Grok API for architecture-level reasoning.

It analyzes the structure and relationships within the repository and produces structured architecture information that Dissect converts into interactive diagrams.

Gemini

We use the Gemini API for lower-level code dissection.

Gemini analyzes individual files and code regions, producing structured summaries tied back to specific parts of the actual source code.

SpacetimeDB

We use SpacetimeDB as the persistent state layer for the learning system.

It tracks how the developer's explicit knowledge evolves across concepts and projects, allowing future explanations to adapt instead of treating every interaction like the user's first encounter with the codebase.

Challenges we faced

One of the biggest design challenges was deciding what Dissect should trust.

The easiest implementation would have been to give the explanation model the coding agent's conversation and ask it to summarize what happened.

We deliberately avoided that.

An agent's stated intention can differ from what it actually changed. Dissect therefore analyzes the repository and Git state directly rather than relying on the agent transcript.

Another challenge was scale.

Sending an entire repository to a model and asking it to "explain the codebase" produces either enormous outputs or shallow summaries.

Instead, Dissect analyzes the code hierarchically:

repository
   |
architecture
   |
module
   |
file
   |
semantic code block

The developer can progressively drill deeper only where they actually need more understanding.

We also had to solve personalization without pretending we can accurately infer someone's knowledge from a few clicks. For the current version, knowledge changes only through explicit signals from the developer.

What we learned

The main thing we learned is that code generation and code comprehension are fundamentally different problems.

Coding agents optimize for completing a task.

A comprehension system needs to optimize for building an accurate mental model.

That means caring about different things:

architecture
data flow
module boundaries
conceptual dependencies
source-code traceability
explanation depth
what the developer already understands

We also learned that persistent state changes the usefulness of an AI teaching system dramatically. Without memory, every explanation begins from zero. With SpacetimeDB tracking explicit knowledge, Dissect can gradually stop explaining fundamentals and spend more attention on the unfamiliar edge of the developer's knowledge.

What's next

Our long-term goal is for Dissect to become the comprehension layer for agentic software development.

Future versions could add:

richer developer knowledge modeling
AST and language-server-backed program analysis
call graphs and dependency graphs
richer architectural visualizations
adaptive explanations based on additional learning signals
more analysis models
support for additional coding-agent environments

As coding agents continue to improve, we think the bottleneck will increasingly shift from:

"Can the AI write this?"

to:

"Do I still understand the system I am building?"

Dissect is built for that second question.

Open source

Dissect is open source:

https://github.com/SirNosh/Dissect

Built with

Use these as Devpost tags, selecting the closest official tag names available:

SpacetimeDB
Grok
xAI
Gemini
Google Gemini
TypeScript
React
React Native
Expo
Node.js
Electron
Mermaid
CodeMirror
Git
Zod
Cursor
Paseo

Try it out

Source code