machine-learning ai-agents langchain learning

From Andrew Ng to Building My Own AI Agent: A Learning Journey

Every software engineer hits a point where they want to understand AI beyond just calling an API. This is the story of how I went from Andrew Ng’s Machine Learning course on Coursera to building my own agentic AI framework from scratch.

The Foundation: Andrew Ng’s ML Course

I started with Andrew Ng’s classic Machine Learning course on Coursera. If you haven’t taken it — it’s the gold standard for building intuition.

The course covers:

  • Linear & Logistic Regression — the statistical backbone of prediction
  • Neural Networks — forward prop, backprop, the math behind the magic
  • SVMs, Clustering, PCA — the classical ML toolkit
  • Bias/Variance, Regularization — why models fail and how to fix them

What I loved most was the focus on intuition over math porn. You understand why gradient descent works before you touch a single derivative.

The assignments were in Octave/MATLAB, which felt dated at first, but honestly — working in a low-level environment forced me to implement matrix operations by hand. No sklearn.linear_model.LinearRegression magic. You build it.

Practical ML: My Research Repo

During and after the course, I started logging experiments in my ml-research repo. It’s not polished — it’s a messy collection of Jupyter notebooks where I tried things, broke things, and slowly built intuition.

The most valuable part? Writing models from scratch before using frameworks. Implementing a neural net with nothing but NumPy teaches you more than a week of fastai tutorials.

Then Came LLMs

After classical ML, I hit the LLM wall. Suddenly everything was “prompts” and “agents” and “chains.” I knew:

  • Transformers existed
  • Attention is all you need
  • GPT models were massive

But LangChain felt like magic. Too much magic.

I’d call chain.invoke() and get an answer, but I had no idea what actually happened. Was it calling the LLM once? Five times? What was the prompt template doing? Where was the state?

Building nova-ai: Learning by Doing

That’s when I started nova-ai. The rule was simple: no frameworks. Pure Python. Understand everything.

What I Built

The repo is an agentic AI framework that implements:

  1. LLM Tool Calling — parsing function schemas, sending them to the model, interpreting the response, executing tools, feeding results back. The core loop.

  2. Reasoning Loops — the agent doesn’t just answer once. It thinks, acts, observes, and iterates. I implemented ReAct-style reasoning manually to understand prompt construction around tool use.

  3. State Management — conversations have context, tools have results, agents have history. Managing this without LangChain’s built-in memory classes taught me exactly what abstractions are useful and which ones are bloat.

What I Learned

LangChain makes sense now. After re-implementing the core patterns: Chain, Tool, Agent, Memory — I understand exactly why those abstractions exist and when to use them.

LangGraph clicked. Graph-based state machines for agent workflows became obvious once I’d built a linear agent and hit its limitations. Branching, looping, parallel tool calls — you need a graph.

The agentic loop is simple in concept, hard in practice:

User Input → LLM thinks → decides tool → calls tool → observes result → LLM thinks again → responds

The complexity is in the edges: error handling, retries, token limits, context window management, and making the LLM actually use the right tool at the right time.

Where I Am Now

I’m comfortable with the full stack now:

  • Classical ML fundamentals (thanks, Andrew)
  • LLM prompting and function calling
  • Agent architectures (ReAct, plan-and-execute, multi-agent)
  • When to use LangChain/LangGraph vs raw Python

My current focus with Hermes Agent builds on all of this — multi-agent orchestration, skill systems, and tool execution at scale.

Advice for Engineers Starting Their AI Journey

  1. Start with Andrew Ng’s course. It’s free, it’s thorough, and the intuition sticks.
  2. Build one thing from scratch. Implement a simple RAG pipeline without LangChain. Build an agent loop without a framework. You’ll understand the tools 10x better afterward.
  3. Read source code. LangChain’s source is surprisingly readable. So is Hermes’. Reading real production agent code teaches you things no tutorial will.
  4. Ship something. Even if it’s a broken Jupyter notebook. The learning happens when you hit errors, not when things work perfectly.

The field moves fast. But the fundamentals don’t change.

← Back to blog