Generative AI: What I Learned as a Beginner (And How It Works)

Habeeb Mohsin — Sat, 22 Aug 2026 15:25:04 +0000

When I first heard about Generative AI, I was a bit confused – I’m just a college student learning this stuff! But I quickly found out that generative AI simply means AI that creates new content. In other words, instead of just analyzing or classifying data like older AI, it can write text, draw images, compose music, and even write code. That’s why it’s called generative. For example, ChatGPT (from OpenAI) can write essays, a model like DALL·E can generate images from descriptions, and tools like GitHub Copilot can generate code snippets. All these are generative AI at work. I learned that this wasn’t a niche thing – recently, tools like ChatGPT, Google’s Gemini, and Anthropic’s Claude became huge news. These models (called LLMs – Large Language Models) became household names and made AI super popular practically overnight.

To break it down: generative AI can create different kinds of content. Some examples are:

Text generation: writing essays, emails, stories or chatting (like ChatGPT).
Image generation: drawing pictures or art from text prompts (like DALL·E or Stable Diffusion).
Code generation: writing computer code (like GitHub Copilot).
Audio generation: composing music or converting text to realistic speech.
Video generation: creating short video clips or animations (still an emerging field).

Old-school AI/ML usually predicted or classified things. For example, a traditional AI might sort emails into “spam” or “inbox.” But generative AI goes further: it actually creates new stuff. As one source puts it, “Traditional AI is mostly predictive or classifying… Generative AI creates something new, like drafting the email itself”. It’s the difference between an AI that labels a picture “cat” (traditional) and one that draws a new cat picture from scratch (generative). In simple terms, generative AI generates new content instead of just sorting existing content.

It became popular because models got so good and easy to use. The launch of ChatGPT (GPT stands for Generative Pre-trained Transformer) in late 2022 showed people how powerful and user-friendly it could be. Big companies poured resources into it, and now we have many such tools. So these days, everyone’s talking about generative AI – me included!

How Generative AI Actually Works

Learning how it actually works was like a lightbulb moment. At a high level, I realized that generative AI models (like GPT) are basically neural networks trained on huge amounts of data to learn patterns in text and other media. During training, the model sees billions of words, images, or code, and learns to predict what comes next. In plain terms, it’s a big guessing machine: given a bunch of examples, it learns the probabilities of words or pixels following each other.

One key idea is tokens. All the input text is broken down into smaller units called tokens. A token might be a whole word or even just part of a word. The model then converts each token into a numerical embedding (a vector of numbers) that captures its meaning. Think of an embedding like coordinates on a map: words or concepts with similar meaning end up in nearby spots. For example, “dog” and “puppy” would get similar vectors.

The magic happens inside a transformer neural network. I learned that transformers use an attention mechanism to decide which parts of the input are most relevant for generating each next token. The famous “Attention is All You Need” paper (2017) introduced this idea, and it’s now the backbone of LLMs. In simple terms, attention lets the model focus on the right words when producing an answer, even if they’re far apart in the text. This is what makes modern LLMs so good at handling long passages of text.

After all the training, the model is ready to generate content. Here’s roughly what happens when you ask it a question or give it a prompt:

You send a prompt (like a question or command).
The model tokenizes the prompt and converts tokens to embeddings.
The transformer processes this input using its learned weights and attention.
The model predicts one token at a time, picking the most likely next word (or piece of text) based on what it learned during training.
It repeats this token-by-token until it completes the response.

So it’s basically a loop: predict one word, add it to the prompt, predict the next, and so on. The AI doesn’t have a fixed answer in mind from the start; it really makes it up on the fly using the patterns it learned. As IBM notes, “the model does not ‘know’ the final answer in advance; it uses all the statistical relationships it learned in training to predict one token at a time”. In other words, each word is its best guess at that moment.

To visualize this flow:

flowchart LR
    A[User Prompt] --> B[AI Model]
    B --> C[Process Input (Neural Network)]
    C --> D[Generate Response Token-by-Token]

So, for example, if I type “Explain your favorite movie in one paragraph,” the prompt goes into the model, it processes it, and then outputs a paragraph word by word. That’s how the answer is generated.

Concepts I Came Across While Learning GenAI

As I studied more, I kept stumbling on certain terms. Here’s what they mean, in simple words:

Prompt Engineering: This is basically writing good prompts for the AI. It’s not a new piece of software – it’s about phrasing your instructions well. For example, saying “Explain quantum physics to a friend” instead of just “quantum physics.” A good prompt can make a big difference. In fact, IBM says prompt engineering is “the easiest and fastest way to get domain-specific knowledge” from a model without extra training. It’s useful when you want a quick tweak in the answer. Example: Adding “like you’re talking to a 5th grader” in the prompt will guide the style of the response.
Embeddings: These are the numeric vectors I mentioned. Each token or piece of text is turned into a list of numbers (an embedding) that represents its meaning. Embeddings let the AI compare and combine meanings mathematically. For instance, in the model’s “mind,” the embeddings for “dog” and “puppy” are close together. This allows the model (and tools built around it) to find semantically similar text.
Vector Database: This is a special kind of database that stores embeddings. Instead of searching by keywords, it finds things by semantic similarity. Essentially, you feed it embeddings of documents or text chunks, and it lets you query by finding which vectors are nearest to a query vector. For example, if I embed all pages of a PDF of my lecture notes and then ask a question, the vector DB can find the part of the notes whose embeddings are most similar to my question’s embedding.
RAG (Retrieval-Augmented Generation): This term came up a lot. RAG is when you combine a knowledge search with the AI model. Instead of relying only on the model’s memory (training), you retrieve relevant info from an external source and feed it to the model as context. For example, imagine you upload a PDF of your course notes and then ask a question. A RAG system would (1) search the PDF for relevant passages, and (2) send those passages along with your question to the LLM so it can answer based on them. IBM describes RAG as an architecture that “connects a language model to external knowledge sources” so it can incorporate that context. This helps a lot with accuracy: it addresses issues like the model’s knowledge cutoff or hallucinations because you’re grounding the answer in real data. A practical example I saw was a Streamlit app where users upload PDFs and ask questions; the system uses RAG to find precise answers from the document.
Fine-tuning: This is actually training the model further on specific data. After the initial large-scale training, fine-tuning adjusts the model’s weights using a smaller, specialized dataset. In simple terms, it teaches the model to focus on a particular domain or style. For example, you could fine-tune a general model on legal documents so it becomes better at legal Q&A. IBM explains it succinctly: “After training … LLMs can be fine-tuned to make them more useful in certain contexts”. Fine-tuning is great if you need a customized model for a specific task (like a medical chatbot), but it requires some programming and data.

These three approaches—prompting, RAG, and fine-tuning—can be compared:

Approach	How it works	When to use it
Prompting	Just change how you ask the model (no extra training). You give clear instructions or examples in your prompt.	Quick tests or when you need different answers on the fly.
RAG	Search a document/database for relevant info and feed it to the model. It “retrieves” context to augment the prompt.	When you need accurate answers from specific texts (e.g. PDFs, internal docs).
Fine-tuning	Train the model more on domain-specific data.	When you want a dedicated model for a task and have the data to train.

Each has its place. As I learned, for many student projects, prompting and RAG are easiest to start with, while fine-tuning is more advanced.

Building My First GenAI Application

After learning the theory, I wanted to build something myself. Here’s what a beginner might need:

Python: Most AI libraries and APIs are Python-based. I used Python because many tutorials do, and it has huge community support.
LLM API: Services like OpenAI (ChatGPT/GPT) or Hugging Face provide APIs. For example, OpenAI’s ChatCompletion API lets you send prompts and get answers. These free tutorials guided me to sign up for an API key (often free tier available).
Hugging Face: A platform with many pre-trained models and the transformers library. If you don’t want to use OpenAI’s cloud, you can load open-source models locally from Hugging Face. They also have courses for beginners.
LangChain: A Python framework that simplifies building LLM apps. It helps link together prompts, chains of tasks, embeddings, and retrieval. GeeksforGeeks points out that LangChain “simplifies the integration of language models into real-world applications”. I learned that LangChain has components like document loaders and vector stores ready-made.
LlamaIndex (GPT Index): Another library for building RAG/Q&A apps. It handles chunking documents and querying them. I found it mentioned in several blog posts as a beginner-friendly tool.
Vector Database: If doing RAG, you might use a vector DB service (like Pinecone, ChromaDB, Weaviate). Even a local solution like FAISS can store embeddings.
Streamlit: An easy way to make a simple web app in Python. Tutorials often use Streamlit to build front-ends where users can type prompts or upload files.

The overall flow of a basic GenAI app (no RAG) is:

User → (Python App / UI) → LLM (model API) → Generated Response

With RAG, we add a retrieval step:

User → (App/UI) → [Search Knowledge Base] → LLM → Response

For instance, if I built a PDF Q&A tool: the flow would be the user asks a question, the app queries the vector DB of embedded PDF chunks to fetch relevant text, then sends the question plus that text to the LLM to answer.

Here’s a simple Python example using the OpenAI library to call an LLM:

import openai
openai.api_key = "YOUR_API_KEY_HERE"

# Call the ChatGPT (gpt-3.5-turbo) model
response = openai.ChatCompletion.create(
    model="gpt-3.5-turbo",
    messages=[
        {"role": "system", "content": "You are a helpful assistant."},
        {"role": "user", "content": "Hello, how does generative AI work?"}
    ]
)

answer = response.choices[0].message.content
print(answer)

I used openai in Python, gave it a system instruction and a user message, and it returned the assistant’s reply. It’s that simple! The code sends a prompt to the model and prints out the generated answer.

Another quick example uses Hugging Face’s pipeline for text generation (no API key needed for small models):

from transformers import pipeline
generator = pipeline('text-generation', model='gpt2')  # GPT-2 is smaller
output = generator("Hello, my name is", max_length=50)
print(output[0]['generated_text'])

This code loads a GPT-2 model locally and generates text continuation. It shows how you can do generative AI purely in Python. For a real app, you’d parse the output and display it to users.

So, the beginner architecture looks like:

flowchart LR
    A[User] --> B[Application (Python)]
    B --> C[Retrieve Knowledge (optional RAG)]
    C --> D[LLM Model]
    D --> E[Response to User]

In code, if RAG is added, you might do something like:

Embed user query and search vector DB.
Fetch top chunks of text.
Include those chunks in the prompt to the LLM.
Call the LLM API with that augmented prompt.

(Handling those details is a bit advanced, but libraries like LangChain/LlamaIndex help automate it.)

What I Learned, What Can Go Wrong, and What Students Can Build

The Good and The Bad: Generative AI is amazingly powerful, but it has flaws. I learned that hallucinations are a real thing: the model can produce answers that sound confident but are completely made up. For example, it might invent a fake source or facts. It can also unintentionally reflect biases from its training data (as IBM warns, “LLMs can also reflect and amplify biases”). Another issue is the knowledge cutoff: most models only know up to a certain date. For instance, one LLM might only know information up to 2021, so it’s clueless about anything after that. This means if you ask about the latest news or technology, it might guess or just say “I don’t know.” In practice, I found it’s crucial to double-check AI outputs. As one source explains, generated content is “fluent by design but not factual by default”. In other words, the AI writes well, but its facts need verification.

There are also practical concerns: privacy (never feed secret personal data into a public model!), and security (someone might try “prompt injection” to get an AI to reveal something it shouldn’t). The key I learned is to always treat AI answers as helpful suggestions, not gospel truth. Verify important info, and use tools (like RAG or citations) to ground the answers.

Student Projects: To get hands-on, I thought up a bunch of beginner-friendly projects. Here are some ideas and what you’d learn from each:

AI Chatbot: Build a chat interface (maybe on Streamlit) that lets you have a conversation with an LLM. What you learn: Basic API calls, handling conversational context, crafting prompts for follow-up questions. (LLMs are great for chatbots and Q&A.)
PDF Q&A Bot: Let users upload a PDF (like lecture notes), then ask questions about it. Use embeddings + a vector DB to retrieve relevant passages (RAG), and answer based on them. What you learn: Document processing, embeddings, vector search, RAG pipelines, and combining search results into the model’s prompt.
AI Study Assistant: Create something that summarizes notes or generates quiz questions. For example, feed it a textbook chapter and ask it to list key points. What you learn: Text summarization techniques, prompt design for educational content, and maybe simple fine-tuning if you add your own summarization examples.
Resume Analyzer: Upload your resume text and have the AI suggest improvements or format it. What you learn: Practical NLP on structured text, designing prompts for critique, using the model for rewriting content, and handling user-uploaded text.
College FAQ Chatbot: Populate a database of common college questions (admissions, campus info) and use RAG to answer them. What you learn: Building a knowledge base, searching that base with vectors, and answering community-style questions.
AI Research Assistant: A bot that can fetch and summarize information on academic topics. (Maybe link it to Wikipedia or an open dataset.) What you learn: Researching with LLMs, summarizing articles, prompt chaining for step-by-step queries.
Coding Assistant: Ask the AI to explain code snippets or help write simple code. What you learn: Generative AI for code generation (as in code completion or examples), and verifying code correctness. It’s cool to see an LLM generate a function when you describe what it should do.

Each project teaches something new: handling LLMs in different ways, designing prompts, managing data, etc. These ideas are based on known use-cases for LLMs (e.g. drafting text, summarization, chatbots, and coding). Starting with any of these will solidify your understanding and give you a tangible portfolio piece.

My Beginner Roadmap for Learning GenAI

Putting it all together, here’s the step-by-step path I followed (and advice I’d give):

Python & Basics: Make sure you’re comfortable with Python, since most examples and libraries use it.
Machine Learning Foundations: Review basic ML concepts (like regression, classification). Understand how neural networks learn. GeeksforGeeks notes that a solid foundation in data science and ML is important before diving into GenAI.
Deep Learning & Transformers: Learn how neural networks work, then specifically study transformers. Knowing that transformers (with attention) power GPT and BERT models helped me a lot.
Experiment with LLMs: Use Hugging Face tutorials or OpenAI’s playground. Get a feel for what LLMs can do by playing with prompts. Learn what tokens and embeddings are (many tutorials explain them).
Prompt Engineering: Practice writing different kinds of prompts. Try variations to see how the output changes. Remember, prompt design is a skill.
APIs & Frameworks: Learn to call LLMs from code. Try OpenAI’s Python library or Hugging Face’s pipelines. Next, explore frameworks like LangChain or LlamaIndex – they simplify building apps. For instance, LangChain helps you chain prompts and manage conversation flow.
RAG & Vector Databases: Learn about embeddings and setting up a vector DB (even a simple local one). Practice retrieving relevant info for a prompt. There are many examples online for “semantic search” or “RAG PDF bot”.
Build Projects: Start a small project (like one of the ideas above). Learn by doing. Don’t just watch videos – code along. It’s okay if the first tries are simple or messy.
Read Documentation & Share: Get into the habit of reading official docs (OpenAI, Hugging Face). Post your code on GitHub and maybe write a quick blog or README. Explaining your project (even to your future self) deepens your understanding.
Iterate and Learn: Pick the next tool or concept and integrate it. Maybe try fine-tuning on a small dataset, or deploy your app as a web service. But go step by step; you don’t need to master everything at once.

Throughout, I tried to remember: curiosity beats expertise at the start. I didn’t worry about knowing all math behind transformers. Instead, I focused on what they do and how to use them. As one source says, in practice we often use techniques like prompt engineering rather than deeply re-training models. My biggest tip: build while you learn. Start with tiny projects, make mistakes, read up on the parts you get stuck on, and keep iterating.