From Eclipse CDT to Zed + clangd — The Exploratory Engineer in Me Is Still Alive...

I recently started moving from Eclipse CDT to Zed + clangd for my C++ development.

On the surface, it is just an IDE change.

For me, it is something more.

Eclipse CDT has been a trusted companion for years. Projects, indexing, debugging, builds, refactoring—everything became familiar. And that familiarity is comfortable.

But there is a danger in becoming too comfortable with the tools.

Suddenly, things that had become invisible are interesting again.

Look at the image, which is clangd's compile_commands.json.

clangd needs to know this information.

Which compiler?

Which C++ standard?

Which include directories?

Which preprocessor definitions?

Which compilation flags?

Once I started looking at it this way, clangd stopped feeling like some mysterious IDE feature.

It became what it really is:

a tool that needs an accurate model of how the compiler sees the source code.

That shift in perspective makes troubleshooting much easier.

How does clangd understand my project?
What exactly does CMake generate?
How does the debugger interact with my program?
How much of an IDE do I actually need?

These are not merely editor questions. They are engineering questions.

And perhaps that is what I enjoy most.

As engineers gain experience, there is a risk of becoming operators of familiar systems rather than explorers of new ones.

I don't want that.

The move from Eclipse to Zed is therefore not really about:

Eclipse → Zed + clangd

It is about:

Routine → Exploration

Familiarity → Curiosity

"This is how I always do it" → "What happens if I try this?"

Why This Experiment Is Interesting to Me

I have always enjoyed understanding what happens underneath the abstraction.

That is probably why I keep moving between areas such as:

• C++
• Java
• Python
• Linux
• OpenGL
• CUDA
• OpenFOAM
• ParaView
• Julia
• Blender
• numerical simulation
• computer graphics
• design patterns

There is a common thread running through all of them.

I don't just want to use the software.

I want to understand how the machinery works.

Moving from Eclipse CDT to Zed + clangd is another small expression of the same instinct.

The editor itself becomes less important.

The interesting part is understanding the ecosystem around it.

The tools will keep changing—C++, compilers, build systems, editors, AI, GPUs, simulation frameworks.

The important thing is to keep experimenting.

Because after years of programming, discovering a new tool is nice.

But discovering that the explorative engineer inside me is still alive—and thriving is much better.