← 2026-03-15 📂 All Days 2026-03-17 →
🏗️
🏗️ System Design
🏗️ 系统设计 Day 3 / System Design Day 3

🏗️ 系统设计 Day 3 / System Design Day 3

HTTP/HTTPS & REST APIs

*Category: Fundamentals | Difficulty: Beginner | Phase: Foundation*

想象你在设计... / Imagine You're Building...

想象你是一家餐厅的服务员。客人(浏览器)坐下来,告诉你他想要什么(HTTP请求),你去厨房(服务器)取回食物,然后送回来(HTTP响应)。这就是HTTP的本质——一种双方约定好的"点餐协议"。

Imagine you're a waiter at a restaurant. The customer (browser) tells you what they want (HTTP request), you go to the kitchen (server), and bring back the food (HTTP response). That's HTTP in a nutshell — a standardized "ordering protocol" both sides agree on.


架构图 / Architecture Diagram

CLIENT (Browser/App) │ │ HTTP Request │ GET /api/users/123 │ Headers: {Authorization: "Bearer token..."} ▼ ┌─────────────────────┐ │ LOAD BALANCER │ │ (distributes load) │ └──────┬──────┬────────┘ │ │ ▼ ▼ ┌──────────┐ ┌──────────┐ │ Server 1 │ │ Server 2 │ ← Stateless REST servers └──────┬───┘ └──────┬───┘ │ │ └──────┬──────┘ ▼ ┌───────────────┐ │ DATABASE │ │ (source of │ │ truth) │ └───────────────┘ │ HTTP Response 200 OK {"id": 123, "name": "Alice"} │ ▼ CLIENT receives data

HTTP vs HTTPS — 核心区别 / Core Difference

HTTP — HyperText Transfer Protocol

  • 明文传输,数据可被中间人截获
  • Plaintext transmission; data can be intercepted

HTTPS — HTTP + TLS/SSL 加密

  • 所有数据加密传输,第三方无法读取内容
  • All data encrypted; third parties can't read the content
  • 通过证书验证服务器身份(你真的是在和 google.com 说话吗?)
  • Certificate verifies server identity (are you really talking to google.com?)
HTTP: 你的密码 → [网络] → 服务器 ← 路由器能看到! HTTPS: 你的密码 → [加密] → [网络] → [解密] → 服务器 ← 中间人只看到乱码

REST API — 六个约束 / Six Constraints

REST (Representational State Transfer) 不是技术,是一套设计风格:

  1. Stateless(无状态) — 服务器不记住你。每个请求自带所有信息。

Server doesn't remember you. Each request carries all needed info.

  1. Client-Server(客户端-服务器分离) — 前端和后端独立演化。

Frontend and backend evolve independently.

  1. Cacheable(可缓存) — 响应可以被缓存,减少重复请求。

Responses can be cached to reduce redundant requests.

  1. Uniform Interface(统一接口) — 用标准HTTP方法操作资源。

Use standard HTTP verbs to manipulate resources.

  1. Layered System(分层系统) — 客户端不关心中间有几层。

Client doesn't care how many layers exist in between.

  1. Code on Demand (Optional) — 服务器可返回可执行代码(如JS)。

Server can return executable code (e.g., JavaScript).


HTTP 方法 CRUD 对应关系 / HTTP Methods → CRUD

HTTP Method CRUD Operation Example ────────────────────────────────────────────────── GET Read GET /users/123 POST Create POST /users {body} PUT Replace (全量) PUT /users/123 {full body} PATCH Update (部分) PATCH /users/123 {partial} DELETE Delete DELETE /users/123

状态码速查 / Status Code Cheat Sheet:

2xx  ✅  成功 / Success
  200 OK           — 请求成功
  201 Created      — 资源已创建
  204 No Content   — 成功但无返回体

3xx  ↩️  重定向 / Redirect
  301 Moved Permanently  — 永久跳转
  304 Not Modified       — 用缓存

4xx  ❌  客户端错误 / Client Error
  400 Bad Request    — 你的请求有问题
  401 Unauthorized   — 没登录
  403 Forbidden      — 登录了但没权限
  404 Not Found      — 资源不存在
  429 Too Many Reqs  — 限流了

5xx  💥  服务器错误 / Server Error
  500 Internal Server Error — 服务器崩了
  503 Service Unavailable   — 服务不可用

为什么这样设计?/ Why This Design?

为什么REST选择无状态(Stateless)?

如果服务器记住每个用户的状态,那扩展到100台服务器时,你必须确保每次请求都打到同一台机器(叫做"粘性会话"sticky session)。这非常麻烦。

无状态的好处:任何服务器都能处理任何请求,水平扩展极其简单。

If servers remembered user state, scaling to 100 servers would require routing each user to the same server every time ("sticky sessions") — a maintenance nightmare. Stateless = any server can handle any request = horizontal scaling is trivial.


别踩这个坑 / Don't Fall Into This Trap

坑 1: 在GET请求中修改数据

❌  GET /deleteUser?id=123    # 语义错误,GET应该是只读的
✅  DELETE /users/123

坑 2: 用动词命名资源(URL应该是名词)

❌  POST /createUser
❌  GET  /getUserById?id=123
✅  POST /users
✅  GET  /users/123

坑 3: 忘记区分401和403

401 Unauthorized → "你是谁?请先登录" (Who are you? Please log in) 403 Forbidden → "我知道你是谁,但你没权限" (I know who you are, but you can't)

坑 4: 滥用200 OK返回错误信息

❌  200 OK  {"error": "User not found"}   # 前端要额外解析body判断成功失败
✅  404 Not Found  {"message": "User not found"}

与昨天的联系 / Connection to Day 2

昨天我们学了DNS和TCP/IP。现在你明白了完整链路:

  1. 你在浏览器输入 https://api.example.com/users
  2. DNS 解析域名 → IP地址
  3. TCP 建立连接(三次握手)
  4. TLS 握手,建立加密通道(HTTPS)
  5. HTTP 发送请求,服务器返回响应
  6. 浏览器渲染数据
Yesterday we covered DNS and TCP/IP. Now you see the full picture: DNS → TCP → TLS → HTTP → response. Each layer builds on the one before it.

*Day 3 | 系统设计基础系列 | 明天:数据库基础*
💻
💻 Algorithms
💻 算法 Day 3 / Algorithms Day 3

💻 算法 Day 3 / Algorithms Day 3

#1 Two Sum (Easy) — Arrays & Hashing

🔗 https://leetcode.com/problems/two-sum/


现实类比 / Real-World Analogy

想象你在一家超市,口袋里有 $11,你想找到两件商品,价格加起来正好等于 $11。

笨方法:把每件商品和其他所有商品逐一配对比较 — 效率太低了 O(n²)。

聪明方法:每次拿起一件商品(价格 x),立刻检查你的"已看过价格"笔记本里有没有 11 - x。有就找到了!这就是哈希表的思路。

Imagine you're in a supermarket with $11 and want two items that add up to exactly $11. Brute force: compare every pair. Smart way: for each item (price x), instantly check if 11 - x is already in your "seen prices" notebook. That's the hash map approach.


题目 / Problem Statement

中文: 给定一个整数数组 nums 和一个目标值 target,找出数组中和为 target 的两个数的下标。假设每道题恰好只有一个答案,且同一个元素不能使用两次。

English: Given an array of integers nums and an integer target, return the indices of the two numbers that add up to target. You may assume exactly one solution exists, and you may not use the same element twice.

Input:  nums = [2, 7, 11, 15], target = 9
Output: [0, 1]   (because nums[0] + nums[1] = 2 + 7 = 9)

逐步思路 / Step-by-Step Walkthrough

方法1:暴力 O(n²) — 先理解,别用它

For i = 0 (num = 2): For j = 1 (num = 7): 2 + 7 = 9 ✅ → return [0, 1]

方法2:哈希表 O(n) — 这才是正解

核心思路:遍历时,对每个数 num,我们不是找"谁加上 num 等于 target",而是找"target - num 在不在我们之前见过的数里"。

具体示例追踪:

nums = [2, 7, 11, 15], target = 9 seen = {} (空字典) i=0, num=2: complement = 9 - 2 = 7 7 in seen? → No (seen is empty) → 把 2 存入 seen: seen = {2: 0} i=1, num=7: complement = 9 - 7 = 2 2 in seen? → Yes! seen[2] = 0 → 返回 [seen[2], i] = [0, 1] ✅

再来一个不那么直接的例子:

nums = [3, 2, 4], target = 6 seen = {} i=0, num=3: complement = 6 - 3 = 3 3 in seen? → No seen = {3: 0} i=1, num=2: complement = 6 - 2 = 4 4 in seen? → No seen = {3: 0, 2: 1} i=2, num=4: complement = 6 - 4 = 2 2 in seen? → Yes! seen[2] = 1 → 返回 [seen[2], i] = [1, 2] ✅ (nums[1] + nums[2] = 2 + 4 = 6 ✓)

Python 解法 / Python Solution

def twoSum(nums: list[int], target: int) -> list[int]:
    # Hash map: value → index
    # We store numbers we've already visited
    seen = {}
    
    for i, num in enumerate(nums):
        # What number do we NEED to complete the pair?
        complement = target - num
        
        # Check if that number is already in our map
        if complement in seen:
            # Found it! Return both indices
            return [seen[complement], i]
        
        # Haven't found a pair yet; record this number and its index
        seen[num] = i
    
    # Problem guarantees a solution exists, so we won't reach here
    return []


# Test cases
print(twoSum([2, 7, 11, 15], 9))   # [0, 1]
print(twoSum([3, 2, 4], 6))         # [1, 2]
print(twoSum([3, 3], 6))            # [0, 1]

复杂度分析 / Complexity Analysis

时间复杂度 Time: O(n) → 只遍历数组一次。哈希表查找是 O(1) 平均。 空间复杂度 Space: O(n) → 最坏情况下,哈希表存储 n-1 个元素(最后一对才匹配)。 vs. 暴力 Brute Force: Time: O(n²) — 双重循环 Space: O(1) — 不用额外空间

权衡: 用空间换时间。这通常是对的 — 内存便宜,时间贵。

Trade-off: We trade space for time. Usually the right call — memory is cheap, user time is not.


边界情况 / Edge Cases

# 两个相同的数字
twoSum([3, 3], 6)   # → [0, 1] ✅
# 关键:先检查 complement,再存入 seen
# 这样避免同一元素用两次

# 负数
twoSum([-1, -2, -3, -4, -5], -8)   # → [2, 4] (nums[2]+nums[4] = -3+-5)

# 只有两个元素
twoSum([1, 9], 10)   # → [0, 1]

举一反三 / Pattern Recognition

掌握了"边遍历边建哈希表"这个模式,你可以解决:

  • Two Sum II (sorted array) — 用双指针,O(1) 空间
  • Two Sum III (data structure) — 设计一个支持 add/find 的类
  • 3Sum (#15) — 固定一个数,对剩余用双指针
  • 4Sum (#18) — 嵌套一层再用双指针
  • Subarray Sum Equals K (#560) — 前缀和 + 哈希表

核心模式: "我需要找 X,先问问我见过 X 吗?没见过,就记下现在这个。"

The pattern: "I need X. Have I seen X? No? Then record what I have now."


*Day 3 | 数组与哈希系列 | 昨天:Valid Anagram | 明天:Contains Duplicate*
🗣️
🗣️ Soft Skills
🗣️ 软技能 Day 3 / Soft Skills Day 3

🗣️ 软技能 Day 3 / Soft Skills Day 3

Conflict Resolution — 冲突解决

问题 / Question:

"Tell me about a time you disagreed with your manager or a senior engineer. How did you handle it?"
"讲一个你与你的经理或高级工程师意见相左的经历。你是怎么处理的?"

为什么这很重要 / Why This Matters

这道题考察的不是"谁对谁错",而是:

  1. 你有没有主见? 没想法的工程师不能独立工作
  2. 你有没有成熟度? 能否在坚持立场和尊重经验之间取得平衡
  3. 你能不能影响他人? 在没有直接权力的情况下推动决策

This question isn't about who was right. It probes:

  1. Do you have independent judgment?
  2. Are you mature enough to push back respectfully?
  3. Can you influence without authority?

At senior/staff level, this is a daily reality. The inability to navigate technical disagreements is a major signal that someone isn't ready to operate at the next level.


STAR 框架拆解 / STAR Framework Breakdown

S - Situation (情境) ← 快速设置场景,30秒内 T - Task (任务) ← 你的目标/责任是什么 A - Action (行动) ← 这是重点,用70%的时间 R - Result (结果) ← 量化 + 反思

❌ 糟糕的回答 / Bad Approach

"我们在选数据库。我觉得应该用 PostgreSQL,我的经理说用 MongoDB。我给他看了对比文章,最后他同意了我的观点。"

为什么不好:

  • 没有上下文(为什么要做这个选择?)
  • 没有展示思考过程(你怎么决定提出来的?)
  • "给他看文章"太被动 — 没有体现你如何主动建立共识
  • 听起来像是"我赢了,他输了" — 没有合作感

✅ 好的回答 / Good Approach

"我们要为用户分析平台选择数据存储方案。我的Tech Lead倾向于继续用我们熟悉的MySQL,因为团队对它最熟悉,迁移成本低。我的判断是,我们的查询模式——大量聚合、时间序列、不规则的事件结构——更适合列式存储,比如ClickHouse。
我没有直接开会说'你错了'。我先花了两天做了一个小型基准测试:用两套方案各跑了我们最慢的5个查询,把性能数据整理成表格。同时我也整理了迁移的风险点和成本估算。
然后我约了Tech Lead 1-on-1,先说:'我想和你讨论一下数据库选型,我做了一些数据,想听听你的想法。'我们发现他的核心顾虑是迁移风险,而不是性能。于是我们达成了折中方案:新的分析pipeline用ClickHouse,老的业务数据留在MySQL,不做迁移。
最终上线后,分析查询从平均 8 秒降到 0.3 秒,用户投诉减少了 80%。而且我和Tech Lead的关系没有受损——他后来还把我当成这个领域的go-to person。"

为什么好:

  • 清楚的商业背景
  • 展示了"先做数据再谈分歧"的成熟判断
  • 用1-on-1而不是公开会议处理分歧(情商高)
  • 承认对方顾虑有道理,找到折中
  • 量化结果
  • 关系反而变好了

场景模板 / Scenario Template

用这个框架构建你自己的故事:

情境:我们在 [项目] 做 [技术决策]
分歧:我的 [经理/Tech Lead] 倾向于 [方案A]
      我的判断是 [方案B] 更合适,因为 [数据/理由]
行动:
  1. 我先 [做了什么验证工作],而不是直接开会争论
  2. 我通过 [1-on-1/小型演示/数据报告] 分享我的发现
  3. 我先理解了对方的核心顾虑是 [XXX]
  4. 我们达成了 [折中方案/对方被说服/我更新了我的判断]
结果:[量化结果] + [关系/团队影响]

Senior/Staff 级别的加分点 / Senior/Staff Level Tips

1. 展示你知道何时该放手 / Show you know when to let go

"我做了充分的论证,但最终决策权在他。我接受了这个决定,全力支持执行。六个月后,我们确实遇到了我预料的问题,但那时我们一起复盘,而不是我说'我早就说过了'。"

2. 主动建立共识而非赢得辩论 / Build alignment, don't win debates

Staff工程师知道:即使你是对的,如果你让别人"输了",你长期付出的代价更大。

Staff engineers know: even if you're right, making someone else "lose" costs you more in the long run.

3. 把技术分歧和人际关系分开 / Separate technical disagreement from personal conflict

"我特别注意在表达不同意见时,聚焦在数据和影响上,而不是质疑他的判断能力。"

关键要点 / Key Takeaways

✅ DO:
  - 先做功课(数据、原型、基准测试)再提出异议
  - 用1-on-1,不要在大会议上让人难堪
  - 理解对方顾虑,找折中点
  - 量化你的结果
  - 即使不同意,也要优雅地接受最终决策

❌ DON'T:
  - "我最终说服了他" 式的叙述(听起来自大)
  - 描述一个你完全错了的故事(除非重点是你从中学到了什么)
  - 没有结果("我们还在讨论…")
  - 批评你的前经理(面试官会想:他会不会也这么说我?)

*Day 3 | 软技能系列 | 昨天:影响力(无直接权力)| 明天:处理模糊需求*
🎨
🎨 Frontend
🎨 前端 Day 3 / Frontend Day 3

🎨 前端 Day 3 / Frontend Day 3

CSS Grid — Two-Dimensional Layouts / 二维布局

Week 1 | CSS Fundamentals


猜猜这段代码输出什么?/ What Does This Layout Look Like?

<div class="grid">
  <div>A</div>
  <div>B</div>
  <div>C</div>
  <div>D</div>
  <div>E</div>
</div>
.grid{
  display: grid;
  grid-template-columns: 1fr 2fr 1fr;
  grid-template-rows: 100px 100px;
  gap: 10px;
}

猜猜结果 / Guess the output:

┌────────┬───────────────┬────────┐ │ A │ B │ C │ │ (1fr) │ (2fr) │ (1fr) │ │ │ │ │ ← row 1: 100px tall │────────┼───────────────┼────────│ │ D │ E │(empty) │ │ (1fr) │ (2fr) │ │ ← row 2: 100px tall └────────┴───────────────┴────────┘ Total 4fr per row → A=25%, B=50%, C=25%

答案: 3列布局,比例 1:2:1。B 的宽度是 A 和 C 的两倍。第五个元素 E 占第二行第二格,第三格为空。


Grid vs Flexbox — 一句话记住 / One-Liner to Remember

Flexbox = 一维  (一行 or 一列)     Think: 导航栏, 按钮组
Grid    = 二维  (行 AND 列同时)    Think: 页面布局, 卡片网格

昨天(Day 2)我们学了 Flexbox。今天 Grid 是它的二维升级版。


核心概念图解 / Core Concepts Illustrated

display: grid; grid-template-columns: 1fr 1fr 1fr; ← 3 equal columns grid-template-rows: auto auto; ← 2 rows, height = content Grid Container (父元素) ┌──────────┬──────────┬──────────┐ │ cell │ cell │ cell │ ← row 1 │ [0,0] │ [0,1] │ [0,2] │ ├──────────┼──────────┼──────────┤ │ cell │ cell │ cell │ ← row 2 │ [1,0] │ [1,1] │ [1,2] │ └──────────┴──────────┴──────────┘ ↑ ↑ ↑ col 1 col 2 col 3

让子元素跨格 / Spanning Multiple Cells

/* 这个元素跨越2列 */
.item-a{
  grid-column: 1 / 3;   /* start at line 1, end at line 3 */
  /* shorthand: grid-column: span 2; */
}

/* 这个元素跨越2行 */
.item-b{
  grid-row: 1 / 3;      /* start at line 1, end at line 3 */
}
Before span: After .item-a spans 2 cols: ┌───┬───┬───┐ ┌─────────┬───┐ │ A │ B │ C │ │ A │ C │ ← A now takes col 1+2 ├───┼───┼───┤ ├───┬─────┴───┤ │ D │ E │ F │ │ D │ E │ F │ └───┴───┴───┘ └───┴─────┴───┘

代码示例:经典页面布局 / Classic Page Layout

.page{
  display: grid;
  grid-template-areas:
    "header  header  header"
    "sidebar main    main  "
    "footer  footer  footer";
  grid-template-columns: 200px 1fr 1fr;
  grid-template-rows: 60px 1fr 40px;
  min-height: 100vh;
  gap: 8px;
}

.header  { grid-area: header; }
.sidebar { grid-area: sidebar; }
.main    { grid-area: main; }
.footer  { grid-area: footer; }
Visual Result: ┌──────────────────────────────────┐ │ HEADER (full width) │ 60px ├───────────┬──────────────────────┤ │ │ │ │ SIDEBAR │ MAIN │ flex-grow │ (200px) │ (remaining) │ │ │ │ ├───────────┴──────────────────────┤ │ FOOTER (full width) │ 40px └──────────────────────────────────┘

grid-template-areas 的魔法: 用 ASCII 艺术描述布局,可读性极强。


你可能不知道 / You Might Not Know

1. fr 单位只分配剩余空间

grid-template-columns: 200px 1fr 1fr;

先分配固定的 200px,然后 把剩余宽度按 1:1 分给后两列。不是三等分!

fr only distributes remaining space after fixed sizes are allocated.

2. auto-fill vs auto-fit

/* auto-fill: 尽可能多地创建列(即使是空的) */
grid-template-columns: repeat(auto-fill, minmax(150px, 1fr));

/* auto-fit: 拉伸现有列填满空间(不创建空列) */
grid-template-columns: repeat(auto-fit, minmax(150px, 1fr));

这是响应式布局的神器——不写任何 media query 就能自适应!

This is the secret to responsive grid layouts without media queries.

3. Grid 也能嵌套

.card-grid{
  display: grid;
  grid-template-columns: repeat(3, 1fr);
}

.card{
  display: grid;  /* nested grid! */
  grid-template-rows: auto 1fr auto;  /* image | content | button */
}

Mini Challenge / 小挑战

用 CSS Grid 创建一个响应式卡片布局,要求:

  • 大屏显示4列,中等屏幕3列,小屏2列
  • 只用一行 CSS,不用任何 media query

<details>

<summary>提示 / Hint</summary>

.grid{
  display: grid;
  grid-template-columns: repeat(auto-fill, minmax(200px, 1fr));
  gap: 16px;
}

当容器宽度变化时,minmax(200px, 1fr) 会自动计算可以放多少列!

</details>


Flexbox vs Grid 决策树 / Decision Tree

你需要对齐内容吗? │ ├─ 只在一个方向(行 OR 列)→ 用 Flexbox │ 例:导航栏、按钮组、居中一个元素 │ └─ 同时在两个方向(行 AND 列)→ 用 Grid 例:页面整体布局、图片画廊、仪表盘

*Day 3 | CSS 布局系列 | 昨天:Flexbox | 明天:响应式设计 & Media Queries*

Interactive Flexbox Playground

Change the flex container controls and compare flex: 1 with flex: 1 1 auto.

Live Container
A
B
C
Shorthand Comparison

flex: 1 starts from zero width.

A short
B has much longer text content

flex: 1 1 auto respects content size first.

A short
B has much longer text content
🤖
🤖 AI
🤖 AI Day 3 — News Roundup / AI 新闻速递

🤖 AI Day 3 — News Roundup / AI 新闻速递

2026年3月第三周 | March 2026, Week 3

⚠️ 注意 / Note: AI 领域动态极快。以下新闻基于截至本文生成时的公开报道,具体数字与细节以原始来源为准。

📰 Story 1: Meta 的 "Avocado" 模型推迟发布

根据报道,Meta 的下一代 AI 大模型(内部代号 "Avocado")被推迟至至少 2026 年 5 月,原因是性能尚未达到 Google 等竞争对手的水平。

背景: Meta 此前招募了 Scale AI CEO Alexandr Wang,并投入数十亿美元试图追赶。Avocado 将是这一系列努力的首个重大发布。

为什么你应该关心 / Why You Should Care:

Meta 的 AI 布局直接影响整个生态——LLaMA 系列是很多开源项目的基础。如果 Avocado 继续落后于 GPT-4o 级别的模型,开源社区的"平替方案"质量也会受影响。对前端/全栈工程师来说:Meta AI 功能的集成(Facebook、Instagram、WhatsApp)会滞后,这可能影响你所在产品的 AI feature timeline。


📰 Story 2: Palantir 的 Maven Smart System — AI 军事应用的争议

Palantir 在其 AIPCon 会议上展示了 Maven Smart System,这是一个 AI 驱动的军事目标识别系统。演示视频显示,用户可以用"左键点击、右键点击、左键点击"的方式锁定打击目标,引发了广泛争议。

为什么你应该关心 / Why You Should Care:

这不只是道德话题——它是工程师职业生涯中越来越难以回避的现实问题。AI 的军事应用正在快速落地,而关于"工程师是否应该为武器系统写代码"的讨论也在硅谷持续升温(参考 Google 的 Project Maven 员工抗议事件)。面试中,你可能会被问到对这类项目的看法。答案没有对错,但你需要有自己的立场。


📰 Story 3: BuzzFeed 的 AI 教训 — 内容农场的警示

BuzzFeed 2025 年亏损达 $5730 万,股价跌至 $0.70,部分原因是大量使用 AI 生成文章和测验内容。尽管如此,CEO Jonah Peretti 仍表示将推出"新的 AI 应用"。

为什么你应该关心 / Why You Should Care:

这是一个"AI 用错地方"的典型案例。内容农场式的 AI 应用(用 AI 批量生产无差异化内容)正在被市场惩罚。读者不傻,算法(Google SEO、推荐算法)也越来越能识别低质量 AI 内容。

工程师视角: 如果你在构建 AI 内容工具,问题不是"能不能生成",而是"用户为什么要看这个而不是其他的"。差异化 > 数量。


📰 Story 4: Amazon Alexa Plus 新增"Sassy"个性模式

Amazon 为 Alexa Plus 推出了新的"Sassy"个性风格,特点是"不加滤镜的个性、机智的讽刺、以及偶尔被屏蔽的脏话"。该功能仅限成人,需要额外身份验证。

为什么你应该关心 / Why You Should Care:

这其实是一个有趣的 UX / AI 产品设计信号——用户对 AI 助手的"人格化"需求越来越强。语音 AI 的个性化是下一个竞争维度(而不只是"准确性")。

技术角度: 实现"可切换人格"需要在 prompt 层面和 safety filter 层面同时设计。"偶尔允许脏话"这个边界的实现本身就是个有趣的工程问题。


📰 Story 5: Meta 收购 Moltbook — AI 代理的"社交网络"

Meta 近期收购了 Moltbook,一个"AI 代理社交网络"平台。收购后,平台更新了服务条款:用户(不是 Meta)对其 AI 代理的所有行为负责,无论行为是否有意为之、是否自主发生。

为什么你应该关心 / Why You Should Care:

这是 AI 代理(Agent)时代的法律雏形。谁对 AI Agent 的行为负责?目前答案是"你,用户"。这对于正在构建 AI Agent 产品的工程师来说是重要信号:你需要设计审计日志、权限边界、和"人类在回路"(human-in-the-loop)机制,不只是因为产品好,而是因为法律会要求你这么做。


本周 AI 关键词 / This Week's AI Keywords

Agentic AI (代理式AI)    — AI 不只回答问题,而是自主行动
Human-in-the-loop (HITL) — 关键决策需要人类确认
AI Liability (AI责任归属) — 谁为 AI 的行为负责?
Model Delay (模型推迟)   — 发布时间表 ≠ 实际发布时间
AI + Military (AI军事化)  — 工程伦理的新战场

*Day 3 | AI 新闻系列 | 昨天:Transformer 工作原理 | 明天:RAG(检索增强生成)*

Attention Heatmap

When the model processes it, it attends most strongly to animal.

Theanimaldidntcrossthestreetbecauseitwastootired
it →