Miff

[Aarno @TheGlobalMinima]

In nearly 5 years of modern generative ai, this is the first book I’m seeing with a super high level of coverage and comprehension.
> language modelling
> inference optimisation
> RL and its methods
> system scaling
> applied concepts like agentic ai, rag, memory
> environments and benchmarking

These fields have a subtle boundary differentiating them, but ultimately overlap in modern applications. Agents require system scaling, memory needs inference optimisation, rl requires understanding of environments and benchmarks.

For the first time in my exp, all in one place. Found this on paperswithcode[.]co

[Justin Skycak @justinskycak]

Every student needs to read "You Are NOT Dumb, You Just Lack the Prerequisites" by @lelouchdaily.

"It’s like walking into a movie halfway through—you can’t understand the plot because you missed the beginning."

Unfortunately, those who need to hear it most, seldom do.

[Roan @RohOnChain]

this is f*cking dangerous

someone just open sourced the entire "LOOP ENGINEERING" framework for free

build a hedge fund printing alpha 24/7 by feeding it into claude code with my article below

bookmark before someone takes it down

[梭哈.AI @SUOHA_AI]

如果你想加入世界顶级的AI公司，这篇笔记能帮你少走很多弯路

Alisa Liu 是华盛顿大学（UW）的 NLP PhD 学生，她最近拿到了 OpenAI Research Scientist 的 offer，并分享了一篇非常实用的求职笔记

她是怎么备战的？

先建立广度：把 Stanford CS336《Language Modeling from Scratch》全部 lectures 看完，这门课帮她把散落的知识点串成一个清晰的整体框架

再深度突破：一个概念一个概念深挖 —— 读 blog + paper + 大量和 ChatGPT/Claude 对话 + 从零实现代码

最关键的是：Transformer 的实现与调试要练到 muscle memory，并且完全关闭 AI 辅助练习 coding（因为真实面试时你必须自己写）

持续��结构化笔记（她有公开的 LLM Notes 可参考）

每个面试前做针对性突击复习，面试当天必须睡够觉（她第一次技术面试只睡 2 小时，结果发挥失常）

学习路径总结：广度先行（CS336）→ 逐个概念深度 + 动手实现 → 针对性面试前 cramming

OpenAI面试主要考什么？

ML Coding（出现频率最高）：用 PyTorch 实现架构、decoding 策略、Transformer 等

General Coding：LeetCode 风格题目

Technical Discussion：实验设计讨论 + 快速概念问答（positional encoding 的不同方式、parallelism、PPO vs GRPO 等）

Research Discussion：讲自己的项目、insight 和未来方向

Behavioral：提前把 PhD 经历整理成故事（她第一场 behavioral 直接翻车，因为没准备）

Math + Job Talk（聚焦自己最核心的方向）

如果你想准备 OpenAI / 类似 lab 的面试，必须精通这些资源

以下是她实际使用的学习资源：

1. 斯坦福大学的“从零开始的语言建模”课
https://t.co/IQrm8EuuoS

2. The Illustrated GPT-2（Jalammar） https://t.co/pZq2BCEhta
用可视化方式快速理解 GPT-2 的内部机制，适合建立直觉

3. Self-Attention & Transformers（CS224n PDF） https://t.co/s7lgCF6j4p
深入理解自注意力机制的核心原理

4. Backpropagation（CS231n） https://t.co/jmEcCRSgtf
手写 backward pass 的基础

5. Introduction to Policy Gradient for LMs https://t.co/hgAIO1cXeC 理解语言模型的策略梯度方法

6. Lightweight Guide to understanding GRPO and RL principles
https://t.co/OGDv7tZBsB
快速掌握 GRPO（近期 RLHF 相关的重要概念）

7. How to Scale Your Model（JAX scaling book） https://t.co/nm1ExirsrF
理解模型 scaling 的工程与理论要点

额外高频练习：
LeetCode（常规 + ML 相关题）

反复从零实现 Transformer（无 AI 辅助）

她的 LLM Notes（学习方法参考）：https://t.co/hsLkZv3NtF

[Codez @0xCodez]

A senior Anthropic engineer just dropped 11-page PDF on "Loop Engineering" for agentic systems.

The shift: you stop prompting the agent. You build the system that prompts it instead.

Schedule → Discover → Build → Verify → Repeat

Every loop runs one turn, five moves:

• Discovery: it finds its own work - failing CI, open issues, recent commits - instead of being handed a list.

• Handoff: each task gets an isolated git worktree so parallel agents don't collide.

• Verification: a second agent, told to assume the code is broken, reviews the first. The "thing that can say no."

• Persistence: results get written to disk, never left in a context window that gets flushed.

• Scheduling: an automation wakes it on a timer. That's what makes it a loop.

The key insight: an agent grading its own work always praises it.

This 11-page PDF changed how I'm building agentic systems today.

Read it now, then explore the article below.

[Movez @0xMovez]

A senior Google engineer just dropped a 19-page PDF on "Loop Engineering" for LLM and agentic systems.

Act → Observe → Learn → Repeat

• Act: the LLM proposes a code transformation (tile this loop, parallelize that one).

• Observe: a compiler runs it and reports back - is it valid? faster? slower? by how much?

• Learn: the LLM reads that feedback and adjusts its next move.

• Repeat until it stops finding improvements.

The agent gets smarter purely from grounded feedback inside its own context window.

This 19-page PDF totally changed the way I’m building agentic systems today.

Read it now, then explore the article below.

[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 ;)

[ℏεsam @Hesamation]

this PhD student had 47 interviews and 4 offers before she was hired at OpenAI.

she practiced with her “notes on LLMs” and math and they’re a goldmine. super concise and organic and shared to everyone for free. you can use her notes or her topic list to study on your own.

[Bober_smart @Bober_smart]

A 19-year-old student from China, Zhang Wei, developed an AI radar and sold it to Hong Kong for $550,000

He created it using Claude, spending just $20 and a month on development

He walked into the Hong Kong administration office with a flash drive and asked for just 5 minutes of their time. 30 minutes later, he walked out with a check for $550,000

The code, connected to a camera, detects speed in real time. If the speed exceeds the limit, Claude takes a video clip and identifies the owner by the car's license plate. The video and the fine are then automatically sent to the owner's email address

Unlike a conventional radar that only takes a photo and doesn't always work, this AI radar eliminates disputes because it captures video and makes the process fully autonomous by sending out the fines on its own

The article includes the ready-to-use configurations.

[Akshay 🚀 @akshay_pachaar]

Web scraping will never be the same.

(100% open-source visual search at scale)

PixelRAG is a retrieval system that skips HTML parsing completely.

Instead of scraping a page into text and embedding chunks, it screenshots the page and retrieves the image. A vision-language model reads the answer straight off the pixels.

Why that matters: parsing is where web RAG quietly loses information.

- A single HTML-to-text parser can drop 40%+ of a page.
- Tables, charts, and layout get flattened or thrown out.
- Swapping parsers alone can move accuracy ~10 points on the same docs.

PixelRAG indexes the page a person actually sees. The team built a visual index of all of Wikipedia, 30M+ screenshots, and it still beats the strongest text RAG baseline by 18.1% on text-only QA.

The repo also ships a Claude Code plugin that gives Claude eyes.

It lets Claude screenshot any URL and read the rendered page instead of scraping the DOM. So you can hand it a live page, an arXiv paper, or your local site and ask what it actually looks like.

One setup script. No MCP server, no backend.

How the pipeline works:

- Renders each document (web, PDF, image) to image tiles.
- Embeds them with Qwen3-VL-Embedding, LoRA fine-tuned on screenshots.
- Builds a FAISS index and serves a search API.

A stronger reader model lifts accuracy with no re-indexing, since the index is just pixels.

Everything is open-source under Apache-2.0.

GitHub repo: https://t.co/qun9TjAdmw

Talking about RAG, I recently wrote an article on a new approach that makes retrieval much more efficient by cutting corpus size by 40x, reducing tokens per query by 3x, and improving vector search relevance by 2.3x.

The article is quoted below.

[Movez @0xMovez]

Claude Code creator:

"At Anthropic, 90% of our engineers are running agents with self-improving loops.

in 3-6 months, everyone will be running /loops - this is the future of engineering"

in a 1-hour podcast, Boris Cherny reveals the best tips for building Claude Code automations.

Claude + loops + routines + dynamic workflows - that’s the secret.

Watch the talk, then read how to apply and build the same setup in the article below.

[Suraj Sharma @suraj_sharma14]

Bro I'm so sick of pretending this isn't weird.

The internet spent 20 years creating tutorials, open-source projects, blog posts & answers for free.

AI companies turned all of it into products worth billions.

And now the same people who created that knowledge are being told they're replaceable.

We built the library.

Someone else started charging admission.

[Miff @Mifftnxae]

@guansi They are stressing the importance of harness around the model, I wonder if this has to do with that

[Roan @RohOnChain]

GOLDMAN SACHS open-sourced most dangerous quant repo on the internet.

THE EXACT FRAMEWORK THEIR INTERNAL DESKS USE TO BUILD & RUN TRADING STRATEGIES.

They even left their Claude skills inside. Plug them in & you've a Goldman Sachs quant building strategies for you. BOOKMARK.

[Path of Men @PathOfMen_]

There's so much power in believing things will work out, even when you don't know how or when.

[Suraj Sharma @suraj_sharma14]

If I had 6 months to become an Agentic AI Engineer.

I'd do this.

Stage 1: Python + Async Foundations
asyncio, FastAPI, event-driven architecture, error handling, API integration patterns.

Stage 2: LLM Fundamentals for Agents
Context management, model routing, token economics, latency tradeoffs, failure modes.

Stage 3: Tool Calling + Structured Outputs
Pydantic validation, function calling schemas, error recovery, dynamic tool discovery.

Stage 4: Memory + State Management
Short-term buffers, long-term vector recall, context compression, cross-session sync.

Stage 5: Single Agent Workflows
ReAct loops, plan-and-execute, self-reflection, iteration limits, graceful degradation.

Stage 6: Multi-Agent Orchestration
LangGraph/CrewAI, supervisor patterns, message passing, conflict resolution, handoffs.

Stage 7: Human-in-the-Loop Systems
Uncertainty detection, approval gates, audit trails, resume logic, intervention points.

Stage 8: Evaluation + Quality Assurance
Automated eval harnesses, LLM-as-a-judge, regression testing, hallucination metrics.

Stage 9: Observability + Tracing
Distributed tracing (LangSmith/Arize), cost dashboards, latency monitoring, alerting.

Stage 10: Security + Guardrails
Prompt injection defense, output filtering, PII redaction, sandboxed execution, compliance.

Stage 11: Production Deployment
vLLM/SGLang, Kubernetes scaling, CI/CD for agents, canary releases, rollback strategies.

Stage 12: Open Source + Portfolio
Ship autonomous agents publicly, write architecture docs, record demos, contribute to libs.

Most people stay stuck watching tutorials.

Builders get hired.

(Bookmark it)

[probiex007 @probiex007]

🤯 This is a website, a simple web-based game built with WebGL and Three.js.
Website: https://t.co/G0cDgaWzKe
It's honestly surprising how far web development has come.

[Miff @Mifftnxae]

@hugolowell @WIRED What does Dario expect with him acting like the wolves are coming to get everyone?? He was spreading fear rhetorics and now he gives the surprise pikachu face when consequences are dealt, I can’t with these tech leaders

[부앙 @gonge_l]

누군지 모르지만 귀여워서 그렸다 🙂‍↕️

[Rahul @sairahul1]

Anthropic pays $750,000+ a year for engineers who can build LLMs from scratch.

Not how to prompt them.
Not how to fine-tune them.
Not how to build RAG pipelines.

But how to build them from scratch.

This 2-hour Stanford lecture teaches you everything.

Scaling laws.
Data collection.
Architecture design.
Post-training alignment.

Free. From Stanford.

Watch first. Then read this.

The lecture is the theory.

And this article shows you how to actually build it (with code) ↓