Why I'm starting 90 days of AI/ML in public

Day 1.

For the next 90 days, I'm doing something I've put off for years — a fully public AI/ML learning sprint. Five posts every single day. By the time this ends, there will be 450 posts on this page, and a public GitHub repo with the code behind every one of them.

Why now? Because I've watched too many private learning attempts (mine included) burn out around week three. The pattern is always the same — notebook open, brain half-engaged, no skin in the game. Nothing on the line, nothing actually learned.

This time I'm putting it on the line. Every concept gets a post within twenty-four hours. Every mistake stays on the timeline. Every snippet ships to GitHub the same day.

The plan covers seven pillars — AI/ML, Python, RAG, DSA, Automation, Agents, and the honest career stuff (portfolios, interviews, open source) that nobody talks about until it's too late.

Five posts a day sounds like a lot. The structure makes it work — concept in the morning, deep-dive at midday, code in the afternoon, a practical tip in the evening, a recap at night. By bedtime, the day's topic is muscle memory.

If you've been meaning to start your own sprint, follow along. We do this together.

90 days. 450 posts. Let's go.

— Saurav
GitHub: github.com/SauravDnj
LinkedIn: linkedin.com/in/sauravdnj

Three letters everyone in tech throws around — AI, ML, DL — and almost nobody uses them correctly.

Let me untangle it the way I wish someone had untangled it for me when I started.

AI is the broad goal. Make a machine do something that looks intelligent. The 1997 Deep Blue chess engine is AI. So is GPT-4. So is the rule-based bot inside your favourite video game. AI is not a single technique — it's a *target*.

ML is one approach to AI. Instead of writing the rules by hand, you let an algorithm learn the patterns from data. A spam classifier trained on a million emails is ML. A handcrafted regex spam filter is AI but not ML.

DL is a subset of ML. Deep neural networks — many layers, lots of parameters, trained on GPUs. Every modern LLM (GPT, Claude, Llama, Gemini) is deep learning of the transformer family.

So: every DL is ML, every ML is AI, but the reverse isn't true. Three nested circles.

Why this matters in conversation: when someone says 'we're using AI', they could mean a giant Llama model OR a five-line if-else. Always ask which layer they mean. The answer changes the cost, the data needs, the failure modes — everything.

Next time someone tells you their startup 'uses AI', smile and ask: 'AI, ML, or DL?' You'll learn more in 30 seconds than from their entire pitch deck.

If you've never trained a machine-learning model, today is the day. It's about to take you six lines of Python.

This is scikit-learn's Iris classifier. Iris is a tiny flower dataset — 150 rows, four numeric measurements, three flower species. It's the 'hello world' of ML, but don't underestimate it. The shape of these six lines is the shape of every ML pipeline you'll ever build, including the billion-parameter ones.

Line 1-2: load data and split it into train and test. Never train and evaluate on the same rows. Ever.

Line 3: pick a model. Random Forest is a strong, fast default for tabular data. You don't need to know how it works yet — that comes in week 6.

Line 4: .fit(X_train, y_train) — the model learns patterns from the training data.

Line 5: .score(X_test, y_test) — see how well it does on data it has never seen. On Iris, you'll get ~97% accuracy.

That's it. Data → split → fit → score. Every billion-dollar AI product starts as a more elaborate version of this loop. The data gets bigger. The models get fancier. The shape doesn't change.

If you can read these six lines and explain each one, you've already understood 80% of practical ML. The remaining 20% is everything we'll do for the next 89 days — but the spine is right here.

Copy. Run. Watch your first model train. Then come back.

I've watched a lot of people start learning AI/ML. The ones who stick with it all do the same weird thing — they ship tiny projects WAY before they think they're ready.

The pattern is brutal in its simplicity. Read about embeddings? That same evening, build a 50-line semantic search over your Notion notes. Read about transformers? Fine-tune a tiny one on your favourite Reddit subreddit. Read about agents? Wire up a 2-tool agent that browses the web and summarises an article.

Notice what's missing — the third tutorial, the fancy GPU, the perfect dataset, the side-project framework. None of it. Just a small messy script that runs.

Here's why this matters more than any course or textbook. Theory teaches you what's *possible*. Tiny projects teach you what you actually *understand*. Those are two completely different things, and the gap between them is where most learners get stuck.

If you can't ship a 100-line version of an idea, you don't understand it yet. That's not an insult — it's a diagnostic. The 100-line version forces you to confront the parts you skimmed.

My rule for myself: every concept I read about gets a tiny repo by end of day. The repo can be ugly. It just has to run, demonstrate the idea, and be pushed somewhere I can find it again.

At the end of 90 days I'll have 90+ tiny repos. Future me will use them as living reference cards — searchable, runnable, faster than any documentation.

For every hour of theory, spend an hour shipping. That's the hack.

End of Day 1. Five posts shipped, zero shortcuts.

Here's what we covered today, distilled.

Morning, we set the contract — 90 days, five posts a day, all public, GitHub repo at the end. Now you know what you're following along with.

Midday, we untangled AI vs ML vs DL. Three nested circles, not three names for the same thing. Use the right word; the right word changes the conversation.

Afternoon, six lines of scikit-learn trained your first ML classifier. The shape of every pipeline you'll build for the rest of your career is hidden in those six lines — load, split, fit, score.

Evening, the one habit that separates learners who finish from learners who don't — ship a tiny version before reading the next chapter. Theory tells you what's possible. Code tells you what you understand.

A quiet number to end on: I started today with 0 posts and a vague plan. I'll end with 5 posts and a slightly clearer one. The thing about building in public is that the plan sharpens *as* you ship. You can't outline your way into clarity.

Tomorrow, Day 2, we set up the cleanest Python environment you'll ever own. uv, ruff, pyproject.toml — three tools, replace about ten old ones, never fight your dev environment again. Boring topic. Massive lifetime payoff.

If today's posts hit, save the day's URL. The whole 90-day index will eventually live behind a single bookmark.

See you tomorrow.