I’ve been working in AI for close to a decade, starting well before today’s LLM-driven wave.

My work is grounded in understanding AI across layers — from hardware, AI models, and data to system design, reliability, and scale. I approach AI as an end-to-end engineering problem: not just modeling, but how models interact with data, infrastructure, and real-world constraints.

Alongside this, I write The AI Merge, a technical newsletter on AI foundations and systems engineering, focused on clear thinking and practical system design rather than hype.

I’m currently building an AI Systems course, centered on end-to-end system design, for engineers who want a deeper, systems-first understanding of modern AI.

🗞️ Read The AI Merge: https://read.theaimerge.com

Alex Razvant

A lot of courses out there teach AI & LLMs, but very few touch on Inference

Sure, it's easy to grasp the fundamentals of what LLMs are and how to build systems around them, but scaling out an LLM out of a lab of 1-2 H100s running it and a single concurrent user session is a big challenge.

Efficient inference is one of the largest barriers to LLMs in production.

Batching, managing memory, concurrent user sessions, GPU saturation, and sharding with/or MIG (Multi-Instance GPUs), parallelisation are key concepts for engineers to know, understand, and work with or around them.

I've had this list of resources saved for a while, which fills some of those gaps.

1. Good Courses / Videos
- CS336 Stanford (Lecture 5-11): https://buff.ly/9o4jRxl
- GPU MODE: https://buff.ly/bPEHYL0 
- LLM Inference Patterns: https://buff.ly/4ASDS5c
- LLM Inference (NVIDIA): https://buff.ly/muDMcor 

2. Repositories / Blogs
- GPU Performance Engineering (E.Andere): https://buff.ly/sfGJNMK 
- AI Performance Engineering (C.Fregly) https://buff.ly/8ey3GPa 
- Inside NVIDIA GPUs (A.Gordic): https://buff.ly/wmgNwMg 
- Understanding LLM Inference (my article): https://buff.ly/NrNU3Qz 

I don't think there's a clear, step-by-step guide on how to master AI Perf Engineering.
The best bet is to study the core pieces of the models and the hardware they run on.

Then, learn the rest on demand.

undefined undefined

Neural Bits CTA

Join 4100+ engineers and get a weekly newsletter on advanced AI/ML. 👉 https://neuralbits.substack.com/

Kubrick

Ready to start building?

--- Resources ---
📌 Kubrick Code Repository
https://github.com/multi-modal-ai/multimodal-agents-course

📌 Neural Bits Newsletter (mine)
https://multimodalai.substack.com/

📌 The Neural Maze Newsletter (Miguel's)
https://theneuralmaze.substack.com/

Senior AI/ML Engineer | Author of NeuralBits Newsletter – helping you build efficient AI Systems

Hard work always pays off, be consistent!

I'm a Senior Machine Learning Engineer with a keen interest in developing AI/ML solutions for real world problems and helping others get started on their Machine Learning Journey.

Let's connect @:
📘 https://medium.com/@alexandrurazvant
✉️ alexandrurazvant@gmail.com
🌐 https://www.neuraleaps.com

Upskill your AI Engineering!

AI Engineering Hub

Senior AI Engineer | Writing The AI Merge Newsletter | Helping Engineers Build AI Beyond Demos

The 5 structure-layers of any LLM Model.
(Understand these, and you'll understand every OSS model on HF)

With each open-source LLM released, you'll find the model weights on Hugging Face.

When you go to the Files section, you won't find a `model.xyz` file, but multiple files, usually 10-15 that compose the entire LLM.

Here's the blueprint to understand them:

1️⃣ 𝘼𝙧𝙘𝙝𝙞𝙩𝙚𝙘𝙩𝙪𝙧𝙚 𝘾𝙤𝙣𝙛𝙞𝙜𝙪𝙧𝙖𝙩𝙞𝙤𝙣 (config.json)
This one contains metadata on model architecture, layer activations, sizes, vocabulary size, number of attention heads, model precision, and more. 

The transformers library knows how to parse this config and build the model architecture. 

2️⃣ 𝙈𝙤𝙙𝙚𝙡 𝙒𝙚𝙞𝙜𝙝𝙩𝙨 (the .safetensors splits)
LLMs have B (billions) of parameters.
For safer download, model weights are split into chunks/shards.
The formats used for weights are either Binary or Safetensors.

Safetensors format is an alternative to the default Pickle serializer that PyTorch (pt) uses, as it’s vulnerable to code injection.

3️⃣ 𝙇𝙖𝙮𝙚𝙧 𝙈𝙖𝙥𝙥𝙞𝙣𝙜 (the *.index.json)
Since the models are large and weights come as part files (e.g., 0001-of-0006, 0002-of-0006, etc.), this file stores a sequential map of the model architecture.

This specifies what layers are part of what model chunk.

4️⃣ 𝙏𝙤𝙠𝙚𝙣𝙞𝙯𝙚𝙧 𝘾𝙤𝙣𝙛𝙞𝙜 (tokenizer.json)
The tokenizer config file contains metadata about the tokenizer used to train this model. 

It contains the class name used to instantiate the tokenizer, the layer names, the structure of how the inputs are processed before passing through the model, and special tokens.

The LLM generally uses 𝘴𝘱𝘦𝘤𝘪𝘢𝘭_𝘵𝘰𝘬𝘦𝘯𝘴 as markers to stop generation.

5️⃣ 𝙂𝙚𝙣𝙚𝙧𝙖𝙩𝙞𝙤𝙣 𝘾𝙤𝙣𝙛𝙞𝙜 (generation_config.json)
These configuration files contain metadata for Inference, such as Temperature and TopP/TopK thresholds or context window size, with which the model was trained. 

When you load your model using Transformers.from_pretrained(), all these files are processed to set up everything you need to actually use that model.

---
Learn AI going through Fundamentals, Engineering and Systems.
Join here (free): https://buff.ly/DnpHEXD

The 4 patterns of LLM Inference.

Deploying LLMs is not the same as deploying traditional ML models. The differences show up most clearly at inference time. 

Some principles such as optimized models, infrastructure, GPU saturation and usage or distributed systems concepts still apply.

But LLM inference adds a new layer of complexity, as Transformer models inference is way more nuanced.

With LLMs, the output is generative and not a fixed size having batch-size input = batch-size output that more traditional ML or Deep Learning models had.

LLM inference splits into two stages, Prefill and Decode, this creates 4 distinct patterns an AI Engineer/Dev should know about before optimizing or deploying.

⇢ In the prefill phase, the model processes the entire input prompt and computes the key-value (KV) cache. In benchmarks, we'll often see this metric as `pp` or `prompt processing` speed, which is fast.

⇢  In the decode phase, it autoregressively generates tokens one at a time, updating the KV cache at each step. In benchmarks, this is refered to as `tg` or text-generation speeds, and this process is memory-bound as tokens have to travel within the GPU's memory during KV cache updates.

Understanding this gives you these four distinct LLM inference patterns:

SISO -- Short Input, Short Output
→ Low latency with fast generation. If using this pattern, aim to optimize for high concurrency.

LILO --  Long Input, Long Output
→ The most compute-intensive requires distributed inference, ideally with shared KV cache across nodes or tensor parallelism.

LISO -- Long Input, Short Output
→ This one has heavy prefill and quick decode. GPUs with enough VRAM would parallelize the prefill and generate fast.

SILO -- Short Input, Long Output
→ Light prefill, which runs fast but is heavier on decode. Decode latency dominates here.

---

𝗧𝗮𝗸𝗲𝗮𝘄𝗮𝘆: The longer the output, the more time is spent in the decode loop.
Before fine-tuning your own LLM and deploying it, also consider the inference pattern your system will target.

Summary:
- In LLM inference, there are 4 patterns.
- For LISO, the generation and TFTT are fast.
- On SISO, everything is fast.
- For LILO,  a lot of computing.
- For SILO, prefill is fast, generation is slow.

---

Learn AI through Fundamentals, Engineering and Systems.
Follow and join here: https://buff.ly/iqFpm9x

If you'll ever try to run LLMs locally - you'll bump into llama.cpp

Most guides tell you what to use for Edge/CPU/low-end GPU inference - but not what’s actually happening under the hood. 

No context on:
- How is the model checkpoint parsed?
- How are tensors unpacked and mapped?
- How do GGML, GGUF, and llama.cpp fit together?

✅ So I went through the codebase myself. 

I spent a few hours digging through llama.cpp, PRs, and community threads, then turned everything into a single sequence diagram that shows the flow end-to-end. 

The key pieces of the stack:
> GGML - the ML Tensor Library and execution primitives (ops, mappings, kv-cache)
> GGUF - the format for storing quantized LLM models and Quantization types.
> llama.cpp - is the C++ inference engine, building on top of GGML & GGUF, wiring everything together.

If you’re running local LLMs, this is the stack you’re relying on.

If you want to understand why things break, how quantized models are actually loaded, this breakdown will help. 

---
I share more practical advice on AI Fundamentals, Engineering and Systems.
Join here (free): https://buff.ly/iqFpm9x

You should read more code.

If you’re already a Software Engineer or AI / ML Engineer, one of the fastest ways to level up right now is to study how big AI teams write and ship - in public. 

Many top companies and major contributors to the AI space have been open-sourcing their internal frameworks, kernels, or infrastructure libraries. 

You might feel overwhelmed by how fast AI is going. But this is a great learning opportunity if you know where to look.

Learning doesn’t just happen from papers and tutorials, especially if you already build software.

You should:
- Read real production code
- Study PRs or commit history on major/popular repos.
- See how teams structure codebases, design APIs, configs, tests

Check what gets reviewed, what gets rejected, and why.
This kind of learning will upgrade your engineering intuition. 

Here are some excellent codebases to learn from.

✅ From DeepSeek:
1. FlashMLA  - A library of high-performance attention kernels.
Link: https://buff.ly/XbFnPA7 

2. DeepEP - A Communication Library for high-throughput MoE workloads.
Link: https://buff.ly/3qxMc3S

3. 3FS - A Distributed Filesystem for AI Workloads, for AI training and inference.
Link: https://buff.ly/ovfW47A

✅ From NVIDIA:
1. Dynamo - A datacenter-scale Inference Serving Framework for GenAI workloads.
Link: https://buff.ly/WyAMzBz 

2. NeMo  -  A Scalable Generative AI Framework, for training and deploying LLMs and VLMs.
Link: https://buff.ly/L9KTuJp 

✅ From vLLM:
1. The vLLM Library  - One of the most popular LLM inference engines, designed for scale.
Link: https://buff.ly/GLCfoIM

✅ From SGLang:
1. The SGLang Engine - A high-performance serving engine for LLMs & multimodal models.
Link: https://buff.ly/m4HhsWQ 

✅ From llama.cpp
1. The llama.cpp Engine - A minimal C/C++ inference engine for LLMs with broad hardware support and quantization options.
Link: https://buff.ly/u9yaXwp

📌 Don't study everything, you won't be able to.

Instead, pay attention to:
⇾ Code structure & abstractions
How are core functionalities separated (core logic vs hardware-specific optimizations)?

⇾  PRs & commit history
What context do authors provide? How do reviewers push back?

⇾  Interfaces & public APIs
How are public APIs designed?

⇾  Tests & benchmarks
How do the test suites look? What CI pipelines do they have, profiling? 

Don’t just use these libraries. 
Read them.

That will build your intuition and help you get better at your craft, either as a curious learner or an engineer as part of a larger team at your job.

---
I distill my learnings with my audience on The AI Merge.
Check it here (8700+ engineers already do that) https://buff.ly/2rwqlNL

I have a surprise for my European audience, for NVIDIA GTC 2026 (March 16–19)

🎁 I’m giving away 1 x NVIDIA DGX Spark to someone who joins me for Virtual NVIDIA GTC 2026. 

I’ve spent the last 6 months building on NVIDIA DGX Spark, and when building AI Systems locally, the Spark is an incredible machine to learn, prototype, fine-tune, build and iterate fast.

Especially if you want more control over your entire stack.

NVIDIA GTC is the premier global AI conference, where developers, and researchers come together to explore the next wave of AI across every industry and application.

✅️ Virtual GTC is free. 

𝗛𝗼𝘄 𝘁𝗼 𝗲𝗻𝘁𝗲𝗿 𝘁𝗵𝗲 𝗗𝗚𝗫 𝗦𝗽𝗮𝗿𝗸 𝗴𝗶𝘃𝗲𝗮𝘄𝗮𝘆:
𝟭. 𝗥𝗲𝗴𝗶𝘀𝘁𝗲𝗿 for GTC 2026 using my link: https://buff.ly/aKgT9BA
𝟮. 𝗔𝘁𝘁𝗲𝗻𝗱 at least 1 virtual session (keynote does not count) - virtual sessions are free
𝟯. 𝗙𝗶𝗹𝗹 𝗼𝘂𝘁 𝗺𝘆 𝗴𝗶𝘃𝗲𝗮𝘄𝗮𝘆 𝗳𝗼𝗿𝗺 𝗮𝗳𝘁𝗲𝗿 𝗮𝘁𝘁𝗲𝗻𝗱𝗶𝗻𝗴

I’ll share the giveaway form link as we get closer to GTC 2026. 𝗦𝘁𝗮𝘆 𝘁𝘂𝗻𝗲𝗱.

Here are a few sessions that caught my eye (links below):
1. AI Factories in Europe: Building the Foundations for Scalable Intelligence [S81899] 
2. Accelerate AI Through Open-Source Inference [S81902] 
3. Teach AI to Code in Every Language With NVIDIA NeMo [S82306] 
4. From Data to Meaning: Vision-Language Models Shaping the Cities of Tomorrow [S81867] 
5. Your Learning Pathway: Get Certified for Career Success [C81544] 

If you’re planning to attend, remember to register here: https://buff.ly/aKgT9BA 

Follow me here and stay tuned for the giveaway form.

Underrated advice to grow as an Engineer

1. Go Depth first (2–3 years)
Pick one stack (language + framework + system) and get good at it.

Breadth gets easy after.
I know it's tempting to know a bit out of everything, but you'll spread yourself too thin, too soon.

2. If you're a junior/mid - talk to senior/staff engineers (smartly)

Don't ask “What should I do?” 
Instead, ask: “Here’s what I tried, here’s what happened, what would you check next?”

They've seen enough systems and code to spot patterns early on.

2. Get good at Code Reviews
Express your points, think past the small code component - oversee the entire system.
Don't nitpick for code changes unless necessary. 

3. No Vibe-coding
With each feature/component you build, spend time gathering context, asking for options, plan, review, verify and write the hard paths yourself.

One practice that works for me is, after drafting a plan for my coding Agent (in Plan Mode), I ask if it's got any questions for me, before starting to work.

It usually comes up with great points.

3. Study outside work
That's an easy switch.
You do it already by consuming content, scrolling through posts and watching videos.
But make sure you focus on what actually helps you, not all the news/hype out there.

Work getting better, use AI as leverage.

A better way to manage complex configurations in your AI/ML projects.

AI/ML systems usually have more moving parts and more configuration surfaces (data, training, evaluation, inference, orchestration). Keeping track of which configuration subset was used can get difficult fast. 

Sure, as per Factor III (Config) in 12-factor apps, environment-specific config can be stored as env variables.

However, env vars alone are usually not enough. You might need hierarchical configs, runtime composition, overrides etc.

For instance, on a current project I'm working on, I have:
- 6 MLOps pipelines that build the raw_data > deployed model lineage.
- 2 edge services that ingest video, route frames to Inference Servers
- 3 MCP servers, each with their own connection details, tools and resources
- 2 Agents, wired through A2A - each with their own subset of instructions and MCP

In this setup, during testing, services often require runtime overrides (MLOps pipelines), composition or swap (training/eval), and sometimes they share the same configuration domain. 

When configuration gets more complex, I found Hydra + OmegaConf to be the way to go.

Here's what you need to know:
1. 𝗢𝗺𝗲𝗴𝗮𝗖𝗼𝗻𝗳 is a hierarchical configuration system explicitly designed for complex applications like ML pipelines. 

You can:
↳ Merge multiple configuration files directly through runtime composition.
↳ Access fields via attribute notation "config.model.optimizer" or dict notation config["model"]["optimizer"]
↳ Add Type safety against schemas such as dataclasses or Pydantic base models.

2. 𝗛𝘆𝗱𝗿𝗮 builds on top of OmegaConf, creating a full-featured framework.

You can:
↳ Group multiple YAMLs into a single configuration file and reference them directly by filename.
↳ Run a sweep, same application - multiple configurations in parallel.

Concrete examples:
1. Your hydra config could look like this (config.yaml)
``` config.yaml
defaults:
  - data: mydata
  - training: trainAB
  - inference: inferAB
  - _self_ 
```

When loading the `config.yaml` file using Hydra, we get a nested configuration object, from which we can access any field 
(cfg . inference . batch_size / cfg . training . batch_size)

2. Override any config value at runtime. 
For example, if in the config.yaml, if you have:
```
model:
 optimizer: SGD
```

At runtime, you can override the value with:

```
python train model.optimizer=Adam
```

𝗧𝗵𝗶𝘀 𝗮𝗹𝘀𝗼 𝘄𝗼𝗿𝗸𝘀 𝗳𝗼𝗿 𝗻𝗲𝘀𝘁𝗲𝗱 𝗰𝗼𝗻𝗳𝗶𝗴𝘀.
↳ Run multiple configurations simultaneously using Hydra multirun.

```
python train -m data.dataset=A1, B12, C55
```

This will launch multiple runs (one per dataset value) and create separate output directories for each run. 

---

I share more practical advice on AI Fundamentals, Engineering and Systems.
Join here (free): https://buff.ly/iqFpm9x

Qwen3.5 4B and 9B around the corner? 👀

Code is cheap nowadays. Design and planning is not. 

Some, keep measuring output by volume. 

I've been doing AI Assisted Programming for the past 2.5 years, on real codebases.

Online, I keep seeing many claim to push 10k Lines of Code a day to production and not reviewing anything.

I think that’s mostly marketing.
The more code added to a codebase, the larger the surface area.

Software isn't written once. It's designed to evolve.
What works now, should be easily changed or improved in the future.

The question you should ask: 
“Can we ship changes that are consistent and safe to release?”

A few safeguards that actually worked for me:
1. Treat AI code as proposal, not truth. Don’t accept diffs you can’t explain.
2. Put a harness on the agent. (Cursor Rules / AgentsMD / ClaudeMD / Skills / Plugins)
3. Keep Agent Rules, Skills and Plugins small, scoped and enforceable.
4. Add guardrails only after noticing Coding Agent failures.
5. Keep PRs reviewable. Minimal context + a 1-pager attached on the PR for big moves.
6. Reviews should't focus on preference. Skip nitpicks. Focus on the entire workflow.
7. Pre-commit + CI parity. Catch drift before you waste a CI cycle.
8. Write a handoff note to your tomorrow-self so you catch-up faster on the next day.

For an Engineer, AI helps, but only when you stay in control of constraints.

---
I explain complex topics in AI, AI Engineering and building AI Systems.

For free.

Join here: https://buff.ly/DnpHEXD

Six Tips on AI Assisted Programming

No BS AI/ML Content | ML Engineer with a Plot Twist 🥷30M+ Views 📝

Done-for you Audience Building & Content Writing for AI/ML Founders that frees up 100% of your time, so you can focus entirely on building your company  
  
Is your work too important to ignore? 💌 https://tally.so/r/wk69VJ  (or shoot me a DM) 👉
  
It's 2025 and we're at the peak of the attention economy  
  
Where Authenticity is king, visibility is currency and people wanna buy from people

Not faceless dehumanized brands  
  
So, they told you LinkedIn was "free marketing" you slapped some posts and called it strategy  
  
You've poured hours crafting the 'perfect' post, only to watch it sink without a trace..  
  
Then it dawned on you, your technical brilliance isn't enough to draw a crowd  
  
Hell, maybe you've even tried mimicking influencers, scrambling for any traction..  
  
Your post got 500 f*cking views... from your friends...  
  
Being ignored is soul-crushing  
  
It's not your fault tough  
  
When you started your company, you didn't sign-up for a degree in an Audience Building, Copywriting and LinkedIn strategy 

And here you are, sacrificing yet another late night for your vision  

"Am I just sabotaging my efforts?"  
  
"Is my life-work meaningless?"  
  
Getting traction feels impossible  
  
You hoped hiring some marketer would save your weekends but..  
  
Tech is a code they can't crack  
  
They can only churn out the lame, soul-sucking crap we all ignore on sight  
  
With armies of founders flooding feeds, your voice dissolves into meaningless white noise  
  
But in the process, you've wasted more of your precious time explaining 101 tech concept and rewriting low-quality drafts 

Done being ignored?  
  
Let's make the world listen 
  
I can help you with:  

✒️ No BS AI/ML Content  
⭐ LinkedIn Profile Revamp
🎯 Website Copy Optimization  

I've done it before:

↳ For founders backed by YC, a16z, Sequoia, and Techstars
↳ For bootstrappers in LLMs, ML, Vector DBs, Data Analytics, and Engineering
↳ For AI and Machine Learning leaders at Google, Microsoft, Airbnb, and YouTube

If they could rise above the noise, so can you

Yeah, even if you're an introvert with a "boring" niche

Still with me?  
  
Amazing—You're amazing!  
  
Cheers,  
Paolo

My booking link: 💌 https://tally.so/r/wLW0oz (or shoot me a DM) 👉

Paolo Perrone

LangChain just open-sourced their answer to Claude Code.

9.9K GitHub stars. 5 hours old.

Deep Agents: the batteries-included agent harness. MIT licensed. FREE.

Here's why this is a big deal:

Claude Code is amazing but closed-source and locked to Anthropic.

Deep Agents gives you the same architecture. Any model. Any provider.

What's included out of the box:

1️⃣ Planning
write_todos for task breakdown and progress tracking. The agent plans before it codes.

2️⃣ Filesystem access
read_file, write_file, edit_file, ls, glob, grep. Full codebase navigation.

3️⃣ Shell execution
Run commands with sandboxing. Build, test, deploy from the agent.

4️⃣ Sub-agents
Spawn isolated workers with their own context windows. Parallel work without context pollution.

5️⃣ Context management
Auto-summarization when conversations get long. Large outputs saved to files. The problem Claude Code solved, now OPEN SOURCE.

Two lines to start:

pip install deepagents

agent = create_deep_agent()

Works with Claude, OpenAI, Google, or any LangChain-compatible model. Swap providers without rebuilding.

Built on LangGraph. Streaming, persistence, checkpointing: all production-ready.

The CLI adds web search, remote sandboxes, persistent memory, custom skills, and human-in-the-loop approval.

From their README: "This project was primarily inspired by Claude Code."

They're not hiding it. They're DEMOCRATIZING it.

Are you still locked into a single AI coding provider? 👇

♻️ Repost for someone who wants Claude Code capabilities without the lock-in

No BS AI/ML Content | ML Engineer with a Plot Twist 🥷100M+ Views 📝

My Meta Staff Engineer friends shared their Claude Code setup with me.

Changed how I build software FOREVER.

10 tips. Here's why they matter:

1️⃣ Always start in Plan Mode
Never execute first. Argue with Claude. Challenge its assumptions. Spend 80% of your time here. The code generation is the easy part.

2️⃣ Run /init on every project
Claude scans your codebase and creates a CLAUDE.md rules file. This controls everything. Skip this and Claude is guessing blind.

3️⃣ CLAUDE.md under 300 lines
Every line bloats your context window. More bloat = worse output. Only add what's unique to your project. Think lint rules, not docs.

4️⃣ Build a validation loop
Build, test, compile commands inside CLAUDE.md. Claude self-corrects when it can validate its own output. Without this, it hallucinates fixes.

5️⃣ Interrupt early, interrupt often
Claude going off track? Escape. Don't wait. Don't hope. Fresh context beats bloated context every single time.

6️⃣ /clear between features
Old context contaminates new tasks. One feature per session. Start clean or pay the token tax.

7️⃣ Multiple instances simultaneously
This is the REAL unlock. Multiple terminals. Multiple Claude sessions. One builds, one plans, one debugs. Jump between them like Starcraft.

8️⃣ Never manually edit rules
"Update the rules so we never do this again." One sentence. Claude maintains its own CLAUDE.md. Stop hand-editing config files.

9️⃣ Audit with /context regularly
MCPs destroy your token budget. /context shows the biggest offenders. Disable what you don't need. Most engineers never check this.

🔟 Sub-agents for atomic tasks ONLY
Don't create CEO agents and product agents. Keep shared context in ONE session. Sub-agents lose the reasoning chain. Bring work to the context, not context to the work.

The meta-lesson:

AI coding is 80% context engineering, 20% code generation.

Most engineers optimize the 20%.

These 10 tips optimize the 80%.

That's why they ship faster than entire teams.

Are you still treating Claude Code like a chatbot? 👇

♻️ Repost for someone using Claude Code who hasn't optimized their workflow

2 founders built Claude Code but for marketing, and it's already compressing 10-month execution cycles into 10 days

After multi-billion dollar exits to Salesforce and Oracle, Tom Chavez and Vivek Vaidya noticed something:

AI eliminated manual work for engineers, but marketers were still dealing with analysis and dashboards.

I was watching their conversation with Navin Chaddha from Mayfield and it struck me what has driven their success as serial entrepreneurs:

•⁠ ⁠“A bad decision made quickly is better than a good decision made slowly.”
•⁠ ⁠“Everything we used to do in 10 months, we now try to do in 10 days.”

Hear them break it all down:

You don't need 14 courses to build AI agents.

You need 6 weeks and this path:

Week 1️⃣: Understand the pattern
→ Anthropic's Building Effective Agents: https://lnkd.in/ew-rnBgD
→ Chip Huyen's agent explainer: https://lnkd.in/gKNqjeGZ
→ 3 hours total. No courses yet.

Week 2️⃣: Build something ugly
→ Langflow (no-code, 1 hour to ship): langflow.org
→ A research agent. A Slack bot. Anything.
→ Now you have context for everything else.

Week 3️⃣–4️⃣: Understand what you built
→ AI Agents in LangGraph: https://lnkd.in/g7raxjpC
→ Agent Memory: https://lnkd.in/ehtwbCVz
→ Rebuild your ugly thing. Properly.

Week 5️⃣–6️⃣: Deploy it
→ LangSmith for tracing: smith.langchain.com
→ Railway or Render for hosting
→ Now it's a portfolio piece.

The trap:
"I need to understand transformers first."
"I should take the Andrew Ng course first."
"I'll start when I have more time."

Build ugly. Learn why it's ugly. Fix it.

💾 Save for your next "where do I even start" spiral
♻️ Repost if you've bookmarked 47 courses and finished zero

Everyone's building AI agent demos.

Palantir shipped an end-to-end agentic architecture.

12 layers. The ENTIRE production stack. Here's what's inside:

1️⃣ Secure LLM integration
GPT, Gemini, Claude, Llama, Meta: commercial and open-source. Zero data retention by providers. Swap models without rebuilding.

2️⃣ Context Engineering
Real-time, pro-code and no-code. Contextual data, contextual logic, and systems of action feeding the Ontology.

3️⃣ The Ontology
Not a data lake. A digital twin with semantic, kinetic, and dynamic layers. Human+AI decision model built in. This is their moat.

4️⃣ Agent Lifecycle
Agent building, orchestration, and evaluation suites. All integrated. No stitching 5 tools together.

5️⃣ Security & Governance
Role-based, marking-based, purpose-based controls. System-wide branching. Approvals. Checkpoints. What regulated industries ACTUALLY need.

6️⃣ End-to-end Observability
Every tool call. Every data access. Every decision traced. Full model catalog.

Plus 6 more layers: tool services, multimodal compute, development environments, human+AI applications, package/release/deploy, and enterprise automation.

12 layers. One architecture. Production-ready.

The framework wars were the warmup.

The real game is agentic architecture.

Are you still debating agent frameworks? 👇

♻️ Repost for someone building agents who hasn't seen this architecture

Google just gave every AI coding assistant NATIVE knowledge of how to build agents.

15,600 GitHub stars. One command. FREE.

Your coding assistant doesn't know ADK. It hallucinates APIs and invents methods that don't exist.

Here's why this changes everything:

npx skills add google/adk-docs/skills -y

One command. Your coding agent now knows:

1️⃣ ADK Cheatsheet
Full Python API reference. Every method, every parameter. No more hallucinated imports.

2️⃣ ADK Dev Guide
Development lifecycle and coding guidelines. The patterns Google's own team uses.

3️⃣ ADK Deploy Guide
Agent Engine and Cloud Run deployment. Prototype to production in the same workflow.

4️⃣ ADK Eval Guide
Evaluation methodology and scoring. Test your agents before they hit production.

5️⃣ ADK Observability Guide
Tracing, logging, and integrations. See what your agents are ACTUALLY doing.

6️⃣ ADK Scaffold
New agent project in seconds. Right structure from the start.

Works with everything:

⚡ Claude Code: one command install
⚡ Cursor: MCP server config
⚡ Gemini CLI: extension install
⚡ Any MCP-compatible tool

Plus a docs MCP server that connects your editor directly to ADK documentation. Always up to date. Machine-readable.

What this replaces:

Hours of Googling API docs → $0
Debugging hallucinated methods → $0
Manually reading changelogs → $0

ADK has 15,600 stars, 2,800+ dependent projects, and now ships in Python, TypeScript, Go, and Java.

Google isn't just building an agent framework.

They're teaching YOUR coding assistant how to use it.

🔗 Install skills: npx skills add google/adk-docs/skills -y
🔗 Full docs: google.github.io/adk-docs

Are you still letting your coding assistant hallucinate ADK APIs? 👇

♻️ Repost for someone building with Google ADK who doesn't know about this

Google just dropped a FREE agent starter pack.

One command. 60 seconds. Full production stack.

3,100+ GitHub stars. Here's why:

5 agent templates, ready to deploy:

1️⃣ ReAct agent (ADK)
2️⃣ RAG agent: document retrieval + Q&A
3️⃣ Multi-agent with A2A Protocol
4️⃣ Live API: real-time multimodal
5️⃣ LangGraph base

That's the starting point. The infrastructure is what makes it DIFFERENT:

⚡ Cloud Run + Agent Engine deployment
⚡ Terraform configs included
⚡ CI/CD with Cloud Build + GitHub Actions
⚡ Vertex AI evaluation built in
⚡ Interactive playground for testing

One command:

uvx agent-starter-pack create my-awesome-agent

No boilerplate. No config hell. No "works on my machine."

Google gave away what most teams spend weeks building.

For $0.

Which template are you starting with? 👇

♻️ Repost for someone building agents from scratch

The complete AI Agents learning stack for 2026.

31 resources. Every single one free.

Most engineers bookmark 50 resources and finish ZERO.

This isn't a bookmark dump. It's a 5-phase path:

📹 UNDERSTAND

1️⃣ Intro to Large Language Models (Karpathy) → https://lnkd.in/egCPxzEx
2️⃣ Deep Dive into LLMs (Karpathy) → https://lnkd.in/euMCHnyv
3️⃣ Agentic AI Overview (Stanford) → https://lnkd.in/etjh6sYZ
4️⃣ Building and Evaluating Agents → https://lnkd.in/e45S6ZcZ
5️⃣ Building Effective Agents → https://lnkd.in/eKEaupVF
6️⃣ Building Agents with MCP → https://lnkd.in/eVhWN9kK
7️⃣ Building an Agent from Scratch → https://lnkd.in/eY3c5npC

📜 READ THE SCIENCE

1️⃣ ReAct → arxiv.org/abs/2210.03629
2️⃣ Chain-of-Thought Prompting → arxiv.org/abs/2201.11903
3️⃣ Tree of Thoughts → arxiv.org/abs/2305.10601
4️⃣ Reflexion → arxiv.org/abs/2303.11366
5️⃣ Toolformer → arxiv.org/abs/2302.04761
6️⃣ Generative Agents → arxiv.org/abs/2304.03442
7️⃣ RAG Survey → arxiv.org/abs/2312.10997

🗺️ STUDY THE ARCHITECTURES

1️⃣ Google's Agent Whitepaper → https://lnkd.in/ejiEnCdK
2️⃣ Building Effective Agents (Anthropic) → https://lnkd.in/ew-rnBgD
3️⃣ OpenAI's Practical Guide → https://lnkd.in/ef2vzH2C
4️⃣ Claude Code Best Practices → https://lnkd.in/eRBfw9k5
5️⃣ Google's Agent Companion → https://lnkd.in/eezmZrVs

🧑‍🏫 BUILD

1️⃣ HuggingFace Agent Course → https://lnkd.in/gxSFVqhY
2️⃣ MCP with Anthropic → https://lnkd.in/efqmGWaR
3️⃣ Agent Design Patterns → https://lnkd.in/gHhvHAKq
4️⃣ Multi-Agent Systems → https://lnkd.in/gkg3qzMG
5️⃣ Building Browser Agents → https://lnkd.in/etMGU_bi
6️⃣ Computer Use with Anthropic → https://lnkd.in/edR3Qg94
7️⃣ Evaluating AI Agents → https://lnkd.in/eFFiUue5
8️⃣ Building & Evaluating RAG Apps → https://lnkd.in/gWAbB363
9️⃣ Agent Memory → https://lnkd.in/eCf57tqh

🗂️ SHIP

1️⃣ GenAI Agents → https://lnkd.in/gykAzWMt
2️⃣ Microsoft AI Agents for Beginners → https://lnkd.in/efzMR5aU

5 phases. 31 resources. $0.

Bootcamps charge $5,000+ for LESS.

Which phase are you starting with? 👇

♻️ Repost for someone who wants to build agents but doesn't know where to start.

RAG, CoT, ReAct, RLHF, LoRA, MoE

What do these acronyms actually mean?

If you're breaking into AI engineering, these come up constantly. 

Here's the breakdown:

🔹 RAG (Retrieval Augmented Generation)
Instead of relying only on what the model "knows," you retrieve relevant documents and feed them into the prompt. Reduces hallucination. Powers most production AI apps.

🔹 CoT (Chain of Thought)
Prompting the model to "think step by step" before answering. Dramatically improves reasoning on complex tasks. Free performance boost.

🔹 ReAct (Reasoning + Acting)
Agent pattern where the model alternates between thinking and taking actions. Think → Act → Observe → Repeat. Foundation of most agent frameworks.

🔹 RLHF (Reinforcement Learning from Human Feedback)
How ChatGPT became ChatGPT. Train the model to prefer outputs humans rate highly. Why models are helpful instead of just predictive.

🔹 LoRA (Low-Rank Adaptation)
Fine-tune a model by training only a small number of new parameters. Makes fine-tuning accessible without massive GPU costs.

🔹 MoE (Mixture of Experts)
Model architecture where only a subset of parameters activate per token. How Mixtral and Nemotron run 30B+ params on consumer hardware.

Frameworks change every quarter.
These acronyms won't.

💾 Save for your next "wait, what does that stand for?" moment
♻️ Repost so they don't have to ask you.

taplio

The Battle

Alex Razvant

Paolo Perrone

Followers

Posts

Engagements

Likes

Performance ScoreAlex Razvant's LinkedIn Performance

Performance ScorePaolo Perrone's LinkedIn Performance

Ready to grow your LinkedIn presence?

taplio

The Battle

Alex Razvant

Paolo Perrone

Followers

Posts

Engagements

Likes

Performance Score.css-goub6s{font-size:var(--chakra-fontSizes-md);font-weight:500;color:var(--chakra-colors-gray-600);display:block;margin-top:var(--chakra-space-1);}Alex Razvant's LinkedIn Performance

Performance ScorePaolo Perrone's LinkedIn Performance

Ready to grow your LinkedIn presence?

Performance ScoreAlex Razvant's LinkedIn Performance