Ai Agent Development, The Journey So Far

Stepping into AI agent development has been both exciting and humbling. One thing I quickly realized is that this journey isn’t for everyone—it strongly favors software engineers, especially those with a backend mindset.

As a Django backend developer, I decided to document my progress openly, learning in public while building a solid foundation for creating production-ready AI agents. Here’s a breakdown of what I’ve learned so far—from Day 1 to Day 9.

Setting the foundation

AI agents don’t live in isolation; they interact through APIs, process requests, manage state, and communicate over the web. Because of this, I had to refresh and deepen my understanding of:

• FastAPI (its structure and best practices)

• HTTP fundamentals

• REST API protocols

• Git & version control

Revisiting these concepts reminded me that strong fundamentals are non-negotiable when building intelligent systems. Have to admit though, there are a lot to learn when it comes to http fundamentals, REST API protocols and git & version control. I was sounding like an ambulance(wow, wow and I havent used this before or oh wow, this should have help me when dealing with this/that feature on this/that project) throughout day 1 studies.

Terminal and Mastering Automations

We often underestimated the power of learning automations. For AI agent development, the terminal becomes a powerful control center. This includes:

• Writing helper scripts

• Process management

• Log analysis

• Automation for production-ready agent operations

The command line has a vast ecosystem of commands, and mastery only comes with consistent use. The more you use it, the more efficient you become.

One key takeaway:

The CLI is faster, more flexible, and makes automation and repetitive tasks significantly easier.

REST APIs for AI Agents

On Day 3, I dove deeper into REST API concepts specifically for AI agents, covering:

• Authentication types

• Rate limiting

• Error handling

• Testing and debugging APIs

Protecting agent endpoints is critical. Without proper safeguards, you risk overuse, unauthorized access, and poor user experience.

I also learned the importance of:

• Designing clean and readable endpoints

• Writing APIs that are well-documented and intuitive

Good APIs make agents easier to use, maintain, and scale.

LLM Fundamentals & Streaming Responses

Day 4 introduced me to the fundamentals of Large Language Models (LLMs) and how they communicate. One interesting concept was the difference between:

• Streaming responses (responses sent as they’re generated)

• Unstreamed responses (waiting until the full response is ready)

This made me appreciate why earlier lessons were so important. Some best practices I explored for streaming include:

• Buffer implementation

• Error recovery

• Monitoring

• Testing strategies

Model Selection & Reasoning

I explored model selection and reasoning, comparing:

• Standard response models

• Deep reasoning models

Before this, I often defaulted to a model without considering whether it truly fit the task. That mindset has changed. Key factors to consider when choosing a model: Cost, Task complexity, Deliverability, Performance requirements. Choosing the right model can make or break an AI agent.

Fine-Tuning vs Prompt Engineering

I explored fine-tuning and prompt engineering—two powerful but very different approaches.

Fine-Tuning

• Training a pre-trained model on domain-specific data

• Best for large-scale production and specialized outputs

• Time-consuming due to training requirements

Prompt Engineering

• Crafting effective prompts to guide model outputs

• Great for experimentation and general-purpose use

• Fast to implement, but less controlled than fine-tuning

Both have their place; knowing when to use each is key.

Understanding Embeddings

Have you ever wondered how ChatGPT can rephrase text so accurately?

Day 7 answered that question: embeddings.

Embeddings are numerical representations of text that capture semantic meaning, not just words. They allow AI systems to understand context and similarity.

Some real-world use cases include:

• Document search

• Content recommendation

• FAQ matching

• Code search

• Academic research discovery

This concept unlocked a new way of thinking about AI intelligence for me.

Vector Databases

I started exploring vector databases, and it was honestly mind-blowing.

Vector databases power:

• Semantic search

• Long-term memory

• Context retrieval

• Retrieval-Augmented Generation (RAG)

Instead of keyword matching, they help AI agents understand meaning, enabling smarter and more relevant responses.

Learning how embeddings, similarity search, and RAG work together changed how I think about building scalable AI systems.

Retrieval-Augmented Generation (RAG)

Day 9 tied everything together with RAG (Retrieval-Augmented Generation).

Initially, I thought fine-tuning was the ultimate solution—but RAG offers something different.

• Fine-tuning: Static, domain-specific, can become outdated

• RAG: Dynamic, retrieves up-to-date information from external sources

RAG Workflow:

Knowledge Base → Retrieval System → Augmentation → Generation

This approach makes AI agents more accurate, current, and context-aware.

My final thought:

This journey has reinforced one key lesson:
AI agent development is built on strong fundamentals, thoughtful design, and continuous learning.

From APIs and terminals to embeddings and vector databases, every layer matters when building agents that work reliably in real-world systems.

I’m still learning but I’m building, experimenting, and sharing every step of the way.

#BozomaLabs #AIAgents #LearnInPublic #AIEngineering