kant

[Alex Veremeyenko @alex_verem]

Andrej Karpathy put his whole AI course on GitHub for free.

7 repos, in the order to learn them

→ nn-zero-to-hero, his video course that builds neural networks from scratch
https://t.co/bUbJjjJtup

→ micrograd, the math that makes AI learn, in a tiny amount of code
https://t.co/fa2H6dHRx2

→ makemore, a small model that learns to invent new names
https://t.co/ILWge5cDuv

→ minbpe, how AI chops your words into tokens
https://t.co/OnazNRnxZI

→ nanoGPT, train your own GPT model
https://t.co/a9aIZtuqw7

→ nanochat, "the best ChatGPT that $100 can buy"
https://t.co/Ws1gcb9J4l

→ autoresearch, AI agents that run AI experiments on one GPU by themselves
https://t.co/wEoFLqoL9d

284,000 GitHub stars between them.

Everything you need to understand how ChatGPT works is free and open source.

[Apex @Apexxxzz]

🚨Claude Code es un dolor de cabeza hasta que instalas esto

Hay un plugin oficial de Anthropic llamado claude-code-setup

Te dice que automatizaciones puedes montar (hooks, skills, MCP servers, subagentes) y como configurarlas paso a paso

Analiza tu proyecto y te recomienda que activar

Para instalarlo: /plugin install claude-code-setup@claude-plugins-official

Guardalo y luego me agradeces

[Josh The Monkey @joshzemon]

This is f*cking insane. Andrej Karpathy, the man Elon called the #2 computer vision mind on Earth:

"Agents aren't magic. They're distillation at scale

99% of what your model knows is dead weight. A small model with the right tools and a closed loop beats it"

In 16 minutes, he lays out the stack that actually works, and why the people at the top stopped paying for the biggest model

Big Model → Small Model → Right Tools → Closed Loop → Self-Improving Agent

Most people keep upgrading the model. The loop is what makes a small one dangerous

Worth more than any $1,000 AI course this year

Bookmark and watch it today

Then read how to build that closed loop step by step in Harness, Loops, Graphs ↓

[Amit Shekhar @amitiitbhu]

This question was asked in an AI Engineering interview at Anthropic.

Question: Walk me through what happens, tensor by tensor, in one forward pass of a decoder-only transformer.

Let's answer it step by step.

A decoder-only transformer turns token IDs into vectors, passes them through a stack of identical layers, where each layer has causal Self Attention and a feed-forward network on a residual stream, and finally turns the last vectors into a probability for every token in the vocabulary.

Let's use a model close to Llama 2 7B: d = 4096, 32 heads, head_dim = 128, 32 layers, FFN size 11,008, vocabulary V = 32,000. B is the batch size and T is the number of tokens.

Step 1: Token IDs
Shape: [B, T]. Just integers.

Step 2: Embedding lookup
The embedding table is [V, d]. Each ID picks one row.
x: [B, T, d]. This is the residual stream.

Step 3: Each of the 32 layers does the following.

Attention part:
- h = RMSNorm(x): [B, T, d]
- Q = h Wq, K = h Wk, V = h Wv, each weight [d, d]. Reshape to [B, 32, T, 128].
- Apply RoPE to Q and K, to add position.
- Scores = Q K^T / sqrt(128): [B, 32, T, T]
- Causal mask: set every score where a token looks at a future token to minus infinity.
- Softmax over the last dimension. Each row now adds up to 1.
- Out = weights times V: [B, 32, T, 128]. Merge the heads back: [B, T, 4096].
- Output projection Wo [d, d]: [B, T, d]
- Residual: x = x + out

Feed-forward part (SwiGLU):
- h = RMSNorm(x): [B, T, d]
- gate = h W_gate, up = h W_up: each [B, T, 11008]
- act = SiLU(gate) * up: [B, T, 11008]
- down = act W_down: [B, T, d]
- Residual: x = x + down

The shape of x stays [B, T, d] through all 32 layers. Each layer only adds to the residual stream.

Step 4: Final RMSNorm
x: [B, T, d]

Step 5: Output projection (LM head)
logits = x W_out, where W_out is [d, V].
logits: [B, T, 32000]

Step 6: What we do with the logits
- Training: use all T positions. The logits at position t predict token t + 1. Cross-entropy loss over all positions.
- Inference: take only the last position, [B, V], apply temperature and softmax, and sample the next token.

Now, the inference details:
- The K and V of every layer are saved in the KV Cache: [B, kv_heads, T, 128] per layer.
- Prefill runs this whole pass on the full prompt.
- In decode, T = 1. Only the new token goes through the layers, and its Query attends to the cached Keys and Values. The scores become [B, 32, 1, T_total].

With GQA, K and V have fewer heads, like 8 instead of 32, and each KV head is shared by a group of Query heads.

In the interview, the most important line is: the residual stream keeps the shape [B, T, d] from the embedding to the last layer, attention mixes information across tokens under a causal mask, the feed-forward network works on each token on its own, and only the LM head changes the shape to the vocabulary size.

[divyansh @divyansh_1729]

SYSTEM DESIGN ROADMAP
│
├── 1. Computer Science Fundamentals
│ ├── How the Internet Works
│ ├── Client-Server Architecture
│ ├── HTTP & HTTPS
│ ├── DNS (Domain Name System)
│ ├── TCP & UDP
│ ├── IP Addresses & Ports
│ ├── OSI Model
│ ├── Network Protocols
│ ├── REST Architecture
│ ├── WebSockets
│ ├── Operating System Fundamentals
│ ├── Processes & Threads
│ ├── Concurrency & Parallelism
│ ├── Memory Management
│ ├── CPU & I/O Basics
│ └── Linux Fundamentals
│
├── 2. System Design Fundamentals
│ ├── What is System Design?
│ ├── What is Software Architecture?
│ ├── Monolithic Architecture
│ ├── Microservices Architecture
│ ├── Service-Oriented Architecture (SOA)
│ ├── Client-Server Architecture
│ ├── Three-Tier Architecture
│ ├── Layered Architecture
│ ├── Event-Driven Architecture
│ ├── Serverless Architecture
│ ├── Distributed Systems Basics
│ ├── Stateful vs Stateless Systems
│ ├── Synchronous vs Asynchronous Communication
│ └── Architectural Trade-offs
│
├── 3. Requirements & Design Fundamentals
│ ├── Functional Requirements
│ ├── Non-Functional Requirements
│ ├── Scalability
│ ├── Availability
│ ├── Reliability
│ ├── Maintainability
│ ├── Fault Tolerance
│ ├── Performance
│ ├── Latency & Throughput
│ ├── Consistency
│ ├── Durability
│ ├── Security
│ ├── Capacity Estimation
│ ├── Back-of-the-Envelope Calculations
│ ├── Traffic Estimation
│ ├── Storage Estimation
│ └── Bandwidth Estimation
│
├── 4. Networking & Communication
│ ├── HTTP Methods
│ ├── HTTP Status Codes
│ ├── HTTP Headers
│ ├── Cookies & Sessions
│ ├── TLS / SSL
│ ├── REST APIs
│ ├── GraphQL
│ ├── gRPC
│ ├── WebSockets
│ ├── Server-Sent Events (SSE)
│ ├── Long Polling
│ ├── API Versioning
│ ├── API Rate Limiting
│ ├── Connection Pooling
│ └── Keep-Alive Connections
│
├── 5. Database Fundamentals
│ ├── Relational Databases
│ │ ├── PostgreSQL
│ │ ├── MySQL
│ │ ├── Tables & Relationships
│ │ ├── Primary & Foreign Keys
│ │ ├── Indexing
│ │ ├── B-Tree & B+ Tree
│ │ ├── Query Optimization
│ │ ├── Joins
│ │ ├── Transactions
│ │ ├── ACID Properties
│ │ └── Normalization & Denormalization
│ ├── NoSQL Databases
│ │ ├── Document Databases
│ │ ├── Key-Value Stores
│ │ ├── Wide-Column Stores
│ │ ├── Graph Databases
│ │ └── MongoDB / Cassandra / DynamoDB
│ ├── Database Internals
│ │ ├── Storage Engines
│ │ ├── Write-Ahead Logging (WAL)
│ │ ├── MVCC
│ │ ├── Locking
│ │ └── Isolation Levels
│ └── Database Design Decisions
│ ├── SQL vs NoSQL
│ ├── Schema Design
│ ├── Read-Heavy vs Write-Heavy Workloads
│ └── Data Modeling
│
├── 6. Caching
│ ├── What is Caching?
│ ├── Cache Hierarchy
│ ├── Client-Side Caching
│ ├── Browser Caching
│ ├── CDN Caching
│ ├── Application-Level Caching
│ ├── Database Caching
│ ├── Redis
│ ├── Memcached
│ ├── Cache-Aside Pattern
│ ├── Read-Through Cache
│ ├── Write-Through Cache
│ ├── Write-Back Cache
│ ├── Cache Invalidation
│ ├── TTL (Time To Live)
│ ├── Cache Eviction Policies
│ │ ├── LRU
│ │ ├── LFU
│ │ └── FIFO
│ ├── Cache Stampede
│ └── Distributed Caching
│
├── 7. Load Balancing & Traffic Management
│ ├── What is Load Balancing?
│ ├── Layer 4 vs Layer 7 Load Balancing
│ ├── Reverse Proxy
│ ├── Forward Proxy
│ ├── Nginx
│ ├── HAProxy
│ ├── Cloud Load Balancers
│ ├── Round Robin
│ ├── Least Connections
│ ├── IP Hash
│ ├── Consistent Hashing
│ ├── Health Checks
│ ├── Sticky Sessions
│ ├── Horizontal Scaling
│ ├── Vertical Scaling
│ └── Auto Scaling
│
├── 8. Distributed Systems Fundamentals
│ ├── What is a Distributed System?
│ ├── Distributed System Challenges
│ ├── CAP Theorem
│ ├── PACELC Theorem
│ ├── Consistency Models
│ │ ├── Strong Consistency
│ │ ├── Eventual Consistency
│ │ ├── Causal Consistency
│ │ └── Read-Your-Writes Consistency
│ ├── Replication
│ │ ├── Leader-Follower Replication
│ │ ├── Multi-Leader Replication
│ │ └── Leaderless Replication
│ ├── Sharding & Partitioning
│ ├── Data Replication Strategies
│ ├── Distributed Transactions
│ ├── Two-Phase Commit (2PC)
│ ├── Consensus Algorithms
│ │ ├── Paxos
│ │ └── Raft
│ ├── Split Brain Problem
│ ├── Quorum
│ ├── Distributed Locking
│ ├── Clock Synchronization
│ └── Idempotency
│
├── 9. Message Queues & Event Streaming
│ ├── Message Queue Fundamentals
│ ├── Synchronous vs Asynchronous Processing
│ ├── Producer-Consumer Pattern
│ ├── Message Brokers
│ ├── RabbitMQ
│ ├── Apache Kafka
│ ├── Redis Streams
│ ├── Amazon SQS
│ ├── Publish-Subscribe Pattern
│ ├── Event-Driven Architecture
│ ├── Topics & Partitions
│ ├── Consumer Groups
│ ├── Message Ordering
│ ├── Delivery Guarantees
│ │ ├── At-Most-Once
│ │ ├── At-Least-Once
│ │ └── Exactly-Once Semantics
│ ├── Dead Letter Queues
│ ├── Retry Mechanisms
│ ├── Event Replay
│ └── Event Sourcing
│
├── 10. Scalability & Performance
│ ├── Horizontal vs Vertical Scaling
│ ├── Stateless Services
│ ├── Database Scaling
│ ├── Read Replicas
│ ├── Database Sharding
│ ├── Partitioning Strategies
│ ├── Connection Pooling
│ ├── Query Optimization
│ ├── CDN & Edge Computing
│ ├── Data Compression
│ ├── Pagination
│ ├── Batching
│ ├── Rate Limiting
│ ├── Load Shedding
│ ├── Backpressure
│ ├── Hotspot Mitigation
│ └── Performance Bottleneck Analysis
│
├── 11. Reliability & Fault Tolerance
│ ├── Fault Tolerance Fundamentals
│ ├── Redundancy
│ ├── High Availability
│ ├── Failover Strategies
│ ├── Active-Active Architecture
│ ├── Active-Passive Architecture
│ ├── Circuit Breaker Pattern
│ ├── Retry Pattern
│ ├── Exponential Backoff
│ ├── Timeout Management
│ ├── Bulkhead Pattern
│ ├── Graceful Degradation
│ ├── Health Checks
│ ├── Disaster Recovery
│ ├── Backup & Restore
│ ├── RPO & RTO
│ └── Chaos Engineering
│
├── 12. Microservices Architecture
│ ├── Monolith vs Microservices
│ ├── Service Decomposition
│ ├── Domain-Driven Design (DDD)
│ ├── Bounded Contexts
│ ├── Service Discovery
│ ├── API Gateway
│ ├── Backend for Frontend (BFF)
│ ├── Inter-Service Communication
│ ├── Synchronous Communication
│ ├── Asynchronous Communication
│ ├── Database Per Service
│ ├── Saga Pattern
│ ├── CQRS
│ ├── Event Sourcing
│ ├── Distributed Tracing
│ ├── Service Mesh
│ ├── Sidecar Pattern
│ └── Microservices Deployment Strategies
│
├── 13. System Design Patterns
│ ├── Singleton Pattern
│ ├── Factory Pattern
│ ├── Observer Pattern
│ ├── Strategy Pattern
│ ├── Adapter Pattern
│ ├── Decorator Pattern
│ ├── Repository Pattern
│ ├── Dependency Injection
│ ├── API Gateway Pattern
│ ├── Strangler Fig Pattern
│ ├── Sidecar Pattern
│ ├── Ambassador Pattern
│ ├── CQRS Pattern
│ ├── Saga Pattern
│ ├── Outbox Pattern
│ ├── Retry Pattern
│ ├── Circuit Breaker Pattern
│ └── Bulkhead Pattern
│
├── 14. Security in System Design
│ ├── Authentication & Authorization
│ ├── OAuth 2.0
│ ├── OpenID Connect
│ ├── JWT
│ ├── Session-Based Authentication
│ ├── Role-Based Access Control (RBAC)
│ ├── Attribute-Based Access Control (ABAC)
│ ├── Encryption at Rest
│ ├── Encryption in Transit
│ ├── TLS
│ ├── Password Hashing
│ ├── API Security
│ ├── Rate Limiting & DDoS Protection
│ ├── SQL Injection
│ ├── Cross-Site Scripting (XSS)
│ ├── CSRF
│ ├── Secrets Management
│ ├── Zero Trust Architecture
│ └── Audit Logging
│
├── 15. Observability & Monitoring
│ ├── Logging
│ ├── Metrics
│ ├── Distributed Tracing
│ ├── OpenTelemetry
│ ├── Prometheus
│ ├── Grafana
│ ├── ELK Stack
│ ├── Alerting
│ ├── Health Monitoring
│ ├── SLI / SLO / SLA
│ ├── Error Budgets
│ ├── Latency Monitoring
│ ├── Throughput Monitoring
│ ├── Root Cause Analysis
│ └── Incident Management
│
├── 16. Cloud & Infrastructure
│ ├── Cloud Computing Fundamentals
│ ├── AWS / GCP / Azure
│ ├── Compute Services
│ ├── Storage Services
│ ├── Managed Databases
│ ├── Virtual Private Cloud (VPC)
│ ├── DNS & Networking in Cloud
│ ├── Object Storage (S3)
│ ├── Containers
│ ├── Docker
│ ├── Kubernetes
│ ├── Container Orchestration
│ ├── Infrastructure as Code
│ │ ├── Terraform
│ │ └── CloudFormation
│ ├── CI/CD Pipelines
│ ├── Blue-Green Deployment
│ ├── Canary Deployment
│ ├── Rolling Deployment
│ └── Serverless Infrastructure
│
├── 17. Storage Systems & File Architecture
│ ├── Block Storage
│ ├── File Storage
│ ├── Object Storage
│ ├── Distributed File Systems
│ ├── Content Delivery Networks
│ ├── File Upload Architecture
│ ├── Multipart Upload
│ ├── Resumable Uploads
│ ├── Data Deduplication
│ ├── Compression
│ ├── Data Retention
│ ├── Backup Strategies
│ ├── Blob Storage
│ └── Metadata Management
│
├── 18. Real-Time Systems
│ ├── WebSockets
│ ├── Server-Sent Events
│ ├── Long Polling
│ ├── Real-Time Notifications
│ ├── Presence Systems
│ ├── Heartbeats
│ ├── Live Chat Architecture
│ ├── Real-Time Collaboration
│ ├── Pub/Sub Architecture
│ ├── Fan-Out Strategies
│ ├── Online Gaming Architecture
│ └── Real-Time Data Processing
│
├── 19. Advanced Distributed Systems
│ ├── Distributed Hash Tables
│ ├── Consistent Hashing
│ ├── Gossip Protocol
│ ├── Merkle Trees
│ ├── Vector Clocks
│ ├── Lamport Clocks
│ ├── CRDTs
│ ├── Distributed Snapshots
│ ├── Leader Election
│ ├── Log Replication
│ ├── Stream Processing
│ ├── Apache Flink
│ ├── Apache Spark
│ ├── Data Locality
│ ├── Multi-Region Architecture
│ ├── Geo-Replication
│ └── Global Traffic Management
│
├── 20. Low-Level Design (LLD)
│ ├── Object-Oriented Design
│ ├── SOLID Principles
│ ├── DRY / KISS / YAGNI
│ ├── UML Class Diagrams
│ ├── Sequence Diagrams
│ ├── State Diagrams
│ ├── Class Relationships
│ ├── Composition vs Inheritance
│ ├── Interfaces & Abstractions
│ ├── Design Patterns
│ ├── Extensibility & Maintainability
│ ├── Concurrency in LLD
│ ├── Thread Safety
│ └── Common LLD Problems
│ ├── Parking Lot
│ ├── Library Management System
│ ├── Elevator System
│ ├── Splitwise
│ ├── BookMyShow
│ ├── Chess
│ └── Food Delivery System
│
├── 21. High-Level Design (HLD)
│ ├── Requirement Gathering
│ ├── Functional & Non-Functional Requirements
│ ├── API Design
│ ├── Database Schema Design
│ ├── Capacity Estimation
│ ├── Component Diagrams
│ ├── Data Flow Diagrams
│ ├── Architecture Diagrams
│ ├── Bottleneck Identification
│ ├── Scaling Strategies
│ ├── Reliability & Fault Tolerance
│ ├── Security Considerations
│ ├── Trade-off Analysis
│ ├── Architecture Documentation
│ └── End-to-End System Design
│
├── 22. System Design Case Studies
│ ├── URL Shortener (TinyURL)
│ ├── Pastebin
│ ├── Rate Limiter
│ ├── Notification System
│ ├── News Feed (Facebook / Instagram)
│ ├── Chat Application (WhatsApp)
│ ├── Video Streaming (YouTube / Netflix)
│ ├── Ride-Hailing (Uber)
│ ├── Food Delivery (Swiggy / Zomato)
│ ├── E-Commerce (Amazon)
│ ├── Payment System
│ ├── Search Engine
│ ├── File Storage (Google Drive / Dropbox)
│ ├── Ticket Booking (BookMyShow)
│ ├── Social Media Platform (X)
│ ├── Recommendation System
│ ├── Distributed Cache (Redis)
│ ├── Logging & Monitoring Platform
│ ├── Web Crawler
│ └── Video Conferencing System
│
├── 23. System Design Tools & Technologies
│ ├── Programming Languages
│ │ ├── Go
│ │ ├── Java
│ │ └── Python
│ ├── Databases
│ │ ├── PostgreSQL
│ │ ├── MySQL
│ │ ├── Redis
│ │ ├── MongoDB
│ │ └── Cassandra
│ ├── Message Brokers
│ │ ├── Kafka
│ │ └── RabbitMQ
│ ├── Networking & Proxy
│ │ ├── Nginx
│ │ └── HAProxy
│ ├── Infrastructure
│ │ ├── Docker
│ │ ├── Kubernetes
│ │ └── Terraform
│ ├── Monitoring
│ │ ├── Prometheus
│ │ ├── Grafana
│ │ └── OpenTelemetry
│ ├── API Testing
│ │ ├── Postman
│ │ └── curl
│ └── Architecture Documentation
│ ├── Excalidraw
│ ├── https://t.co/Er2z05X7Du
│ └── Mermaid
│
├── 24. System Design Practice
│ ├── Design Small Systems First
│ ├── Design a URL Shortener
│ ├── Design a Rate Limiter
│ ├── Design a Notification Service
│ ├── Design a Chat Application
│ ├── Design a News Feed
│ ├── Design a Video Streaming Platform
│ ├── Design a Ride-Hailing Platform
│ ├── Design a Payment Service
│ ├── Design a Distributed Cache
│ ├── Design a Search Engine
│ ├── Design a File Storage Service
│ ├── Design a Ticket Booking System
│ ├── Design a Real-Time Analytics System
│ ├── Document Design Decisions
│ ├── Identify Trade-offs
│ ├── Review Existing Architectures
│ └── Build End-to-End Projects
│
└── 25. Mastery & Career Preparation
├── Architectural Thinking
├── Breaking Down Complex Problems
├── Requirement Analysis
├── Capacity Estimation
├── Identifying Bottlenecks
├── Choosing the Right Components
├── Scalability Trade-offs
├── Reliability Engineering
├── Distributed Systems Thinking
├── Cost Optimization
├── Security-First Design
├── Architecture Reviews
├── Technical Documentation
├── System Design Interviews
├── Mock Design Interviews
├── Real-World Production Experience
└── Continuous Learning

FINAL GOAL:
Become an Exceptional System Designer
│
├── Design Scalable Applications
├── Build Reliable Distributed Systems
├── Understand Large-Scale Architectures
├── Make Strong Engineering Trade-offs
└── Design Systems Used by Millions of Users

[Movez @0xMovez]

this is f*cking crazy

karpathy's CLAUDE.md hit #1 on github trending.
228,000 stars. most devs still haven't read it.

it took my Claude agents accuracy from 65% to 94%.

the 6 rules inside:

• step 1 → surface assumptions

"State your assumptions explicitly. If uncertain, ask."
ambiguous task → list interpretations → ask → build.

• step 2 → cut the scope

"No abstractions for single-use code."
200 lines → refactor → 50 lines → ship.

• step 3 → keep the diff surgical

"Don't refactor things that aren't broken."
request → minimal diff. every changed line traces back.

• step 4 → clean only your orphans

"Remove imports/variables/functions that YOUR changes made unused."

old dead code → flag it, don't delete it.

• step 5 → turn tasks into tests

"Fix the bug" → "Write a test that reproduces it, then make it pass."

vague task → failing test → pass/fail signal.

• step 6 → run the verify loop

"[Step] → verify: [check]"
plan → code → verify → fail? loop → pass → ship.

that's it.
65 lines. 6 rules. 94% accuracy.

save this before everyone else does.

then, read the article on how to build a team of Claude agents with Graphs below ↓

[Pallavi @pallavishekhar_]

Evolution of LLM Architecture

Read here: https://t.co/YyTsnEaPR8

[灰狐 @huihoo]

Google Open Source Blog 是个巨大知识宝库 (从 2008-2026年)
虽然不少技术因为体量和规模你无法在现实中应用
但保持对新技术前沿科技的了解和感知也蛮重要的
https://t.co/ogRYymGlZW

同理，其它互联网大厂和组织的开源博客也可一同关注
Microsoft Open Source Blog
https://t.co/gWtKazEiUX

AWS Open Source Blog
https://t.co/zePienFdLc

Netflix TechBlog
https://t.co/UOBk5qmJIj

CNCF Blog (云原生计算基金会)
https://t.co/jIcFZ58VQx

Linux Foundation Blog
https://t.co/OoostPxcGx

还有很多 ... 感兴趣的朋友可自行收集正整理

[晓知以Ray资源分享 @caoxiaolei]

你以为自己在是在公司上班，实际你可能正在经历一场“宫廷权力斗争”。
推荐一本很有意思的书：《公司就是朝廷》。
它把中国历史上的帝王权术、权力博弈、利益制衡，直接套进现代公司管理。
从领导风格、职场站队、利益分配，到集权与分权，这本书用历史案例拆解组织内部的生存规则。
《公司就是朝廷》，自取：https://t.co/bNBL5zHgAT

[娜美知识库 @fhwofjow51260]

为什么你一说话就紧张？明明脑子里有很多想法，一开口却语无伦次？

推荐一本豆瓣8.2分的好书：《关于说话的一切》，作者是B站知识区UP主「汤质看本质」。

这本书从哲学、语言学、符号学、认知心理学等角度，拆解说话背后的底层逻辑。

为什么有些人聊天总能接住话？为什么一到重要场合就紧张？怎样才能把复杂的想法讲得清楚又有说服力？

如果你嘴笨、社恐、不擅长表达，或者总觉得自己有话说不出来，真的建议读读这本书。

电子版自取：https://t.co/VUxqcVmcpV

[lumxss @bkdgiffug]

Coding Agent 写得快，但测试、约束和代码审查经常跟不上？可以看看 Addy Osmani 的开源 Skills。

它把需求梳理、规范编写、TDD 和代码验证拆成标准流程，每个环节都有明确步骤和退出条件。

不用一次全装，先用 Spec、TDD，合并前再做 Review。调试、安全、性能、ADR 和部署等技能，可按需启用。
GitHub：https://t.co/yGACniHteu

[Lucas @lksmlabc]

很多人一门心思琢磨怎么赚钱，却很少去想：赚到的钱，最后为什么又会被拿走一部分。

《税的荒唐与智慧》讲的正是税收背后的另一面：它不只是算几个税率，更是利益、财富分配与社会规则之间的一场博弈。
📚《税的荒唐与智慧》
👉：https://t.co/CfU48lQZM5

[头雁 @alacheng]

《MoE 训练终极手册》中文版来啦！https://t.co/LvC8VYhY1f

[InfiCheesy無限芝士 @InfiCheesy]

稠州商行，俗称小国泰

可以通过这家银行见证开通“美国国泰银行”账户

听起来是小银行，业务可一点不小

[Huan @Huanusa]

这招价值很大...
针对中国目前最大的物业，这么要求也是非常合理的😂 最后一条最猛👍

[Айтишница из Тбилиси @nerdniwe]

Тоже статья Антропиков, про построение эффективных агентов.

И вот это - лучшее, что я читала за месяц. База на базе базой погоняет.

#озидо

https://t.co/KFMyTtUyT3

[Kirk Borne @KirkDBorne]

Excellent animated visual demonstration of Gradient, Divergence and Curl vector fields — cool Mathematics from @matheorems

[𝗿𝗮𝗺𝗮𝗸𝗿𝘂𝘀𝗵𝗻𝗮— 𝗲/𝗮𝗰𝗰 @techwith_ram]

𝗞𝗩 𝗖𝗮𝗰𝗵𝗶𝗻𝗴 𝗘𝘅𝗽𝗹𝗮𝗶𝗻𝗲𝗱

Ever wondered how LLMs remember thousands of tokens without processing everything from scratch every time?

That's where KV Caching comes in.

When an LLM generates a response, it doesn't need to recompute the Key and Value representations of all previous tokens at every step.

Instead, it stores them in a cache and reuses them while generating the next token.
Sounds simple, but this makes a huge difference in inference speed and computational efficiency.

Here's what happens:

- During prefill, the model processes the prompt and stores the Keys and Values.
- During decoding, it computes Q, K and V only for the new token.
- The new K and V are added to the existing cache.
- Previous KV values are reused instead of being recomputed.

But there's one important thing to understand: KV Caching doesn't eliminate attention over previous tokens. It eliminates the need to recompute their Keys and Values.

As context grows, KV cache memory can become a major bottleneck.

That's why techniques like:
- MQA (Multi-Query Attention)
- GQA (Grouped-Query Attention)
- PagedAttention
- Prefix Caching

play an important role in making LLM inference more efficient.

Understanding KV Caching is essential if you're learning how LLM inference actually works or building systems that serve LLMs at scale.

[陈发财 @Chenfacai0]

有人把503门AI课程的全部内容都开源了，项目叫做《从零开始的AI工程》。整套内容分为20个阶段、总计约320小时，完全免费，采用MIT许可，编程语言方面Python、TypeScript、Rust、Julia均有涉及。

它的教学核心在于：并不从框架起步，而是要求你先亲手把底层轮子造出来，手动推导反向传播、从零编写分词器、从零搭建注意力机制、从零实现代理循环。等这些做完，再去用生产级库把相同的概念复现一遍。

每节课的框架固定不变：座右铭 → 问题 → 概念 → 造它 → 用它 → 发布它。每节课结束时你都能拿到可反复使用的东西：提示词、SKILL.md、代理实现、MCP服务器、可运行代码。

学习方式偏向AI原生：先执行 npx skills add rohitg00/ai-engineering-from-scratch，再输入 /start-learning。系统会用10道题帮你定位起点，并生成个性化的LEARNING.md。此后 /learn 负责讲课、/course-guide 负责查主题、/check-understanding 负责阶段测验。Claude Code、Cursor、Codex、OpenClaw、Hermes 都能兼容。

项目还配了一个 Claude 认证学院，四个官方认证轨道的课程、实验、诊断、项目、模拟考全部齐备。

20个阶段从第0阶段（工具配置）一直排到第19阶段（顶点项目）。单是第19阶段就含有17个端到端产品加9个深度构建轨道。EPUB/PDF版也有提供。

503门课数量看着吓人，但脉络很清楚：先弄懂机制、自己动手造一遍、再过渡到抽象。

🔗https://t.co/Z48Z1lLBCN

[山景城小路 @Zen_with_AI]

第24期ML面试问题

Q：为什么现在神经网络基本都用 ReLU 做激活函数？它比 Sigmoid 和 Tanh 好在哪？

A：

ReLU 是什么 Rectified Linear Unit
ReLU(x) = max(0, x)：负的直接归零，正的原样通过。比如输入 -2 出 0，输入 3 出 3，简单到只有一个 max 操作。
Sigmoid 和 Tanh 的毛病 saturation
它俩在两头都会饱和：Sigmoid 输出挤在 0 和 1 附近时导数趋近 0，最大也只有 0.25；Tanh 虽然输出以 0 为中心，两头照样饱和。反向传播链式相乘，梯度越传越小，浅层基本学不动——这就是梯度消失的一个主要来源。
ReLU 好在哪
正区间导数恒为 1，梯度传多少层都不打折；计算便宜，不用算指数；负的归零让一部分神经元天然关闭，激活是稀疏的，省算力。
一句话记住：负的归零，正的直通，导数恒 1 不打折。
追问加分：ReLU 有什么毛病？——dying ReLU：神经元一旦总落在负区间，梯度恒为 0，就再也醒不过来；改进版 Leaky ReLU、GELU 给负区间留一点斜率。
更深度问题：Transformer 里为什么用 GELU 而不是 ReLU？