learning AI from the ground up

Kunal Kokate

Database developer, always working on something.
This page is where I keep track of it.

LinkedIn GitHub
// current focus

Now

Narrowing down to a couple of things instead of spreading across everything. What's actually getting my time this month.

last edited 10/4/2026
🤖

AI Main Focus

Digging into how AI/ML actually works under the hood, not just using the tools. This is where most of my time outside work is going right now.

💼

Career

Database Developer at Argo Group, working in Snowflake.

🧊

Certs & Courses

Working through the dbt Fundamentals course. SnowPro Core and the Claude Certified Architect cert are on hold for now while I focus on AI.

// in progress

Building

Projects I'm actively working on or planning. Click to expand.

This Website Live

A public "now page" style site, hosted free on GitHub Pages, pointed at my own domain. Built to track what I'm actually doing instead of just listing a resume.

HTML/CSS/JSGitHub Pages
dbt Fundamentals Certification In Progress

Working through the dbt Fundamentals course now, heading toward the certification.

SnowPro Core Certification On Hold

Want to get the current COF-C03 exam done eventually — architecture, warehouse management, data loading, and the newer Cortex AI / Dynamic Tables topics. Paused for now while I focus on AI.

Claude Certified Architect – Foundations On Hold

Want to get certified on building with Claude eventually. Paused for now while I focus on AI.

Scroll-Blocker iOS App Planning

An app to block Reels/Shorts-style infinite scroll while keeping messaging apps fully usable.

Travel Tracker App Planning

An app to track which countries and cities I've actually been to. Still just an idea at this point.

Circuits & Electronics (Elegoo UNO R3) On Hold

Was messing around with basic circuits on an Elegoo UNO R3 kit. On hold for now while I focus on AI.

Energy Drink Tier List Planning

A completely unserious, very serious ranking of every energy drink I've tried. Yes, this needs its own tier list.

// where this is going

Goals

Things I'm working toward, not all with deadlines. Trying to keep this to a short list instead of everything at once.

Build something with AIMain focus right now — still figuring out exactly what
Ship at least one personal app end to endScroll-blocker or the travel tracker, whichever comes first
Pass the SnowPro Core certificationOn hold while I focus on AI
Learn guitarOn hold while I focus on AI
Build more with circuits and electronicsOn hold while I focus on AI
// skills

Stats

What I'm actually learning right now, honestly leveled. Click a line for detail.

kunal@kokate: ~/skills
$ ./skill_matrix --scan
scanning... done.
 
 
// synced 10/04/2026 — run again anytime
// the plan

AI Roadmap

Written assuming zero prior knowledge — no programming, no AI, nothing. Three things it's building toward: use AI for real at work, train something that can beat a game, and eventually build a whole simulated world of agents — like a city of cars where some drive normally, some break the rules, and cops react to it. Click a phase to expand it.

Foundation AI Engineering — using models, at work & on my own ML / RL — training something to beat a game
0
Learn to code, from zero Foundation

Before any of this makes sense, I need to be able to write and run basic code. Python is the language almost everything in AI is built with, so that's the one to start on — no coding background assumed, starting from "what is a program."

Install Python and run a program from the terminal (the text-based window where you type commands instead of clicking)
Get comfortable with a code editor (VS Code is the standard, free one)
Understand variables (named storage for a value), loops (repeat an action), and if/else logic (branching based on a condition) — the core building blocks of any program
Write a few tiny throwaway programs just to get the feel of it — a calculator, a number-guessing game
// CS50P — Harvard's free intro to Python, built for true beginners · freeCodeCamp's "Python for Beginners"
1
Python for real Foundation

Move from "I can follow a tutorial" to "I can build something of my own." Everything after this assumes this level of comfort.

Functions (named, reusable chunks of code) and classes (templates for bundling related data and behavior together)
Reading and writing files from code, without looking up the syntax every time
What an API is (one program asking another program, usually over the internet, for data or an action) and what JSON is (the plain-text format those answers usually come back in)
Git (a tool that tracks changes to code over time) and GitHub (where code gets stored and shared) beyond just this site
// Automate the Boring Stuff with Python — free online, very practical
2
How AI models actually work Foundation

The plain-English version of what's actually happening under the hood — enough to not just be guessing at API calls. No math required at this stage.

Tokens — the small chunks of text (roughly pieces of words) a model actually reads and writes
Context window — how much text the model can "see" and remember at once in a conversation
Embeddings — a way of turning text into a list of numbers so a computer can compare meaning, not just exact words
The difference between training a model (teaching it, done once, by a company like Anthropic) and inference (just asking it something, which is what using it means)
// 3Blue1Brown's neural network video series · Karpathy's "Intro to Large Language Models" talk — both free on YouTube, no background assumed
3
Build with the API AI Engineering

Move past the chat window — calling a model directly from code is a different skill than chatting with one, and it's the one that actually transfers to work.

Call the Claude or OpenAI API directly from a Python script and print out what it says back
Understand system prompts (instructions that set the model's behavior before the conversation starts) and getting the model to reply in a structured format like JSON instead of free text
Function calling / tool use — letting the model ask your code to do something for it, like look up a number, instead of guessing
Build: a small command-line tool that does one real task start to finish
// Anthropic API docs · DeepLearning.AI short courses — free, beginner-friendly
4
Retrieval-augmented generation (RAG) AI Engineering

Hooking a model up to real, specific data instead of just what it memorized during training. This plays directly to the SQL/data background.

Understand vector search — searching by meaning instead of exact keywords, using those "embedding" numbers from Phase 2
Set up a vector database (a database built specifically to store and search those embeddings) — Chroma is the easiest one to start with
Build: a tool that answers questions grounded in my own notes or documents, not just the model's general knowledge
// Chroma quickstart · LlamaIndex docs
5
Agents, applied at work AI Engineering

An "agent" is just a model that can take more than one step on its own — plan, use a tool, check its own work, repeat. Where this is supposed to actually land: something useful in the Snowflake/data world I already work in.

Build a simple agent that plans a few steps, calls a tool, and checks its own output before finishing
Build: a tool that turns a plain-English question into a SQL query against real Snowflake data
Ship something small for actual use, even if it's just for me at first
// Anthropic's agent-building guide · LangGraph docs
6
ML fundamentals ML / RL

Where the game-playing goal branches off from the work-facing track — this is about training a model myself, not calling one someone else trained. Some basic math shows up here (just enough algebra and stats to follow what's happening, nothing heavy).

Loss — a single number that says how wrong a model's guess was — and gradient descent, the method used to nudge the model to be a little less wrong, over and over
Comfortable with NumPy and pandas (Python libraries for working with numbers and tables of data efficiently)
Build a model from scratch — starting with linear regression (fitting a line to data), then a small neural network
// fast.ai "Practical Deep Learning" · Karpathy's "Neural Networks: Zero to Hero" — both start from first principles
7
Reinforcement learning basics ML / RL

The actual field "train an AI to beat a game" belongs to — a different branch of ML from the language-model stuff above.

The core vocabulary: the agent (the thing making decisions), the environment (the game or world it acts in), the reward (the score it's trying to maximize), and its policy (its strategy for picking actions)
Implement Q-learning (one of the simplest training methods) by hand on something tiny, like the FrozenLake grid-walking game
Get comfortable with Gymnasium — the standard toolkit that gives you game-like environments to train agents in
// Hugging Face's free Deep RL course — built for this exact on-ramp · Gymnasium docs
8
Beat an actual game ML / RL

The goal. Start small and work up — nobody trains an agent to beat a hard game on the first try, the simple ones teach the real lessons.

Train a DQN agent (a straightforward, well-documented method) on something simple — CartPole (balance a pole) first, then a basic Atari game
Move up to PPO (a more modern, stable training method), using a ready-made library called Stable-Baselines3 instead of writing it from scratch
Pick one real game I actually care about and make that the real target
// Stable-Baselines3 docs · CleanRL reference implementations
9
Build a living world (traffic sim) ML / RL

The real stretch goal: not one agent beating one game, but a whole simulated world running at once — cars driving endless roads, most of them behaving, some of them not, and cops reacting to the ones that don't. This is "multi-agent" — lots of independent agents in the same world instead of just one — and it's genuinely harder than anything above, so it comes last and leans on everything before it.

Build the world itself first, with no AI at all — roads, intersections, and cars that just follow a fixed path, in a simple 2D engine like Pygame
Script a few "normal" driver agents with plain rule-based logic — stay in lane, stop at lights, obey speed limits
Script a few "bad" driver agents that break those same rules — running lights, speeding, ignoring lanes — still just hand-written rules at this stage, not learning yet
Add a police agent that watches for rule-breaking and reacts — pulls the offending car over, starting as simple rule-based detection ("is this car over the speed limit?")
Swap the hand-scripted drivers for trained ones, one at a time, using the RL skills from Phases 7–8, so behavior comes from training instead of if/else rules
Stretch: look into multi-agent RL proper — where many agents learn and adapt to each other at the same time, which is its own harder research area
// Pygame docs — for building the world itself · SUMO — a free, purpose-built traffic simulator, worth a look once the custom version works · PettingZoo docs — the standard toolkit for multi-agent RL
// changelog

Log

A running log of updates to this site — what changed and when.

2026-10-04 · 9:12 PM
Added a 3rd goal to the AI Roadmap: Phase 9, a multi-agent traffic simulation — normal drivers, rule-breakers, and a police agent that reacts to them. Starts hand-scripted, ends with trained agents.
2026-10-04 · 7:48 PM
Added an AI Roadmap tab, rewritten to assume zero starting knowledge — phases from "install Python" through two tracks: AI engineering (API, RAG, agents at work) and ML/RL (training something to actually beat a game). Checkable milestones that stick around.
2026-10-04 · 6:21 PM
Rebuilt the Stats tab as a little terminal — skill_matrix --scan, click a line to expand detail. Updated levels: AI/ML 20%, SQL & Snowflake 75%, Python 20%, Circuits 0%, Guitar 5%.
2026-10-04 · 9:40 AM
Decided to narrow focus down to AI and dbt. Put SnowPro, the Claude cert, circuits, and guitar on hold instead of spreading across everything at once.
2026-09-26 · 2:30 PM
Started the dbt Fundamentals course.
2026-09-26 · 7:34 AM
Site is live. Started tracking stats and goals here instead of just in my head.