Day 22 #100DaysOfMLCode
Image Augmentation
Transfer learning - use a set of filters already run on larger dataset
Inception model from google had dozens of layers, can classify images into thousands of categories
Dropout regularization - overcome fitting
#100DaysOfCode
Google just dropped a 1-hour course on agentic engineering from scratch:
00:00 – How to build your first AI agent
08:24 – Build agent memory (short, persistent, long)
28:34 – Agentic loops, long-running AI agents
40:04 – How to build MCP (MCP vs API)
1:00:22 – Multi-agentic systems
This 1-hour watch will replace 10 paid agentic courses on the internet.
Bookmark this. Watch this weekend.
𝗬𝗼𝘂’𝗹𝗹 𝗻𝗲𝘃𝗲𝗿 𝗳𝗼𝗿𝗴𝗲𝘁 𝗔𝗜 𝗳𝘂𝗻𝗱𝗮𝗺𝗲𝗻𝘁𝗮𝗹𝘀 𝗼𝗻𝗰𝗲 𝘆𝗼𝘂 𝘀𝗲𝗲 𝗵𝗼𝘄 𝘁𝗵𝗲𝘆 𝗰𝗼𝗻𝗻𝗲𝗰𝘁.
You want a computer to understand text. But computers only understand numbers. They have no idea what "hello" means.
>> So you use tokens.
Text is split into small pieces, and each piece gets a number. "Unbelievable" becomes "Un", "believ" and "able". Now the computer can read.
But those numbers are random labels. "Dog" might be 4521 and "puppy" 9873. Nothing tells the computer they mean almost the same thing.
>> So you use embeddings.
Every token becomes a long list of numbers, placed so that similar meanings sit close together. "Dog" lands next to "puppy" and far from "Paris". Now numbers carry meaning.
But a word on its own is not enough. "Bank" means something different in "river bank" and "bank loan". The meaning depends on the neighbours.
>> So you use attention.
Every word looks at every other word and decides which ones matter. Now "bank" knows if it is near a river or a loan.
You have a structure that can read. But it knows nothing yet. Where does the knowledge come from?
>> So you use training.
You feed it a huge amount of text and give it one job: predict the next token. Every wrong guess adjusts billions of numbers called weights. After trillions of guesses, those weights hold grammar, facts, and reasoning.
But the trained model only knows how to continue text. Ask "What is the capital of France?" and it might write three more quiz questions. It is not being difficult. It has never seen a conversation.
>> So you use fine-tuning.
You train it further on thousands of examples of good questions and answers. Now it behaves like an assistant.
But it always picks the single most likely next word. Every answer sounds the same, flat and repetitive.
>> So you use temperature.
Low temperature plays it safe, which is right for code and facts. High temperature takes chances, which is right for ideas and writing. You choose the risk.
Now you paste in a 500-page manual and ask a question. Half of it gets ignored. In long chats, it forgets what you said at the start.
>> That is the context window.
The model can only see so much text at once. Everything outside it does not exist.
Then you ask about your company's internal docs. The weights were frozen during training and were never seen. The model does not say "I don't know". It writes something that sounds right and is completely wrong.
>> That is hallucination.
It is not lying. It is predicting text, not checking facts.
>> So you use RAG.
Before answering, the system searches your real documents and puts the relevant parts into the context window. Now it is an open-book exam, not a memory test.
But it can still only talk. It cannot check your server, query your database, or open a ticket.
So you give it tools. The model decides which tool to call, reads the result, and keeps going until the job is done.
>>That is an agent everyone seems to be building these days.
Don't waste 2 years learning to become an AI agentic engineer in 2026.
Andrew Ng, the godfather of AI, gave the complete playbook to become one from scratch.
1 hour course. Free:
• 00:00 - AI agent basics
• 12:12 - AI Agentic workflows & design patterns
• 53:27 - Practical tips for building AI agents
• 1:20:30 - self-improving AI agent loops
• 1:30:19 - multi-agent AI systems
I watched it last night.
Halfway through, I realized I could get into Anthropic in weeks, not years.
Bookmark now. Watch it. Then build your own AI agent
Understanding agentic AI system design concepts in simple language:
• Agent: an AI that takes actions not just answers
• LLM: the brain that thinks and decides
• Prompt: the instructions you give the brain
• System prompt: the agent's job description
• Tools: the hands (search, code, APIs, browser)
• Function calling: how the brain uses its hands
• Memory: short-term is the chat, long-term is what it remembers forever
• Context window: how much it can hold in its head at once
• Planning: breaking a big goal into small steps
• Reasoning loop: think, act, check, repeat
• Reflection: the agent reviews its own work and fixes it
• RAG: looking things up before answering
• Embeddings: turning words into numbers so AI can find meaning
• Vector database: the library where those numbers live
• MCP: a universal plug that connects AI to any app
• Orchestrator: the manager that assigns work to other agents
• Multi-agent: a team of AIs, each with one job
• Sub-agents: helpers the main agent spins up for side tasks
• Guardrails: rules that stop it doing something dumb
• Human in the loop: you approve the risky stuff
• Evals: tests that check if the agent actually works
• Observability: logs that show what it did and why
• Latency: how long it takes to respond
• Token cost: what every thought costs you
Chatbots talk.
Agents do.
Bookmark this before your next AI interview.
Andrej Karpathy’s 1-hour Stanford lecture on AI engineering is one of the best explanations I’ve seen of how AI systems actually work.
The progression is simple:
10% → LLM
30% → Prompt
50% → Agent
70% → Loop
100% → Graph
The key takeaway:
AI engineering isn’t just about writing better prompts.
It’s about building systems around models — giving them context, memory, tools, feedback loops, and data flows.
“Delete everything, keep Graph.”
Definitely worth watching if you’re building with AI agents.
Watch → Bookmark it
i don't think people realize what one person can now build with Claude...
a Google Cloud engineer just went on stage and built a full app from scratch in 26 minutes, live.
he showed everything step by step, no team, no setup, just Claude and a goal.
worth more than any $500 vibe-coding course, and most people will scroll right past it.
watch it, then read the guide below on the Claude features 99% of users never find.
Kubernetes is beautiful.
Every Concept Has a Story, you just don't know it yet.
In k8s, you run your app as a pod. It runs your container. Then it crashes, and nobody restarts it. It is just gone.
So you use a Deployment. One pod dies and another comes back. You want 3 running, it keeps 3 running.
Every pod gets a new IP when it restarts. Another service needs to talk to your app but the IPs keep changing. You cannot hardcode them at scale.
So you use a Service. One stable IP that always finds your pods using labels, not IPs. Pods die and come back. The Service does not care.
But now you have 10 services and 10 load balancers. Your cloud bill does not care that 6 of them handle almost no traffic.
So you use Ingress. One load balancer, all services behind it, smart routing. But Ingress is just rules and nobody executes them.
So you add an Ingress Controller. Nginx, Traefik, AWS Load Balancer Controller. Now the rules actually work.
Your app needs config so you hardcode it inside the container. Wrong database in staging. Wrong API key in production. You rebuild the image every time config changes.
So you use a ConfigMap. Config lives outside the container and gets injected at runtime. Same image runs in dev, staging and production with different configs.
But your database password is now sitting in a ConfigMap unencrypted. Anyone with basic kubectl access can read it. That is not a mistake. That is a security incident.
So you use a Secret. Sensitive data stored separately with its own access controls. Your image never sees it.
Some days 100 users, some days 10,000. You manually scale to 8 pods during the spike and watch them sit idle all night. You cannot babysit your cluster forever.
So you use HPA. CPU crosses 70 percent and pods are added automatically. Traffic drops and they scale back down. You are not woken up at 2am anymore.
But now your nodes are full and new pods sit in Pending state. HPA did its job. Your cluster had nowhere to put the pods.
So you use Karpenter. Pods stuck in Pending and a new node appears automatically. Load drops and the node is removed. You only pay for what you actually use.
One pod starts consuming 4GB of memory and nobody told Kubernetes it was not supposed to. It starves every other pod on that node and a cascade begins. One rogue pod with no limits takes down everything around it.
So you use Resource Requests and Limits. Requests tell Kubernetes the minimum your pod needs to be scheduled. Limits make sure no pod can steal from everything around it. Your cluster runs predictably.
this is f*cking gold
How to build your first AI agent (Full guide)
if I had this a year ago, I would've shipped my first agent in a day instead of 2 weeks in the right hands, this changes everything:
A few algorithms I regularly force myself to review so I don’t forget how they work:
• Kadane’s → Maximum subarray sum
• Rabin-Karp → Substring search with hashing
• Topological Sort → Ordering a DAG
• Prim’s → Minimum Spanning Tree
• Kruskal’s → MST with Union-Find
• Dijkstra’s → Shortest path (no negative weights)
• Bellman-Ford → Shortest path (with negative weights)
• Tarjan’s → Strongly Connected Components
• Backtracking → Sudoku Solver
These are the ones I keep coming back to years later.
Which algorithms do you still periodically revisit?
🚨Anthropic just showed a 24-minute workshop on how to actually do prompts for Claude.
Taught by the people who built it.
Free. No registration. No paywall.
I've seen $300 courses that don't cover what they teach in the first 8 minutes.
Watch it and bookmark it now.
Google CEO, Sundar Pichai:
"If you don't learn to how to orchestrate agents now, you'll spend 2027 catching up to people who started today"
In 30 minutes he explains why the best engineers stopped writing code and started running agents.
Watch the interview, then save the exact setup below 👇
Stanford just dropped a 2-hour lecture that explains how LLMs like ChatGPT and Claude are actually built.
Most people will scroll past it.
That’s the mistake.
Because this isn’t typical AI content it goes deep into how these systems work from the ground up, in a way that finally makes things click.
No hype. No fluff. Just real understanding.
If you’ve ever used ChatGPT or Claude and thought, “what’s really happening behind this?” this is where you’ll get clarity.
Bookmark it.
Give it 2 hours today, no matter what.
This might be the most valuable thing you watch all week.