My Roadmap for Learning Generative AI

As I continue my MCS studies, I feel that generative AI is becoming one of the most important areas I want to understand deeply. I already have experience as a full stack developer, working with technologies like React, Laravel, Node.js, Python, and Supabase. That background has helped me understand how web applications are built from frontend to backend.

But generative AI feels like a new layer on top of traditional software development.

Before, most of my focus was on building applications that store data, process requests, display results, and solve user problems through fixed logic. Now, I am becoming more interested in applications that can understand language, generate responses, summarize documents, assist users, and make software feel more intelligent.

This blog is my personal roadmap for learning generative AI. I am writing it based on the topics I am studying and the direction I want to follow as a developer.

Starting with the Basics of Generative AI and LLMs

The first step in my roadmap is understanding what generative AI actually means.

I do not want to only use AI tools without understanding the ideas behind them. I want to know what makes a system generative, how large language models work, why they can produce human-like text, and where their limitations are.

At this stage, I want to ask simple but important questions:

What is a language model really learning?

How does it generate the next word or token?

Why does it sometimes give confident but wrong answers?

Where can generative AI be useful in real applications?

As a full stack developer, I naturally think about how these models can be connected with web systems. For example, an AI chatbot is not only a model. It also needs a frontend interface, backend APIs, user authentication, database storage, and proper error handling.

So from the beginning, I want to learn generative AI not only as a theory, but also as something I can build with.

Understanding Pretraining, Tokenization, and Embeddings

After learning the basic idea of LLMs, the next part of my roadmap is understanding pretraining, tokenization, and embeddings.

This part is important because it explains how text becomes something a machine can process.

As developers, we usually work with strings, objects, arrays, and databases. But language models do not understand words the same way humans do. Text has to be broken into smaller parts called tokens. Then those tokens are represented in a numerical form so the model can process them.

Embeddings are especially interesting to me because they connect language with meaning.

For example, in a normal search system, we may search by matching exact keywords. But with embeddings, we can search by meaning. This makes me think about smarter search features for blogs, notes, documents, or portfolio content.

Instead of only searching for exact words, an AI-powered system can understand related ideas. That can be very useful in real web applications.

Learning Transformer Architecture Step by Step

The next major part of my roadmap is understanding transformer architecture.

Transformers are important because they are the foundation behind many modern language models. At first, the architecture can look difficult because it includes concepts like attention, positional encoding, layers, and model parameters.

But I want to approach this step by step.

I do not need to understand everything perfectly in one day. My goal is to understand the main idea: how a model pays attention to different parts of input and uses context to generate better output.

This is where my MCS studies become helpful. In full stack development, I mostly focus on building working systems. But in MCS, I am learning to think more deeply about the concepts behind systems.

The transformer topic reminds me that modern AI is not magic. It is built on mathematical ideas, data, architecture, and training methods. Understanding this helps me respect the technology more and also use it more carefully.

Improving My Prompt Engineering Skills

After understanding the basics and architecture, prompt engineering becomes a practical skill.

Many people think prompt engineering is only about writing commands to AI. But I think it is more than that. It is about communicating clearly with the model.

A weak prompt gives weak output. A better prompt gives context, constraints, examples, and a clear expected result.

As a developer, this feels similar to writing good requirements. If the requirement is unclear, the output will also be unclear. The same thing happens with AI prompts.

For example, instead of asking:

“Write code for a chatbot.”

A better prompt would explain the tech stack, expected features, database structure, API behavior, user flow, and limitations.

This is why I want to practice prompt engineering properly. It can help me use AI better for coding, learning, documentation, debugging, and building user-facing features.

Understanding Chain-of-Thought and Reasoning

Another topic I want to explore is reasoning.

AI models are not only used for generating text. They are also used to solve problems, explain ideas, analyze information, and support decision-making. This makes reasoning an important part of generative AI.

The idea of chain-of-thought is interesting because it focuses on how complex problems can be broken down into smaller thinking steps.

As a student and developer, I find this useful because many programming problems also require step-by-step thinking. When debugging a bug, I do not solve everything at once. I check the frontend, then the API, then the backend logic, then the database, then the response.

Similarly, AI systems can perform better when tasks are structured properly.

This makes me think about a deeper question:

Can AI help users think better, instead of only giving them quick answers?

That question feels important to me because I do not want AI applications to make users passive. I want to build tools that help people understand, learn, and make better decisions.

Learning How to Evaluate Generative AI

One of the most important parts of my roadmap is evaluation.

In normal software development, we can test features using expected inputs and outputs. But generative AI is different. The answer may not always be exactly the same, and there can be many acceptable outputs.

This makes evaluation more challenging.

I want to learn how to evaluate generated content based on quality, accuracy, relevance, fluency, faithfulness, and usefulness. I also want to understand how to measure whether an AI system is actually helping the user.

This part is very important for real projects.

If I build an AI document assistant, how do I know the answer is correct?

If I build an AI chatbot, how do I know it is not misleading the user?

If I build a content generation tool, how do I know the result is useful and not just nice-sounding text?

These questions make me realize that building AI applications is not only about generating output. It is also about checking whether the output can be trusted.

Exploring Retrieval-Augmented Generation

Retrieval-Augmented Generation, or RAG, is one of the topics I am most excited to learn.

RAG feels practical because it connects AI with real data.

Instead of asking a model to answer only from its training knowledge, we can give it relevant information from documents, websites, databases, or other knowledge sources. Then the model can generate answers based on that retrieved information.

As a full stack developer, this immediately gives me project ideas.

I can imagine building an AI assistant for a personal website that answers questions based on my resume, projects, blogs, and experience. I can also imagine a document assistant that allows users to upload PDFs and ask questions from them.

This is where my existing skills become useful.

React can be used for the interface. Laravel or Node.js can be used for backend APIs. Python can help with AI and data processing. Supabase can help with authentication and database storage. A vector database can help with semantic search.

RAG shows me that generative AI is not separate from full stack development. It actually needs full stack development to become a complete application.

Learning Fine-Tuning, Alignment, and Reasoning

After RAG, I want to understand fine-tuning, alignment, and reasoning more deeply.

Fine-tuning is interesting because it allows a model to be adapted for a more specific task or domain. But I also want to understand when fine-tuning is actually needed and when other methods like prompting or RAG are enough.

Alignment is another important topic because AI systems should behave in a way that is useful, safe, and responsible. A model should not only produce an answer. It should produce an answer that follows the goal, respects user needs, and avoids harmful output.

Reasoning connects back to the question of how AI can solve more complex tasks.

For me, these topics are important because they move AI learning beyond basic tool usage. They help me think about how AI systems can be improved, controlled, and used responsibly.

Building Projects While Learning

I do not want this roadmap to remain only theoretical.

As I learn each topic, I want to build small projects. This is the best way for me to understand things properly.

Some projects I want to try are:

AI chatbot for my personal website

PDF question-answering assistant

Smart search for blog posts

AI resume or portfolio assistant

Prompt testing dashboard

Content generation tool for developers

RAG-based document assistant

Small AI agent that can perform simple developer tasks

These projects match my background because they combine full stack development with generative AI. They also give me a practical way to apply what I learn in MCS.

My Final Project Direction

The final part of my roadmap is building a complete AI-powered project.

I want my project to have a clear problem, real data, proper AI integration, and a usable interface. I do not want to build something only for demonstration. I want to build something that feels practical.

One project idea I like is an AI-powered personal knowledge assistant.

The idea would be simple: users can upload documents, notes, or website content, and then ask questions from that information. The system would retrieve relevant content and generate an answer based on that source.

This kind of project would help me practice many concepts together: embeddings, RAG, prompt engineering, evaluation, frontend design, backend development, database management, and responsible AI handling.

It would also connect well with my experience as a full stack developer and my current interest in generative AI.

My Learning Mindset

My roadmap for learning generative AI is not about rushing.

I know this field is large, and it changes very fast. There are many tools, models, frameworks, and research ideas coming out all the time. It is easy to feel overwhelmed.

But I want to learn step by step.

First, I want to understand the basics. Then I want to understand how models process language. After that, I want to learn transformers, prompting, reasoning, evaluation, RAG, fine-tuning, and alignment. Finally, I want to connect everything through real projects.

As an MCS student, I want to build a strong foundation. As a full stack developer, I want to apply that foundation in real applications.

For me, generative AI is not just another technology trend. It is a new direction in software development.

I started my journey by learning how to build web applications. Now, I want to learn how to make those applications more intelligent, more helpful, and more meaningful for users.

This roadmap is only the beginning, but it gives me a clear direction for where I want to go next.