kant

[Ebokify @ebokify]

AI Engineering Interviews: Over 350 AI Interview Questions and Answers

📕 Get Now: https://t.co/sIrAL4pRYm

Generative AI is rapidly spreading across industries, and companies are actively hiring people who can design, build, and deploy these systems. But to land one of these roles, you'll have to get through the interview first. Generative AI Interviews walks you through every stage of the interview process, giving you an insider's perspective that will help you build confidence and stand out.

[纳米AI @antiAIvo]

又发现一门大模型学习的好课：
斯坦福 CME295《Transformers & Large Language Models》

讲师是 Afshine 和 Shervine Amidi 兄弟
就是做斯坦福那套 cheatsheet 的两位

这门课的好处是完整：
从 Transformer 一路讲到推理模型和 Agent
9 节课，一节不到两个小时

课表：
1. Transformer：分词、词向量、注意力、整体结构
2. Transformer 的变体与技巧：MHA / MQA / GQA、RoPE、BERT
3. 大模型：MoE、采样、上下文学习、思维链
4. 训练：预训练、量化、SFT、LoRA
5. 对齐：RLHF、奖励模型、PPO、DPO
6. 推理模型：强化学习练推理、GRPO
7. Agent：RAG、函数调用、ReAct
8. 评估：LLM 当裁判、偏差与坑
9. 当前趋势

2025 年秋季那一期已经全部公开：
录像、课件、期中期末考题和答案都有
今年秋季正在上新一期
录像同步发在 Stanford Online 的 YouTube 频道

适合的人：
想把大模型从原理到训练、对齐、Agent 串成一条线的人
有一点微积分、线性代数和机器学习基础就够了

https://t.co/dKrHZ6QQVI

[白板报 zhongwen.ai @zhongwen_ai]

本站数学视频增加到4096部，这是数学爱好者的MathTube，根据HN, Reddit 400G数据集按照讨论热度排序。不要持械入宋了，持笔入数吧。 https://t.co/kWCCwCgmVz

[meng shao @shao__meng]

Airbnb 开源内部使用的工作流引擎 Skipper：把可恢复的工作流嵌进服务，不必另建编排集群；面向 Java、Kotlin 服务，解决多步业务中常见的问题：执行到一半进程崩溃、下游暂时失败，流程怎样继续，而不是从头盲目重做。

开源地址：https://t.co/HKoafGCTVF

核心机制：执行在服务里，进度存进数据库

Skipper 作为库嵌入现有服务，运行时和调度器随服务一起部署，不需要独立的工作流编排集群。多个服务副本共享数据库，用租约协调任务；某个副本失败后，其他副本可以接管。

恢复时，它会从头重放工作流方法，但已持久化的动作直接返回保存结果，不必重新执行。流程也能暂停等待信号或定时器，不持续占用线程。因此，它不只是串联函数的工具，而是具备持久化与故障恢复能力的执行引擎。

最重要的边界：可恢复，不等于绝不重复

Skipper 不能保证下游操作只发生一次。 默认情况下，部分检查点会批量写入；落盘前崩溃，已经完成的动作可能再次执行。即使立即保存，下游调用与检查点也不是一个原子事务。因此，支付、发券等操作仍需开发者保证幂等，避免重复调用产生重复结果。

开源版目前提供 MySQL、SQLite 适配器，多实例生产部署建议用 MySQL；Postgres、DynamoDB 仍在规划。Airbnb 此前自报，内部已覆盖 15 个以上用例，峰值达到每秒 1 万个工作流，但该峰值使用 DynamoDB，不能直接视为当前开源版的性能指标。

[Ashish Pratap Singh @ashishps_1]

I created a Github repository to learn System Design, and it crossed 40k stars recently.

The repository contains a collection of FREE resources to study:
- System Design Core Concepts
- Networking and API Fundamentals
- Database and Caching Fundamentals
- Distributed Systems, Microservies and Architectural Patterns
- System Design Tradeoffs
- 40+ interview problems categorized by difficulty level

Check it out here: https://t.co/pkVpi6LxSV

If you find the repo valuable, consider giving it a ⭐️ and share with others.

[灰狐 @huihoo]

几何学和想象力，充满了数学思想
优雅，直观，解释清楚，敏锐洞察力
无论初学者或数学家，阅读都将是一种享受
几何学越来越重要，内容也越来越丰富

《直观几何》（Geometry and the Imagination）是 1932 年由数学大师大卫·希尔伯特（David Hilbert）与斯蒂芬·康福森福森（Stephan Cohn-Vossen）合著的经典数学科普名著

希尔伯特以推动数学形式化与公理化闻名，但这本书体现了他对“几何直观”作为数学创造力源泉的高度重视。书中收录了大量精美的立体图解与实物模型照片，至今仍是数学系学生与数学爱好者建立几何直觉的必读经典

这本书对本世纪数学家的持续影响
它应该属于伟大数学书籍的“万神殿”

当代数、几何、拓扑，结合起来思考时，威力是巨大的 https://t.co/73HfPzGrSE

[Tao Wang @Tao100086]

斯坦福CS329Z — Engineering AI Agents（2026 秋季）这门课程现在终于在youtube上线了。

https://t.co/J9BneaLUWu

这是一门全新的斯坦福研究生课程，由 Diyi Yang、Michael Ryan（DSPy 核心贡献者）和 John Yang（SWE-bench 共同创建者）共同授课。⁠

核心定位是：从单一大模型转向复合 AI 系统（Compound AI Systems） 的工程实践。也就是把 LLM、检索器、工具、优化器、记忆等组件组合起来，构建从简单流水线到自主 Agent 的完整系统。

课程强调动手工程能力，而不是只讲概念：

先从零实现核心组件（RAG、工具调用、Agent Loop），再学习框架（如 DSPy）如何抽象这些模式。
重点训练：问题拆解、组件选型、数据收集与整理、评测体系搭建、设计权衡、可靠性与安全。

主要内容覆盖
Agent 基础与解剖结构（LLM 核心、推理、记忆、工具、环境）
RAG（索引、检索器、Agentic RAG）
工具使用与函数调用（包括 MCP）
框架与编排（DSPy、LangGraph 等）
Agent 设计模式（ReAct、Reflexion、CodeAct 等）
记忆架构、多智能体系统
优化（提示、权重、系统级）
评测（LLM-as-Judge、benchmark 设计、pass@k 等）
安全与防护（prompt injection、沙箱、权限模型）
专项主题：编程 Agent、主动式 Agent

还有嘉宾课，包括 Terminal-Bench、SWE-bench 团队，以及与 Andrew Ng 的 fireside chat。

作业与实践（已公开）

HW1（Michael Ryan 设计）：从零搭建 Agent Harness（类似迷你版 Claude Code）。要求不用现成框架，只用 chat completion API + 自己写代码。基于真实公司邮件语料做检索、摘要、工具调用、终端、记忆、人工审批等。成本很低（参考实现跑完测试大约不到 1 美元）。⁠
仓库：https://t.co/HtipRCrTHs

HW2（John Yang 设计）：使用 Harbor 框架构建接近 Terminal-Bench 风格的真实 Agent 评测任务。学生要自己设计问题、运行环境和验证器。
仓库：https://t.co/iymexsaZtQ

课程网站：https://t.co/TitmAOJd4R

YouTube 播放列表已开始更新（Lecture 1 已上线）：https://t.co/J9BneaLUWu

整体来说，这是目前斯坦福最系统、最偏工程实践的 AI Agent 课程之一，重点在“怎么真正把 Agent 系统做出来并可靠运行”，而不是只调用现成框架。材料正在全面公开，现在是跟着学的好时机。

[Lucas @lksmlabc]

《DK 中文百科全书合集》全套下载来了，权威科普读物大全。

🔗：https://t.co/UkRlrb0SQZ

[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