How I Accidentally Learned LangChain and LangGraph

Like many engineers lately, I told myself:

"I'll spend a weekend learning AI."

Several weeks later, I was drawing state diagrams and reading agent execution traces at midnight. So naturally, everything was going according to plan.

It Started With Curiosity

I've been building software for years, and recently I found myself increasingly interested in AI—not the demos, but the engineering challenges around it. The demos are easy. The moment you try putting AI into an actual application, things get interesting. Suddenly you're asking questions like:

• How do I know the model did the right thing?
• What happens when a tool call fails?
• How many retries is too many retries?
• Why did the agent decide to do that?

The last question became surprisingly common.

My First Impression of LangChain

LangChain was my entry point.

At first, it felt like exactly what I wanted.

Need a model?

Done.

Need retrieval?

Done.

Need tools?

Done.

Need an agent that can use those tools?

Also done.

It felt like someone had already solved all the annoying plumbing work.

As someone who enjoys building products more than wiring SDKs together, I appreciated that.

I was able to get prototypes running quickly.

Dangerously quickly.

The kind of quickly that makes you think you understand a system before you've actually understood it.

The "Wait, What Is It Doing?" Phase

Everything was fine until I started building more complex workflows.

That's when I entered what I now call the:

"Wait, what is it doing?" phase.

The agent worked.

Mostly.

The problem was that I couldn't always explain why it worked.

Or why it didn't.

Or why it suddenly decided that calling the same tool three times was a great idea.

The more autonomy I gave the system, the more I wanted visibility into its decisions.

That's when I realized something important:

AI doesn't eliminate software engineering. It creates more opportunities to need it.

Discovering LangGraph

Then I found LangGraph.

My first reaction was:

"Why are people drawing graphs for LLM applications?"

My second reaction was:

"Oh. That's why."

LangGraph felt less like AI magic and more like building a real system.

States.

Transitions.

Control flow.

Decision points.

Things software engineers have been dealing with forever.

For the first time, I could look at an agent workflow and understand exactly where it was supposed to go, where it actually went, and where things started becoming creative.

That's a surprisingly valuable feature.

The Most Important Lesson

The biggest lesson wasn't about LangChain.

It wasn't about LangGraph either.

It was about AI applications.

When you're new to AI, prompts seem like the most important thing.

After building a few real workflows, prompts become one of many concerns.

The hard parts are usually:

• Observability
• Evaluation
• State management
• Error handling
• User trust
• Guardrails
• Knowing when not to use AI

The model is just one component.

A very impressive component.

A very expensive component.

A very confident component.

But still just a component.

Things AI Has Taught Me

One unexpected benefit of working with AI systems is that they expose bad assumptions quickly.

Computers traditionally do exactly what you tell them to do.

AI does something slightly more exciting:

It does what it thinks you meant.

Sometimes that's helpful.

Sometimes that's a production incident waiting to happen.

Either way, it forces you to be explicit about requirements, expectations, and success criteria.

Which, in hindsight, are things we should probably be doing anyway.

Where I Am Now

I'm still learning. That's part of what makes this space interesting. These days I reach for LangChain when I want to move quickly. I reach for LangGraph when I need something I can reason about six months from now. And increasingly, I find myself thinking less about models and more about systems.

Because the longer I spend building with AI, the more I arrive at a slightly boring conclusion:

Good engineering still matters.

The tools changed.

The fundamentals didn't.

Unfortunately, debugging remains undefeated.