Lumyst

We built the wrong thing first. Here's what we learned.

We started with Smart Graph. It was a structural map of your entire codebase. Think architecture diagrams, but accurate and generated from the actual code.

It showed:

What modules exist
How they connect
Where each component lives in the code
The overall system architecture

Developers loved it. During onboarding.

Then they stopped using it.

The Pattern We Saw

Week 1: New developer joins. They open Smart Graph. They explore the codebase. They understand the overall structure. "This is amazing. I understand the system now."

Week 2: They're writing code. They're fixing bugs. They're reviewing PRs. They never open Smart Graph.

Week 3: Still not using it.

Week 4: We ask them why. "I already know the structure. I don't need it anymore."

The Realization

Onboarding happens once. Debugging happens every day.

Structure is important. But it's front-loaded. You learn it once and you're done.

Behavior is what you need constantly. "How does this feature actually work? What happens when I click this button? Why is this API failing?"

Why Smart Graph Wasn't Enough

Smart Graph showed the map. It didn't show the journey.

It told you:

"There's a Payment Module"
"It connects to the Fraud Module"
"Both talk to the Database"

But it didn't tell you:

"When a user clicks checkout, this exact sequence of 15 functions runs"
"The fraud check happens here, in this specific function"
"If fraud is detected, this path is taken instead"

The Difference

Structure = What exists

Behavior = What happens

You only need to learn structure once. You need to understand behavior constantly.

The daily reality:

Developers don't spend their day asking:

"What modules do we have?"
"How is the system architected?"
"Where does the Auth code live?"

They spend their day asking:

"Why is this API returning 500?"
"What does this AI-generated function actually do?"
"How does the refund flow work?"
"Where is this error coming from?"

These are behavior questions. Structure doesn't answer them.

Example: The payment bug

A payment is failing. You know the structure. You know there's a Payment Service, a Fraud Service, and a Payment Gateway.

Smart Graph shows you all three boxes. Connected by lines.

Great. Now what?

You still don't know:

Which function in Payment Service handles the checkout
What exact sequence of calls happens
Where the error is occurring
What the execution path looks like

You have the map. But you don't know the route.

The pivot:

We realized developers don't explore codebases randomly. They investigate specific behaviors.

They start with a question: "How does X work?"

Then they trace the execution path to find the answer.

Smart Graph gave them the 10,000-foot view. They needed the ground-level trace.

This is why we built Call Trace.

Call Trace answers: "What exactly happens when this function runs?"

You click a function. We show you:

Every function it calls
In what order
Under what conditions
With what branching logic

You see the actual execution path. Not just the system structure.

The frequency shift:

Smart Graph: Used once during onboarding, rarely after.

Call Trace: Used multiple times per day, every day.

Because behavior questions come up constantly:

"How does this feature work?" (Every time you touch new code)
"What does this AI-generated code do?" (Every time AI writes code)
"Where is this bug?" (Every time something breaks)
"What will this PR change?" (Every time you review code)

The honest mistake:

We thought developers needed to understand the system.

They do. But only once.

What they really need is to understand specific flows. Constantly.

We built for the one-time event. We should have built for the daily workflow.

What We Learned

1. Onboarding tools have limited retention

Useful for 1-2 weeks
Then forgotten
Low long-term value

2. Daily workflow tools have high retention

Used multiple times per day
Becomes part of debugging process
High long-term value

3. Developers care more about "how" than "what"

"What exists" is a one-time question
"How does it work" is a constant question

4. Structure is the foundation, behavior is the house

You need structure first
But you live in the behavior

The evolution:

Smart Graph is still valuable. For onboarding. For understanding large open-source projects. For getting the initial lay of the land.

But Call Trace is what you use every day. It's the tool that lives in your workflow. It's what you reach for when you have a question about how code actually executes.

The insight:

We were building for the exceptional case (onboarding) instead of the normal case (daily debugging).

We were optimizing for the first impression instead of the lasting value.

We were solving the problem people think they have (understanding structure) instead of the problem they actually have (understanding behavior).

The better question:

Not "What would help developers learn a codebase?"

But "What would help developers work with code every single day?"

The answer is behavior visibility. Execution flow. Logic traces.

Why we're sharing this:

Because it's easy to build tools that look impressive but don't stick.

It's easy to solve one-time problems and mistake them for daily needs.

It's easy to optimize for the wow moment instead of the long-term value.

We made this mistake. We learned from it.

Smart Graph was impressive. Call Trace is useful.

Impressive gets you the first week. Useful gets you every week after.

The lesson:

Build for retention, not just adoption.

Build for the daily workflow, not just the exceptional case.

Build for the problem that happens constantly, not just the problem that feels big.

We built Smart Graph because onboarding felt like a big problem.

We built Call Trace because debugging is the actual daily problem.

One was a nice-to-have. The other is a need-to-have.

Where We Are Now

Call Trace is what developers use every day. Smart Graph is what they use once.

Both have value. But only one has staying power.

We're focusing on the one that matters for the long term.

The one that answers: "How does this code actually work?"

Not: "What does this codebase contain?"

Behavior over structure. Daily workflow over onboarding. Lasting value over first impression.

That's the shift.