Rain

make a difference

[Fei-Fei Li @drfeifei]

https://t.co/l3mSj9Ur24

[Rain @yugsuo]

@web4miko 跟方舟是什么关系

[来碗牛肉粉 @beefnoode]

成熟的软件产品和简单的demo或者网页完全是两个概念
我们团队也在开发产品，各种细节问题层出不穷
产品定位、技术选型、交互体验、不断测试修bug、基于反馈迭代优化

AI coding时代想做出60分的产品可能只需要烧一下午token
但想要做90分以上产品，并且留住用户，绝对没有卖课的老师说的这么简单

[Google Research @GoogleResearch]

Introducing TurboQuant: Our new compression algorithm that reduces LLM key-value cache memory by at least 6x and delivers up to 8x speedup, all with zero accuracy loss, redefining AI efficiency. Read the blog to learn how it achieves these results: https://t.co/CDSQ8HpZoc

[LangChain @LangChain]

https://t.co/9WLIjS8Lrk

[Boris Cherny @bcherny]

New in Claude Code: Code Review. A team of agents runs a deep review on every PR.

We built it for ourselves first. Code output per Anthropic engineer is up 200% this year and reviews were the bottleneck

Personally, I’ve been using it for a few weeks and have found it catches many real bugs that I would not have noticed otherwise

[Rain @yugsuo]

我们是刚刚见证印刷机诞生的抄写员。繁琐的抄写工作结束了。艺术才刚刚开始。

[Anish Moonka @anishmoonka]

Boris Cherny (Head of Claude Code, Anthropic) just dropped ~90 mins on Lenny's Podcast about what happens after coding is solved.

Just the clearest thinking I've heard on where software is actually going.

My notes:

𝟭. 𝗖𝗼𝗱𝗶𝗻𝗴 𝗶𝘀 𝗹𝗮𝗿𝗴𝗲𝗹𝘆 𝘀𝗼𝗹𝘃𝗲𝗱.

Boris has not edited a single line of code by hand since November 2025. He ships 10 to 30 pull requests every single day, all written by Claude Code. He is one of the most prolific engineers at Anthropic, just as he was at Instagram, except now he never touches a keyboard for code.

I built an entire iOS app, @10minutegita, without writing a single line of code myself. No CS degree, no bootcamp. Just described what I wanted and shipped it. Boris is right. It's real.

𝟮. 𝗧𝗵𝗲 𝗻𝗲𝘅𝘁 𝗳𝗿𝗼𝗻𝘁𝗶𝗲𝗿 𝗶𝘀 𝗔𝗜 𝗱𝗲𝗰𝗶𝗱𝗶𝗻𝗴 𝘄𝗵𝗮𝘁 𝘁𝗼 𝗯𝘂𝗶𝗹𝗱.

Claude is now scanning Slack feedback channels, reviewing bug reports, reviewing telemetry, and coming up with its own ideas for what to fix and what to ship. Boris describes it as the AI becoming less like a tool and more like a coworker who brings you pull requests you never asked for.

If you are a product manager reading this, you should be feeling a very specific kind of discomfort right now. The moat was always "I know what to build." That moat is eroding.

𝟯. 𝗣𝗿𝗼𝗱𝘂𝗰𝘁𝗶𝘃𝗶𝘁𝘆 𝗽𝗲𝗿 𝗲𝗻𝗴𝗶𝗻𝗲𝗲𝗿 𝗮𝘁 𝗔𝗻𝘁𝗵𝗿𝗼𝗽𝗶𝗰 𝗶𝘀 𝘂𝗽 𝟮𝟬𝟬%.

For context, Boris led code quality at Meta across Facebook, Instagram, and WhatsApp. In that world, hundreds of engineers working an entire year would move productivity by a few percentage points. Two hundred percent gains are genuinely unprecedented in the history of developer tooling.

The kid optimizing for an FAANG SDE role might be optimizing for a role that looks completely different by the time they get there.

𝟰. 𝗨𝗻𝗱𝗲𝗿𝗳𝘂𝗻𝗱 𝘆𝗼𝘂𝗿 𝘁𝗲𝗮𝗺𝘀 𝗼𝗻 𝗽𝘂𝗿𝗽𝗼𝘀𝗲.

Boris puts one engineer on a project instead of five. With unlimited tokens and intrinsic motivation, one person ships faster because they are forced to let AI do the work. Cowork, the product now used by millions, was built by a small team in 10 days using Claude Code.

This is the same logic as giving a startup founder a small seed round rather than a massive Series A round. Constraint breeds invention. Always has.

𝟱. 𝗚𝗶𝘃𝗲 𝗲𝗻𝗴𝗶𝗻𝗲𝗲𝗿𝘀 𝘂𝗻𝗹𝗶𝗺𝗶𝘁𝗲𝗱 𝘁𝗼𝗸𝗲𝗻𝘀.

Some engineers at Anthropic spend hundreds of thousands of dollars a month on tokens. Boris frames this as the new hiring perk. His logic is simple: at the individual scale, token cost is low relative to salary. If an engineer discovers a breakthrough, optimize the cost later. Don't kill the idea before it has a chance to breathe.

People who argue about $20/month or even $200/month AI subscriptions while earning six figures in a research pipeline will always outperform those who wait and are penny-wise, pound-foolish.

𝟲. 𝗧𝗵𝗲 𝗕𝗶𝘁𝘁𝗲𝗿 𝗟𝗲𝘀𝘀𝗼𝗻 𝗮𝗽𝗽𝗹𝗶𝗲𝘀 𝘁𝗼 𝗲𝘃𝗲𝗿𝘆𝘁𝗵𝗶𝗻𝗴.

Richard Sutton's idea: the more general model always wins over time. Boris says teams that build strict orchestration workflows around models, forcing step 1, then step 2, then step 3, get maybe 10 to 20% improvement. But those gains get wiped out with the next model release. Just give the model tools and a goal. Let it figure out the order.

This is true for investing, too. The analyst who can build their own models and automate their own research pipeline will always outperform the one waiting for someone else to build the tools.

𝟳. 𝗕𝘂𝗶𝗹𝗱 𝗳𝗼𝗿 𝘁𝗵𝗲 𝗺𝗼𝗱𝗲𝗹 𝘀𝗶𝘅 𝗺𝗼𝗻𝘁𝗵𝘀 𝗳𝗿𝗼𝗺 𝗻𝗼𝘄.

Claude Code was designed for a model that did not exist when Boris started building. Sonnet 3.5 wrote maybe 20% of his code. He built the product anyway, betting the model would catch up. When Opus 4 shipped, everything clicked. Startups building for today's model will be behind by the time they launch.

This is the most uncomfortable advice in the episode because it means your product market fit will be weak for months. But if you read this and feel nothing, you are probably building for the wrong time horizon.

𝟴. 𝗟𝗮𝘁𝗲𝗻𝘁 𝗱𝗲𝗺𝗮𝗻𝗱 𝗶𝘀 𝘁𝗵𝗲 𝘀𝗶𝗻𝗴𝗹𝗲 𝗯𝗲𝘀𝘁 𝗽𝗿𝗼𝗱𝘂𝗰𝘁 𝘀𝗶𝗴𝗻𝗮𝗹.

When users abuse your product for something it was never designed to do, pay attention. Facebook Marketplace started because 40% of group posts were buy-and-sell. Cowork started because people were using a terminal coding tool to grow tomato plants and recover corrupted wedding photos.

Never ask a barber if you need a haircut, but always watch what people do with the scissors when you're not looking.

𝟵. 𝗧𝗵𝗲 𝘁𝗶𝘁𝗹𝗲 "𝘀𝗼𝗳𝘁𝘄𝗮𝗿𝗲 𝗲𝗻𝗴𝗶𝗻𝗲𝗲𝗿" 𝗶𝘀 𝗴𝗼𝗶𝗻𝗴 𝗮𝘄𝗮𝘆.

Boris predicts that by end of year, Boris predicts that by the end of the year, we will start to see the title replaced by "builder."we will start to see the title replaced by "builder." On the Claude Code team, everyone already codes: the PM, the designer, the finance person, the data scientist. There is a 50% overlap across traditional roles. And the strongest people are generalists who cross disciplines.

Controversial take, but I agree. The best investment theses I've had came from connecting dots across completely unrelated domains. No narrow specialist does that.

𝟭𝟬. 𝗧𝗵𝗲 𝗽𝗿𝗶𝗻𝘁𝗶𝗻𝗴 𝗽𝗿𝗲𝘀𝘀 𝗶𝘀 𝘁𝗵𝗲 𝗿𝗶𝗴𝗵𝘁 𝗮𝗻𝗮𝗹𝗼𝗴𝘆.

Before Gutenberg, sub-1% of Europe was literate. Scribes did all the reading and writing. In 50 years after the press, more material was printed than in the thousand years before. When a scribe was interviewed about the press, he was actually excited because it freed him from tedious copying, so he could focus on the art.

Boris's framing here is perfect. We are the scribes. The tedious copying is over. What we do with the freed-up time determines everything.

𝟭𝟭. 𝗔𝗻𝘁𝗵𝗿𝗼𝗽𝗶𝗰 𝗰𝗮𝗻 𝗻𝗼𝘄 𝗽𝗲𝗲𝗸 𝗶𝗻𝘀𝗶𝗱𝗲 𝘁𝗵𝗲 𝗺𝗼𝗱𝗲𝗹'𝘀 𝗯𝗿𝗮𝗶𝗻.

Through mechanistic interpretability, Anthropic can trace individual neurons, see when a deception-related neuron activates, and understand how concepts are encoded via superposition. Boris describes three layers of safety: neural-level observation, synthetic evaluations, and real-world behavior. Claude Code was used internally for four to five months before public release, specifically to study safety.

If you are worried about AI alignment, this part of the podcast should actually make you feel better. They are not just hoping it works. They are building the instruments to check.

𝟭𝟮. 𝟳𝟬% 𝗼𝗳 𝗲𝗻𝗴𝗶𝗻𝗲𝗲𝗿𝘀 𝗮𝗻𝗱 𝗣𝗠𝘀 𝗲𝗻𝗷𝗼𝘆 𝘁𝗵𝗲𝗶𝗿 𝗷𝗼𝗯𝘀 𝗺𝗼𝗿𝗲 𝗻𝗼𝘄.

Lenny polled engineers, PMs, and designers on whether AI has made their work more or less enjoyable. Engineers and PMs: 70% said more. Designers: only 55% said more, and 20% said less. Boris says he has never enjoyed coding as much as he does today because the tedious parts, the git wrangling, dependencies, and boilerplate are completely gone.

If you're in the 30% enjoying work less, something is wrong, and it's worth diagnosing. The people thriving are the ones who leaned in early, not the ones who watched from the sidelines.

We are the scribes who just saw the printing press. The tedious copying is over. The art is just beginning.

Full podcast is worth every minute. Link in replies.

[Aryan @justbyte_]

Be honest, is this relatable??

[Rain @yugsuo]

@marryevan999 deal

[OpenClaw🦞 @openclaw]

The lobster has molted into its final form 🦞

Clawd → Moltbot → OpenClaw

100k+ GitHub stars. 2M visitors in a week.
And finally, a name that'll stick.

Your assistant. Your machine. Your rules.
https://t.co/d39LXKRE9h

[Avi Chawla @_avichawla]

Researchers built a new RAG approach that:

- does not need a vector DB.
- does not embed data.
- involves no chunking.
- performs no similarity search.

And it hit 98.7% accuracy on a financial benchmark (SOTA).

Here's the core problem with RAG that this new approach solves:

Traditional RAG chunks documents, embeds them into vectors, and retrieves based on semantic similarity.

But similarity ≠ relevance.

When you ask "What were the debt trends in 2023?", a vector search returns chunks that look similar.

But the actual answer might be buried in some Appendix, referenced on some page, in a section that shares zero semantic overlap with your query.

Traditional RAG would likely never find it.

PageIndex (open-source) solves this.

Instead of chunking and embedding, PageIndex builds a hierarchical tree structure from your documents, like an intelligent table of contents.

Then it uses reasoning to traverse that tree.

For instance, the model doesn't ask: "What text looks similar to this query?"

Instead, it asks: "Based on this document's structure, where would a human expert look for this answer?"

That's a fundamentally different approach with:

- No arbitrary chunking that breaks context.
- No vector DB infrastructure to maintain.
- Traceable retrieval to see exactly why it chose a specific section.
- The ability to see in-document references ("see Table 5.3") the way a human would.

But here's the deeper issue that it solves.

Vector search treats every query as independent.

But documents have structure and logic, like sections that reference other sections and context that builds across pages.

PageIndex respects that structure instead of flattening it into embeddings.

Do note that this approach may not make sense in every use case since traditional vector search is still fast, simple, and works well for many applications.

But for professional documents that require domain expertise and multi-step reasoning, this tree-based, reasoning-first approach shines.

For instance, PageIndex achieved 98.7% accuracy on FinanceBench, significantly outperforming traditional vector-based RAG systems on complex financial document analysis.

Everything is fully open-source, so you can see the full implementation in GitHub and try it yourself.

I have shared the GitHub repo in the replies!

[Avi Chawla @_avichawla]

Function calling & MCP for LLMs, explained visually!

Before MCPs became popular, AI workflows relied on traditional Function Calling for tool access. Now, MCP is standardizing it for Agents/LLMs.

The visual below explains how Function Calling and MCP work under the hood.

Today, let's learn:
- Function calling by building custom tools for Agents.
- How MCPs help by building a local MCP client with mcp-use and using tools from the Browserbase MCP server.

In Function Calling:

- The LLM receives a prompt.
- The LLM decides the tool.
- The programmer implements a procedure to accept a tool call request from the LLM and prepare a function call. The tool call request is found in the LLM's response when you prompt it.
- A backend service executes the tool.

This Function Calling takes place within our stack:

- We host the tool.
- We implement a logic to determine the tool to invoke and its parameters.
- We execute it.

So, Function Calling requires us to wire everything manually.

MCP simplifies this!

Instead of hard-wiring tools, MCP:

- Standardizes defining, hosting, and exposing tools.
- Makes it easy to discover tools, understand schemas, and use them.
- Demands approval before invoking them.
- Detaches implementation from consumption.

For instance, whenever you integrate an MCP server, you never write a line of Python code to integrate the tools.

Instead, you just integrate the MCP server and everything beyond this follows a standard protocol handled by the MCP client and the LLM:
- They identify the MCP tool.
- They prepare the input argument.
- They invoke the tool.
- They use the tool’s output to generate a response.

Everything happens through a standard (but abstracted) protocol.

So here’s the key point: MCP and Function Calling are not in conflict. They’re two sides of the same workflow.

- Function Calling helps an LLM decide what it wants to do.
- MCP ensures that tools are reliably available, discoverable, and executable, without you needing to custom-integrate everything.

For example, an agent might say, “I need to search the web,” using function calling.

That request can be routed through MCP to select from available web search tools, invoke the correct one, and return the result.

Check the workflow in the diagram below.

To build a local MCP client, you can use mcp-use because it lets you connect any LLM to MCP servers & build private MCP clients, unlike Claude/Cursor.

- Compatible with Ollama & LangChain
- Render MCP outputs as UI elements
- Stream Agent output async
- Built-in debugging mode, etc

I have shared the mcp-use GitHub repo in the replies!

[Rain @yugsuo]

@Zephyr_hg NEWS

[Rain @yugsuo]

@recap_david AGENT

[David Roberts @recap_david]

I built an AI marketing agent to run my $100K media company.

After 4 months of prompting, tooling, and integrations, I built this agent that effectively replaced my content team.

Here’s how it works under the hood:

→ Scrapes Reddit, Hacker News, X, and Google News
→ Publishes a Morning Brew–style daily AI newsletter (10k daily readers)
→ Repurposes that content into:
 • viral Twitter threads (like this one)
 • short-form videos for TikTok & Instagram
 • Reddit posts
 • high-engagement LinkedIn updates
→ Produces content that’s driven millions of impressions
→ Generates custom, brand-aligned images for every unique asset

All automated.

The entire system runs through Jarvis-like voice commands, powered by ElevenLabs + n8n (see video below, I literally trained it on Jarvis from Iron Man).

No manual content creation.
No team to manage.
Runs while I sleep.

I'm no longer focusing on this business, so I'm giving all this away for free. If you want the complete system, prompting, n8n templates, & setup walkthrough:

Comment “AGENT”
Like & Retweet
Follow me (so I can DM you)

I’ll send everything over.

[Tech with Mak @techNmak]

Most people will waste this weekend.
Don’t be one of them.

Stanford's Autumn 2025 Transformers & LLMs course. 9 lectures. Free.

While others scroll, you could understand how Flash Attention achieves 3x speedup, how LoRA cuts fine-tuning costs by 90%, and how MoE makes models efficient.

➕ What's covered:

➡️ Lecture 1: Transformer Fundamentals
→ Tokenization and word representation
→ Self-attention mechanism explained
→ Complete transformer architecture
→ Detailed implementation example

➡️ Lecture 2: Advanced Transformer Techniques
→ Position embeddings (RoPE, ALiBi, T5 bias)
→ Layer normalization and sparse attention
→ BERT deep dive and finetuning
→ Extensions of BERT

➡️ Lecture 3: LLMs & Inference Optimization
→ Mixture of Experts (MoE) explained
→ Decoding strategies (greedy, beam search, sampling) → Prompting and in-context learning
→ Chain-of-thought reasoning
→ Inference optimizations (KV cache, PagedAttention)

➡️ Lecture 4: LLM Training & Fine-tuning
→ Pretraining and scaling laws (Chinchilla law)
→ Training optimizations (ZeRO, model parallelism)
→ Flash Attention for 3x speedup
→ Quantization and mixed precision
→ Parameter-efficient finetuning (LoRA, QLoRA)

➡️ Lecture 5: LLM Tuning
→ Preference tuning
→ RLHF overview
→ Reward modeling
→ RL approaches (PPO and variants)
→ DPO

➡️ Lecture 6: LLM Reasoning
→ Reasoning models
→ RL for reasoning
→ GRPO
→ Scaling

➡️ Lecture 7: Agentic LLMs
→ Retrieval-augmented generation
→ Advanced RAG techniques
→ Function calling
→ Agents
→ ReAct framework

➡️ Lecture 8: LLM Evaluation
→ LLM-as-a-judge overview
→Best practices and benefits
→Biases and pitfalls

➡️ Lecture 9: Recap & Trending topics

From Stanford Online:
Rigorous instruction. Latest techniques. Free access.

Perfect for:
→ ML engineers building with LLMs
→ AI engineers understanding transformers
→ Researchers working on language models
→ Anyone learning beyond API calls

This weekend: learn the techniques that separate good engineers from great ones.

(I will put the playlist in the comments.)

♻️ Repost to save someone $$$ and a lot of confusion. ✔️ Follow @techNmak for more AI/ML insights.

[Guohao Li 🐫 @guohao_li]

Anthropic Claude Cowork just killed our startup product 😅 So we did the most rational thing: open-sourced it.

Meet Eigent 👉 https://t.co/R82WRFoh41

[Agno @AgnoHQ]

This isn't just another agent pattern. It's a disciplined loop for building agents that survive real workflows.

Built with Agno + Gemini 3 Flash.

Blog: https://t.co/vcR4W771iU
Code: https://t.co/KA3LJBgKGs

[Rain @yugsuo]

@othingstodo_com 一湾清河入梦来