OUR STORY

We Built LOOM Using AI. Here's What We Learned.

LOOM exists because we got tired of not understanding our own code.

The Problem We Lived

We've all been there. You inherit a codebase. Or you come back to code you wrote six months ago. And you have no idea how it fits together.

You search. You scroll. You grep. You trace function calls manually. You draw diagrams on whiteboards that are outdated the moment you finish them.

We decided to fix it.

[IMAGE: Split screen. Left: Developer surrounded by sticky notes, multiple monitors with code, confused expression, coffee cups everywhere. Right: Same developer, calm, looking at a clear LOOM visualization that shows the exact structure they need to understand.]

How LOOM Started

[IMAGE: A developer's workspace at night. Single monitor glowing. The early prototype of LOOM running—a basic visualization that's recognizably the ancestor of DataVerse. The kind of late-night, obsessive building that creates real products.]

LOOM started as a side project. A tool built out of frustration. We wanted to see our code—really see it—and nothing existed that did what we needed.

So we built it. First for ourselves. Then for our team. Then we realized every developer we showed it to had the exact same reaction: "I need this."

LOOM is a product of Mental Alchemy IO, an AI consulting and software development firm based in Charleston, SC. The methodologies we use to build LOOM—Cognitive Mirror and Architect & Assemblers—are available as free white papers.

What We Believe

Code Has Structure

Every codebase has shape, patterns, and relationships. The problem isn't that structure doesn't exist—it's that you can't see it. LOOM makes it visible.

[IMAGE: Before/after. Before: Flat file list with no apparent organization. After: Same files shown as a structured graph with clear clusters, hierarchies, and relationships.]

Understanding Should Be Instant

If understanding takes hours, you won't do it. Every time. You'll skip it when you're under pressure. LOOM makes understanding fast enough to actually use.

[IMAGE: Stopwatch comparison. Old way: Hours of manual tracing. LOOM way: Seconds to see any relationship.]

Relationships Matter More Than Files

Files are arbitrary containers. What matters is how code connects—who calls what, what depends on what, what breaks if you change something.

[IMAGE: File-centric view vs relationship-centric view of the same code. The relationship view reveals structure that's invisible in the file view.]

Visualization Isn't Extra

Human brains process visual information better than text. Turning code into something visual isn't a nice-to-have—it's using the right tool for the job.

[IMAGE: Brain scan showing visual processing areas lighting up when viewing LOOM vs struggling with text-only code navigation.]

Built With Our Own Tools

LOOM is built with LOOM. We use it every day on our own codebase.

[SCREENSHOT: LOOM scanning the LOOM source code. Meta, but real. Shows the scanner processing its own files.]

15+ Core Modules

Scanner, Registry, DataVerse, and more—all mapped and maintained with LOOM.

[SCREENSHOT: LOOM's own dependency graph showing how its modules interconnect.]

5,697 Internal Connections

We know exactly how our own code connects because LOOM shows us.

[SCREENSHOT: LOOM DataVerse showing LOOM's architecture as a 3D visualization.]

Daily Usage

Every feature was built because we needed it. Every improvement makes our work better too.

Where We're Going

Code intelligence is becoming infrastructure. As codebases grow and AI tools become standard, understanding code structure isn't optional—it's essential.

For Developers

Instant codebase understanding
Visual architecture that stays current
AI assistants with full context

For Teams

Faster onboarding
Architectural governance
Knowledge that doesn't walk out the door

See What We Built

We built LOOM because we needed it. Turns out, so do you. The free tier is free forever—no strings attached.

[IMAGE: Full DataVerse visualization of a real codebase—thousands of interconnected nodes forming recognizable patterns, clusters of tightly coupled code, clean boundaries between services. Text overlay: "This is what understanding looks like."]

Start With LOOM Talk to Our Team

Free tier available. No credit card required. Your code stays local.