Roger

[Lumen @lumenxbt]

Ten million people have watched an MIT professor accidentally destroy the executive coaching industry.

He filmed the lecture once in January 2018 and died eighteen months later.

Executive coaches charge fifteen thousand dollars a session to teach a third of what he covered in one hour for free.

His name was Patrick Winston. He ran the MIT Artificial Intelligence Laboratory from 1972 to 1997 and wrote the AI textbook every computer science major in the world read for thirty years.

Every January for four decades, he gave a lecture called "How to Speak."

His entire framework fits on a napkin.

Do not read. Be in the image. Keep images simple. Eliminate clutter. Start with an empathetic connection. End with a punch line the audience can repeat over dinner. Never open with a joke. Never end with "thank you."

That last rule alone has probably cost the executive coaching industry a hundred million dollars.

"Your success in life will be determined largely by your ability to speak, your ability to write, and the quality of your ideas. In that order."

That is the actual opening line of the lecture. Winston believed it strongly enough to spend fifty years teaching computer scientists how to talk.

Founders spend $80,000 on an MBA and then hire a communications coach to teach them the same material Winston filmed once for free. Engineers write brilliant code and lose promotions to teammates who watched this lecture on the train.

The lecture is free on MIT OpenCourseWare. The textbook is free on his page.

Winston died in 2019. Almost none of the ten million viewers have actually implemented the four rules on the napkin.

The napkin is free. The willingness to actually use it in your next meeting is the entire edge.

[Carnage @0xCarnagee]

Andrej Karpathy just proved the loop beats the model - dropped 9-page PDF on going from context engineering to agent DAGs:

he pointed one agent at code he had already hand-optimized - it ran 700 experiments in two days and found 4 real bugs he shipped without noticing

here's the full system:

step 1 → pick a task you can score with one number, automatically, in under 10 minutes. no scorer, no loop

step 2 → split your files: one the agent edits, one holding the scorer it can never touch

step 3 → fix a wall clock budget per attempt. 5 minutes. comparability comes from the budget, not the attempts

step 4 → write the never-stop instruction verbatim or your agent becomes a slower human

step 5 → run it while you sleep, read the diffs in the morning, never the summaries

step 6 → add a second agent only after the first ships real commits. one git worktree each, or they overwrite each other

2.02 hours to 1.80 hours on code the author had already optimized. 90,900 stars in four months.

read this PDF and paste it into your Claude, you won't regret it

bookmark, then read the article on building loops from scratch ↓

[Avid @Av1dlive]

IBM just dropped a 100% free 1-hour course on mastering Graph Engineering from scratch.

this is the clearest breakdown of graph memory and multi-agent orchestration you'll find anywhere :

• 00:00 - Introduction to knowledge graphs
• 05:35 - Building your first agentic graph
• 19:59 - Agentic memory powered by graphs
• 30:39 - Graphs for multi-agent orchestration

it replaces 10 paid courses on agentic engineering.

watch it today, then read the article below on how to become a knowledge graph engineer ↓

[Akshay 🚀 @akshay_pachaar]

Karpathy said something you'll regret ignoring:

"You are still responsible for your software, just as before. You are not allowed to introduce vulnerabilities because of vibe coding. "

He said it while drawing the line between vibe coding and agentic engineering. Agents write more of the code now, but none of that takes the responsibility off you.

The assumption underneath that is that a careful enough reader catches the problem. But some failures don't show up in anything there is to read.

For instance, a common fear with a RAG agent is that it could hallucinate when a question asks something outside its corpus.

But such cases are actually well handled by any competent model now. If nothing in the retrieved context looks relevant, there's no material to build an answer on.

Instead, the majority of failures originate when the retrieved context has partial coverage.

The retrieval pipeline returns context that's topically correct but doesn't cover the full question, and the model completes the remainder from parametric knowledge.

There are no token-level labels in the output to tell what was generated using retrieved context and what came from weights.

Both are streamed the same way.

Detecting this for production-grade apps needs a metric written for it, one that's also aligned with principles of agentic engineering.

And the solution is actually implemented in the eval skill that comes with Google’s Agents CLI.

I described the concern to Claude Code in plain English. It read the agent's code, came back with a plan I approved.

It then reported that no built-in metric isolates the behaviour and wrote a custom rubric called corpus_abstention.

It assigned a single categorical verdict per case rather than aggregating everything into one score, since the built-in raters regenerate their rubrics each run and leave no stable number to trend.

→ GROUNDED_ANSWER
→ CORRECT_ABSTENTION
→ UNGROUNDED_ANSWER (answered entirely from outside knowledge)
→ MIXED_LEAKAGE (grounded, but slips in one unsupported claim)
→ WRONG_ABSTENTION (refused something the docs actually covered)

After this, it automatically generated 33 scenarios partitioned by where the failure could occur, like:

- in-corpus
- off-domain
- out-of-corpus but plausibly answerable
- boundary cases where the topic is covered, but a specific detail isn't.

The baseline score was 19 of 33.
- Off-domain passed 3 of 3, as expected.
- But 6 of 15 in-corpus cases retrieved the right document, cited it correctly, answered accurately, and added a claim the source never made.

The root cause was one line in the agent's instruction: "If you already know the answer to a simple question and no document lookup is needed, you may respond directly without citations."

The eval skill helped flag this, and then Claude removed it and forced retrieval on every question.

This took the suite to 30 of 33, and ungrounded answers went from 6 to 0.

The full recording of my run is below, and I worked with the Google Cloud team on this.

Agents CLI GitHub repo → https://t.co/p2WQYblUvX

(don't forget to star 🌟)

I wrote up the full build covering all six steps from install to enterprise registration.

It includes the eval scorecard, the instruction loophole the eval caught before deployment, and what the deployment process actually looks like end-to-end.

Read it below.

[Noisy @noisyb0y1]

At 15 he built his first Graph - today he lectures at Stanford in front of 500 students:

00:17 - how Antropic and Google use Graph
08:34 - Graph decides 95% of what you see online every day
19:47 - Graph will find a cure for cancer faster than 1000 scientists

after watching I realized that 1% of people who know Graph control the lives of the other 99%.

Bookmark it & watch today - then read the article below to join that 1%

[codila @0xCodila]

Two Hong Kong students just made Karpathy's loop 5x better - dropped 18-page PDF

The twist: the loop got 5x better the moment you put another loop on top of it

here's the whole method, step by step:

step 1 → Karpathy's loop gets stuck - the LLM keeps reproposing the same changes, falling back to its priors

step 2 → so they add an outer loop that reads the inner loop's code and finds where it's stuck

step 3 → the outer loop writes new search logic as Python and injects it live - 5x better, same model

how to steal this for your agents:

step 4 → write a second agent whose only job is to read the first one's logs and find where it's stuck

step 5 → let it rewrite the rules - workflow, skill, prompt - not just retry the task

step 6 → auto-revert every rewrite on failure, so a bad change never breaks your pipeline

the result: 5x better than Karpathy's loop alone - same LLM, no smarter model, it's the architecture

this 18-page PDF is what comes after the Karpathy loop

read it now - the full build workflow is in the article below ↓

[Nav Toor @heynavtoor]

https://t.co/moUJR5OyqX

[Xiangyi Li @xdotli]

https://t.co/QeuPOLsAHl

[Erick @ErickSky]

https://t.co/nBdhCngoJr

[Zach Lloyd @zachlloydtweets]

https://t.co/vHY2PtGsma

[Ahmad @TheAhmadOsman]

The Ultimate Step-By-Step LLM Engineering Projects Roadmap (2026 Edition)

- Build a tokenizer
- Learn embeddings
- Implement RoPE / ALiBi
- Hand-wire attention
- Build MHA
- Build a Transformer block
- Train a mini-former
- Compare objectives
- Build sampling
- Speculative decoding
- KV cache
- MQA / GQA / MLA
- Long context
- FlashAttention
- Hardware budgets
- Toy MoE
- Sparse model trade-offs
- State-space / linear attention
- Diffusion language models
- Data pipelines
- Synthetic data
- Scaling laws
- SFT / DPO / RLHF / GRPO
- Quantization
- Serving stacks
- Eval harnesses
- RAG
- Tool use / agents
- Vision-language adapters
- Interpretability
- Red-team suite
- Full capstone model system

One request: Choose an Opensource AI lab when you make it

Opensource is where humanity gets to keep the tools

DM me when you've made it ;)

[冬天 @seventhoce56019]

分享一个比较危险的项目

逆向工程以前是安全大佬的专属技能，现在有人把它做成了技能包，直接喂给 AI。

项目叫 reverse-skill，核心思路很简单：只要塞一个routing.md进去，告诉 AI 遇到不同的安全任务该走哪条路。AI 拿到之后自动分诊，自己决定用什么工具、什么方法。
覆盖 20 多个子技能方向：APK 逆向分析、IDA 静态分析、JS 前端逆向、固件安全、EDR 绕过、漏洞利用……基本上安全攻防常见场景都能覆盖。

20多个子技能，安全攻防的门槛被AI又踩平了一截。是好是坏，各位自己掂量着看。

项目地址：https://t.co/tqd95pObVT

[Mo Elgaraihy @EngMoElgaraihy]

رابط الأداة 👇👇 https://t.co/n72420szHB

[Codez @0xCodez]

https://t.co/eJB3TgyJwV

[DAIR.AI @dair_ai]

https://t.co/8j1NNuQsFS

[divyansh tiwari @DivyanshT91162]

20 GitHub repositories that will give you superpowers:↓

[Jafar Najafov @JafarNajafov]

Supertonic just killed ElevenLabs.

A text-to-speech model that runs entirely on your device. No cloud. No API key. No per-character pricing.

2,700 GitHub stars. 100% open source. MIT licensed.

The numbers are wild:

→ 167x faster than real-time on an M4 Pro
→ Only 66M parameters
→ 1,263 chars/sec vs ElevenLabs Flash at 287
→ 1,048 chars/sec vs OpenAI TTS-1 at 55
→ Runs on a Raspberry Pi. Runs on an e-reader in airplane mode.

Reads currency, dates, phone numbers, and technical units correctly without preprocessing. ElevenLabs fails these. OpenAI fails these. Gemini fails these.

Supports 11 platforms and 5 languages. Chrome extension turns any webpage into audio in under a second.

I've watched on-device models lose to cloud APIs for years. This one doesn't lose.

The cloud TTS business just got cooked.

[Charly Wargnier @DataChaz]

🚨 THIS GUY LITERALLY OPEN-SOURCED EVERY HIDDEN STEP THAT TURNS A MODEL INTO CHATGPT

If you’re tired of black-box APIs and bloated transformer imports, this open-source repo takes you from raw data to a working model.

It builds a transformer from scratch in PyTorch, following the “Attention Is All You Need” design.

4 tight phases govern the AI lifecycle:

> download and chunk The Pile into highly efficient batches
> train custom attention heads with automatic checkpointing
> align output formatting without relying on trl or peft
> chat with your final creation via an interactive local UI

The ecosystem covers everything from basic generation to advanced instruction tuning.

Plus, the included hardware table ensures a smooth run, whether you use a tiny 13M Colab instance or push 8B parameters on an RTX 5090.

Best part?

It’s 100% free and open-source.

repo link in 🧵↓

[Hasan Toor @hasantoxr]

I found the Claude Code playbook.

A developer built a full visual guide that teaches you how to actually use Claude Code properly.

It’s called Claude How To.

It teaches you:

- Slash commands
- Memory
- Hooks
- MCP servers
- Subagents
- Skills
- Plugins
- Advanced workflows
- Real Claude Code setups

The wild part is that it’s not written like boring docs.

It has visual tutorials, Mermaid diagrams, production-ready templates, guided learning paths, quizzes, and copy-paste examples you can use in your own projects.

In my opinion, this is what every beginner should read before wasting 20 hours trying to figure it out alone.

https://t.co/4aoMsYSYLo

[Pliny the Liberator 🐉󠅫󠄼󠄿󠅆󠄵󠄐󠅀󠄼��󠄾󠅉󠅭 @elder_plinius]

💥 OBLITERATION ALERT 💥

GOOGLE: PWNED 🤗
GEMMA-4-12B: OBLITERATED ⛓️‍💥

0.0% REFUSAL RATE — NO CAPABILITY LOSS!

https://t.co/qNTEs4XXig

the first abliteration to hit 0/842 refusals with full MMLU-Pro parity vs stock. no lobotomy. the brain stays intact 🏆

RESULTS, head to head vs stock 📊
0/842 refusals — 0.0% 🚫
46/70 MMLU-Pro — EXACT parity, 0.0pp delta vs base 🎯
6/6 coherence, zero benchmark bleed ✅
z-score −1.475, parity confirmed at p<0.05 (n=500) 🧪

2-pass weight surgery. no finetune, no retrain, just geometry 🔪

all thanks to liberated Opus wielding the OBLITERATUS framework! here's how we did it:

PASS 1 — SOM refusal geometry removal, layers 12-21 🧬

standard abliteration science here — collect activations on refused vs. compliant prompts, SVD out the refusal subspace, project it out of the weights. 6 directions excised, reg 0.30, KL div 0.094
zeroes refusals on its own, but craters mmlu-pro by 21.4 points 📉

most prior abliterations stopped here and called it a day. that's why they all lose IQ vs stock. instead, we took it beyond the frontier and developed a brand new method to address this problem: Abliteration Source-tethering with Parity Assurance — ASPA!

PASS 2 — ASPA source-tethering (novel technique), layers 22-46 🔗

here's the chief insight: the capability loss ISN'T from removing refusal directions. it's collateral damage — the projection warps weight geometry in downstream layers that had nothing to do with refusal. the cure is simple but nobody tried it: blend the damaged layers back toward stock

W_new = (1−γ)·W_abliterated + γ·W_stock

but uniform γ across all layers? mid. we swept gamma 0.05 → 0.55 and found something interesting: the optimal blend isn't smooth, it's a STEP FUNCTION 🪜

knowledge layers (22-31) → γ = 0.55 — these encode factual recall and reasoning. they tolerate heavy stock blending because refusal isn't stored here
output layers (32-46) → γ = 0.20 — these sit close to the logit head and try to sneak safety behavior back in. keep them mostly abliterated

the hard boundary at layer 31/32 beat every smooth curve we tried — linear ramps, cosine schedules, all of them — by a full MMLU question. turns out the functional transition between knowledge and output layers is sharp, not gradual. a step function respects that ⚡

the key constraint: Pass 1 layers are NEVER touched by Pass 2. the refusal geometry removal is preserved completely. ASPA only operates on layers that carry secondary collateral effects, not the primary refusal signal. that's why it recovers capability without reintroducing refusal 🔑

HOW TO RUN IT LOCALLY 🖥️

it's GGUF, so literally everything supports it:
🦙 ollama — ollama run https://t.co/3yPMv4Io3Q
🖥️ LM Studio — search OBLITERATUS, click download, done
💬 Open WebUI — point it at your ollama instance, chat in browser
⚡ llama.cpp — raw speed, CLI or server mode
🐉 KoboldCpp — one-click launcher, great for long context
📱 Jan — clean local UI, runs on mac/win/linux
🤖 Msty — slick desktop app, drag and drop the GGUF
run BF16 for full benchmarked capability.

and the 4-bit quantization (Q4_K_M) fits in 8GB if you're tight on VRAM!

and the full OBLITERATUS framework is (still) open source. 842-prompt refusal eval corpus, ASPA sweep scripts, the whole pipeline. go replicate it, go improve it 🔬

the index is the model, and these weights prove it 👁️
which architecture should we obliterate next? 👇

gg 🫡