Simple explanation of the usefulness of the Riemann proof (so far) is that it removes the conditional nature of other math theorems dependent upon it.
And, of course, is yet another mind-blowing thing achieved by super intelligence …
nitter.gq/i/grok/share/bGVnYWN5_…
don't ruin your life with cs 229, go this way; math 51 or cme 100, cs 109 & cs 229, thank me later
7
#swahilijs retweeted
Build 10 end-to-end AI/ML projects that actually showcase your skills to recruiters.
amanxai.com/2026/11/20/10-en…
#swahilijs retweeted
Learn LLM inference, build real stuff, and thank me later
All you need to get started
> kipp.ly/transformer-inferenc…
>huggingface.co/docs/transfor…
> docs.vllm.ai/
> github.com/sgl-project/sglan…
> arxiv.org/abs/2205.14135
#swahilijs retweeted
Why KV cache stores K and V vectors but never Q?
(a popular technical LLM interview question)
An LLM writes text one token at a time, and it predicts each new token from all the tokens before it.
Without a cache, the model would process the whole prompt again at every step. The KV cache exists to skip that repeated work, and what it keeps shows how attention actually works.
Inside each attention layer, every token produces three vectors. The query (Q) describes what the token is looking for, the key (K) describes what it offers to other tokens, and the value (V) carries the content it passes along.
After a forward pass, every position ends with a hidden state, its final vector. Only the last position's hidden state becomes logits, the scores for the next token.
So the real question is what that last hidden state depends on. Here's how a 4-token prompt produces token 5 (follow along with the visual below):
↳ In prefill, the model reads all 4 tokens in one parallel pass, and every layer computes a Q, K and V for each token.
↳ In the last layer, only the last token's row feeds the prediction, so its query Q₄ is compared against every key from K₁ to K₄.
↳ Softmax turns those scores into weights, which blend V₁ to V₄ into a single output row.
↳ The feedforward block processes each position on its own, so that row becomes the last hidden state, and the next token is picked from it.
That final vector needs only the newest query, along with every key and value.
Now token 5 joins. Each layer computes Q₅, K₅ and V₅ for it, then compares Q₅ against K₁ to K₅.
K₁ to K₄ and V₁ to V₄ are exactly what the model computed in the previous step. The causal mask stops any token from looking at tokens after it, so adding token 5 can't change them.
Q₄ only ever served row 4, and that row is already finished. No future step will read it again.
So the cache keeps every K and V, while each step creates one fresh query, uses it once, and discards it.
The visual below shows the complete flow.
- Only the last hidden state predicts the next token.
- That state needs the newest Q plus every K and V.
- Old K and V never change, so they're cached, while each Q is used once and discarded.
I've quoted my full breakdown of KV caching below if you want to go deeper.
#swahilijs retweeted
Introducing Qwen3.8-27B-pi-adapted 🤗
We adapted Qwen's model specifically for the pi coding agent using reinforcement learning and a LoRA adapter.
The results, measured as pass@1:
🚀 SWE-bench Pro (Hard 51): 29.4% → 62.7%
💻 Terminal-Bench 2.1: 39.5% → 55.8%
⚡ 55–62% fewer tool calls per task
This is the power of open models: you can adapt them to YOUR tools and YOUR use cases. Let’s build! 💛
Open weights: huggingface.co/harness-hub/Q…
Methodology: huggingface.co/blog/harness-…
#swahilijs retweeted
System Design: The Ultimate Learning Roadmap
├── 01 Fundamentals
│ ├── Client-Server Architecture
│ ├── HTTP, DNS & Networking
│ └── Latency, Throughput & Availability
│
├── 02 Data Structures & Algorithms
│ ├── Arrays, HashMaps & Trees
│ ├── Time & Space Complexity
│ └── Searching & Sorting
│
├── 03 Database Fundamentals
│ ├── SQL vs NoSQL
│ ├── Indexing & Query Optimization
│ └── ACID & Transactions
│
├── 04 API Design
│ ├── REST, GraphQL & gRPC
│ ├── API Versioning & Pagination
│ └── Authentication & Rate Limiting
│
├── 05 Scalability & Performance
│ ├── Horizontal vs Vertical Scaling
│ ├── Load Balancing
│ └── Caching Strategies
│
├── 06 Distributed Systems
│ ├── CAP Theorem & Consistency
│ ├── Replication & Sharding
│ └── Consensus & Fault Tolerance
│
├── 07 Messaging & Event-Driven Systems
│ ├── Kafka, RabbitMQ & SQS
│ ├── Pub/Sub & Event Streaming
│ └── Retries & Idempotency
│
├── 08 Storage & Data Processing
│ ├── Object Storage & CDN
│ ├── Relational vs Distributed Storage
│ └── Batch & Stream Processing
│
├── 09 Microservices Architecture
│ ├── Service Discovery & API Gateway
│ ├── Saga & Circuit Breakers
│ └── Service-to-Service Communication
│
├── 10 Security & Reliability
│ ├── OAuth2, JWT & RBAC
│ ├── Encryption & Zero Trust
│ └── Disaster Recovery & Backups
│
├── 11 System Design Patterns
│ ├── CQRS & Event Sourcing
│ ├── Strangler Fig & Sidecar
│ └── Leader-Follower Architecture
│
├── 12 Observability & Infrastructure
│ ├── Logs, Metrics & Distributed Tracing
│ ├── Docker & Kubernetes
│ └── CI/CD & Infrastructure as Code
│
└── 13 Real-World System Design
├── Design URL Shortener
├── Design WhatsApp
├── Design YouTube
├── Design Uber
└── Design Netflix
System Design isn't just about drawing architecture diagrams.
It's about building scalable, reliable and fault-tolerant systems that handle real-world traffic.
Save this roadmap.
Learn one concept at a time.
Practice designing real-world systems.
The goal isn't just to design systems. It's to build systems that scale.
"And he informed me, and talked with me, and said, ‘O Daniel, I have now come forth to give you skill to understand.’" Daniel 9:22
May God give us the skill to understand, and the grace to fulfill our purposes.
32
#swahilijs retweeted
We entered the era of custom inference engine vibe coding.
None of this would be possible without projects like SGLang, vLLM, and llamacpp.
We are so lucky they are open source.
#swahilijs retweeted
NVIDIA released a new looped transformer:
Instead of stacking more layers, it runs the same layers multiple times so a 4B model can think like a 9B one.
Here's how it works:
In a standard transformer, every token passes through a stack of decoder blocks once, and each block has its own weights.
So if you want a deeper model, you add more blocks, and the parameter count grows with the depth.
NVIDIA's Dory1.0-4B decouples the two by reusing a chunk of its layers.
The model is split into three parts:
> An input block of 8 blocks runs once and turns the tokens into a hidden state x.
> A recurrent block of 20 shared blocks runs k times, where k can be anywhere from 1 to 4.
> An output block of 8 blocks runs once on the final state, followed by the LM head.
Before every pass through the recurrent block, x is added back to the current state and the sum is L2-normalized.
This keeps the original token representation in view on every pass, instead of each pass only seeing what the previous one produced.
Both models in the diagram below store 36 blocks of weights.
The standard transformer applies each block once, while Dory applies 36 blocks at k=1, 56 at k=2, and 96 at k=4, i.e., 72, 112, and 192 physical layers from the same checkpoint.
The extra depth is actually helpful on reasoning and agentic tasks:
> SWE-bench Verified:
- at 1 loop → 50.3
- at 2 loops → 59.5
- at 4 loops → 61.8
> 12-benchmark average:
- at 1 loop → 35.17
- at 2 loops → 39.67
- at 4 loops → 40.60
- and with 2 or more loops, it beats Qwen3.5-9B, Gemma 4 12B, and Gemma 4 26B-A4B.
More loops implies more compute per token, but the 4-loop model also writes 1.3x to 2.5x fewer output tokens on agentic tasks.
So 2 loops end up costing only 1.03x to 1.25x the compute of 1 loop end to end, which is why NVIDIA recommends 2 as the default.
By default, Dory keeps a separate KV cache for every loop, so at 4 loops the recurrent layers store 4x the cache.
To avoid this, it can keep only the cache from the last loop, which uses the same KV memory as a normal model with only a small change in accuracy.
One thing to note here is that looping helps the model reason over what it already knows, but it does not add knowledge.
For instance, on tasks like AA-Omniscience, accuracy stays at 10.0 whether you run 1 loop or 4, and on knowledge-heavy tasks like GPQA, Dory still trails Qwen3.5-4B.
Here's the paper: arxiv.org/abs/2611.03998
That said, how much memory looping costs comes down to how the KV cache is handled, so I wrote a full breakdown of how KV caching works.
It covers what gets cached during prefill, how the cache grows during decoding, and why it becomes the main memory bottleneck at long context.
Read it below.
#swahilijs retweeted
Nothing exposes a fool faster than a conversation with someone who actually knows what they're talking about.
#swahilijs retweeted
If you can complete Stanford’s CS336 (Language Modeling from Scratch) and CS230 (Deep Learning) assignments, you can build and train custom LLMs from the metal up.
The full lecture playlists are public on YouTube.
Cost: $0.
#swahilijs retweeted
Former Scale AI founder and newly appointed @Meta Chief AI Officer @alexandr_wang dropped a bombshell during his YC conversation with @garrytan, and you could almost hear the tech leadership world go quiet.
He said Meta has already seen this internally:
Build the right agentic loop, give it an evaluation system and metrics that let it optimize itself, and a group of AI agents can complete more work than a team of 100 senior engineers.
And they do it “very easily.”
But the most interesting part wasn’t the 100-engineer comparison.
It was how simple the system underneath it actually is.
You’d expect some insanely complex, almost alien architecture powering a swarm like this.
Instead, Wang described it with a few almost comically basic words:
“Markdown files, cron jobs, goal, metrics, data.”
Once you strip away the hype, the implications for traditional software engineering become pretty clear:
1️⃣ It’s not that the models are magically smarter. The eval loop is doing the heavy lifting.
Traditional approach: humans write prompts, run the code, inspect the output, and hope nothing broke.
Meta’s approach: turn the business goal into something a machine can score automatically.
The agent submits its work. The system runs tests, calculates metrics, finds what’s wrong, and sends it back for another pass. Repeat until it passes.
Nobody has to babysit every step. The metric becomes the supervisor.
2️⃣ The real alpha is burning 1,000x more tokens inside the feedback loop.
A lot of people are still optimizing for the cost of a single AI call.
The frontier labs are playing a different game: spend 1,000x or even 1,000,000x more tokens in the background so agents can constantly review, rerun, challenge, and verify each other’s work until they reach a reliable business outcome.
Token cost is fixed. The payoff is a pipeline that keeps running.
3️⃣ Memory doesn’t need some fancy database.
Persistent memory can live in Markdown files.
Scheduling can be handled by the server’s built-in cron jobs, running overnight.
The simpler the scaffolding, the more robust the system can be. Less infrastructure also means fewer ways for context to fall apart.
This is a pretty brutal change in how technical organizations work.
The ceiling for a tech lead used to be partly about how many people they could manage, how many meetings they could sit through, and how many teams they could coordinate.
The leverage for the next generation of technical leaders may look very different:
Can you turn a messy business objective into a rigorous set of metrics that an AI can evaluate automatically?
If 100 people’s output can be replaced by a few cron jobs, Markdown files, and a well-designed eval loop, the era of “just take the ticket and write the code” is coming to an end.
The people who can design the evals and orchestrate the swarm aren’t just holding a new tool.
They’re effectively running a virtual company.
#swahilijs retweeted
Google Brain founder Andrew Ng:
"Prompting will be dead in 6 months"
"Loops and graphs are replacing it"
In just 2 hours, he shows how to build agents that work, learn, and improve on their own
LLMs → Agents → Loops → Graphs → Self-Improving Systems
The first 15 minutes alone are more valuable than most $500 AI courses
Most people are still learning prompts while AI engineering is already moving beyond them
Watch the lecture first
Then read the full guide to loops and graphs below ↓
Use PyTorch-native libraries within the NVIDIA NeMo Framework to customize models to hit your exacting requirements for latency, speed, memory, and compute.
@NVIDIA's blog demonstrates how quantization-aware distillation (QAD) improves the Nemotron 3.5 Lightning model using NVIDIA Model Optimizer. We walk through the entire training pipeline, and show how QAD consistently outperforms post-training quantization (PTQ) compression on agentic benchmarks, ensuring high quality while reducing memory usage.
Read it here: developer.nvidia.com/blog/de…






















