Week 1 recap + the reading list I'm following

End of week one. 35 posts shipped. Time to step back and ask — what mattered, what surprised me, what I'd tell day-one-me if I could.

Seven lessons, in the order they landed.

One. Make it public. Genuinely. Five posts a day forces you to compress what you learned into something a stranger can read. The compression is the learning. Private notebooks are kindling; public posts are fuel.

Two. AI ⊃ ML ⊃ DL is a sentence worth memorising. Three nested circles. Use the right word and the conversation gets clearer; use the wrong one and you sound like a marketing deck.

Three. Tools first. uv + ruff + pyproject.toml. One afternoon of setup buys you the rest of your Python career without environment fights. The cost of not doing this is paid every morning until you do.

Four. In Python, types belong to values, not labels. Variables are pointers; values have types. This single mental model resolves probably 80% of beginner confusion about the language.

Five. List and dict do 95% of the work. Choose by complexity profile — array versus hash map. The remaining 5% (set, deque, heap, defaultdict) you reach for when the situation calls for it.

Six. Loop the values, not the indices. enumerate, zip, comprehensions. range(len()) is a tell that you brought C habits to Python.

Seven. Functions are first-class. They go in lists, get passed as args, get returned from other functions. Once this clicks, decorators and callbacks stop being magic.

The theme tying it all together — Python rewards explicitness. Be explicit about types, about call style, about which container you're using and why. The clearer your intent, the cleaner the code. Onward to week two.

People keep asking what I'm reading. Here's the actual list — books, courses, channels — that survived my filter for this 90-day sprint. I've cut the ones that overlap or that I'd recommend mainly out of nostalgia.

Fluent Python by Luciano Ramalho. The single best Python book if you want to go from 'writes Python' to 'thinks in Python'. Long, dense, worth every page. Reread chapters as you encounter the topics in your day job.

Hands-On Machine Learning by Aurélien Géron (3rd edition, the 2022 one). Best practical intro to classical ML. Code-first, math-as-needed, scikit-learn and Keras both covered. Read chapters 1-9 for ML, 10-15 for the DL section.

Dive into Deep Learning (d2l.ai). Free, online, code-first deep learning textbook. PyTorch, JAX, and TensorFlow versions. Notebooks for every chapter. The right resource if you want depth without paying for a course.

fast.ai courses. Top-down, practical, opinionated. Jeremy Howard's teaching style is unusual — show the result first, explain the theory after. It works for some learners and not for others. Try one lesson; you'll know.

Karpathy's 'Neural Networks: Zero to Hero' on YouTube. Andrej Karpathy explains backprop, transformers, and tokenisers from first principles, building each from scratch in a notebook. Free. Probably the best deep-learning teaching material on the internet right now.

3Blue1Brown's deep learning playlist. Visual intuition for the math. Pair with anything technical and the math suddenly makes sense.

Lilian Weng's blog (lilianweng.github.io). Survey-grade summaries of agent design, prompt engineering, RL fundamentals. Reference material — bookmark, don't read in one sitting.

Free beats paid. Practice beats reading. Bookmark this; I'll cite it across the next 83 days.

Before the week ends, here's the exact pyproject.toml I drop into every new AI/ML repo. Copy it, rename the project, swap dependencies for your stack, you're done.

The [project] section declares the basics — name, version, Python version requirement, and the dependencies that uv will install when you run uv sync. The version specifier 'requires-python = >=3.11' is intentional. As of 2026, 3.11 is the minimum I'd target — you get exception groups, decent typing, and good error messages.

Dependencies stay flat in this section. Just package names. Specific version pins live in the auto-generated uv.lock file, which you commit. The two together give you reproducibility without locking your pyproject.toml to specific versions.

The [tool.ruff] section sets line-length to 100 (the modern default; 88 is too narrow on wide screens, 120 is too generous for diff-friendliness) and enables a tight set of rule families: E (pycodestyle errors), F (pyflakes — undefined names, unused imports), I (isort — import ordering), UP (pyupgrade — modernise old syntax), B (bugbear — common bug patterns). These five letters catch most of the issues I'd otherwise hit in code review.

The [tool.pytest.ini_options] section sets pytest's default flags. addopts = '-q' makes pytest output less noisy. You'll add more options as your test suite grows.

This is the floor. Add type-checker config under [tool.mypy] when you want it. Add hatch or build-system entries when you publish to PyPI. For 90% of personal AI/ML projects, this 12-line file is the entire setup.

There's a failure mode in self-taught learning so universal that it has earned a name — the tutorial trap. It works like this:

Watch a course. Take notes. Feel productive. Don't write any code. Forget most of it within a week. Buy the next course. Watch. Take notes. Repeat.

If this sounds familiar, you're not alone. I lived in the tutorial trap for two years before I figured out the way out. The way out is uncomfortable but simple.

My rule, kept religiously now: every concept I read about, I build a 30-line repo about, by end of day.

Not a polished project. Not a finished tutorial. A 30-line script in a public GitHub repo that demonstrates the concept, runs on my laptop, and proves to me that I understood it.

Learned about embeddings? cosine_similarity_demo.py. Learned about decorators? timing_decorator.py. Learned about dataclasses? frozen_dataclass_demo.py. Each one ugly. Each one runs.

The point isn't the project quality. The point is the friction of moving from 'I read about this' to 'I implemented this'. The friction is the learning. You can't fake your way through a 30-line script the way you can fake your way through reading.

At the end of 90 days, I'll have 90+ tiny repos. Each takes 30-60 minutes to write. Most are scrappy. All run.

Two years from now, when I need to remember how decorators work, I'll grep my repos before I google. Reading my own past code is a compounding asset. Reading other people's tutorials isn't.

For every hour of theory, spend an hour shipping.

End of week one. 35 posts. 7 days. Zero misses.

Thank you. Genuinely. To everyone who reposted, commented, or just hit save without saying anything — showing up for someone else's learning journey on the internet is one of the most generous, low-recognition things you can do, and it's why this format works at all.

A few things I've noticed in the first week.

The pace is doable but tight. Five posts a day, written in advance the night before, takes about 90 minutes. The actual writing time isn't the constraint — the thinking-clearly-enough-to-write is. If a topic isn't clear in my head, the post takes three times longer.

The public commitment is doing what I hoped. There have been at least two days this week where, alone, I would have skimmed a topic. Knowing five posts had to ship made me actually understand. That's the whole game.

The response has been more generous than I expected. DMs from people starting their own sprints, comments correcting me where I was wrong (and right to do so), and quiet reposts that reach corners of the network I'd never reach myself. Keep it coming.

What's next.

Week 2 starts tomorrow with Python OOP. By the end of week 2, you'll be able to read any open-source AI/ML codebase without flinching. Decorators, generators, context managers, type hints, dataclasses — the parts that show up in every framework and confuse most beginners.

After week 2 we go DSA for two weeks (the foundation that ML interviews and elegant code share), then NumPy, Pandas, classical ML, deep learning, transformers, RAG, agents, automation, and a career-focused wrap.

If you're catching up, the full plan lives on my GitHub. Pinned, indexed, and updating daily.

See you tomorrow.