ai-developer-skill-os 8.1.7 → 8.1.9

package/.agents/skills/qk-code-review/references/cross-cutting/code-quality-universal.md

@@ -0,0 +1,358 @@
+# Các Anti-Pattern Chất lượng Code Phổ quát (Universal Code Quality)
+
+> Hướng dẫn nhận diện các anti-pattern về chất lượng code độc lập với ngôn ngữ, bao quát các chủ đề: Tái sử dụng code, Rò rỉ trừu tượng (Leaky abstraction), Phình to tham số (Parameter bloat), Câu lệnh điều kiện lồng nhau, Magic strings, TOCTOU, Cập nhật vô nghĩa (No-op update), v.v. Áp dụng cho mọi PR.
+
+## Mục lục
+
+- [Kiểm tra Tái sử dụng Code (Code Reuse)](#kiểm-tra-tái-sử-dụng-code)
+- [Phình to Tham số (Parameter Bloat)](#phình-to-tham-số)
+- [Rò rỉ Trừu tượng (Leaky Abstraction)](#rò-rỉ-trừu-tượng)
+- [Lạm dụng Chuỗi (String Typing)](#lạm-dụng-chuỗi)
+- [Điều kiện Lồng nhau (Nested Conditions)](#điều-kiện-lồng-nhau)
+- [Biến thể Copy-Paste (Copy-Paste Variations)](#biến-thể-copy-paste)
+- [Cập nhật Vô nghĩa (No-Op Updates)](#cập-nhật-vô-nghĩa)
+- [Lỗi tương tranh TOCTOU (Race Conditions)](#lỗi-tương-tranh-toctou)
+- [Thao tác quá rộng (Broad Operations)](#thao-tác-quá-rộng)
+- [Trạng thái Dư thừa (Redundant State)](#trạng-thái-dư-thừa)
+- [Checklist Chất lượng Chung](#checklist-chất-lượng-chung)
+
+---
+
+## Kiểm tra Tái sử dụng Code (Code Reuse)
+
+Trước khi chấp nhận code mới, hãy tìm kiếm trong source code xem đã có các hàm tiện ích (utilities) dùng chung nào chưa.
+
+### Tận dụng Utility có sẵn
+
+```python
+# ❌ Viết lại logic nối đường dẫn —— Trong project đã có sẵn PathBuilder
+def get_config_path(name):
+    base = os.environ.get("APP_ROOT", ".")
+    return os.path.join(base, "config", name + ".json")
+
+# ✅ Dùng PathBuilder đã có
+def get_config_path(name):
+    return PathBuilder.config(f"{name}.json")
+```
+
+```javascript
+// ❌ Tự viết tay hàm debounce —— Project đã có lodash hoặc utils/debounce.ts
+function debounce(fn, ms) {
+  let timer;
+  return (...args) => {
+    clearTimeout(timer);
+    timer = setTimeout(() => fn(...args), ms);
+  };
+}
+
+// ✅ Import hàm utility có sẵn
+import { debounce } from "@/utils/debounce";
+```
+
+**Checklist:**
+- [ ] Hàm mới viết có bị trùng tên hoặc trùng chức năng với utility có sẵn không?
+- [ ] Đoạn logic viết inline có thể thay thế bằng hàm dùng chung không?
+- [ ] Đã ngó qua thư mục `shared/utils` chưa?
+
+---
+
+## Phình to Tham số (Parameter Bloat)
+
+### Hàm có quá nhiều tham số
+
+```python
+# ❌ Cứ có yêu cầu mới là nhét thêm 1 tham số
+def create_user(name, email, role, team, active, avatar_url, timezone):
+    ...
+
+# ✅ Nhóm thành DataClass / Config Object
+@dataclass
+class CreateUserParams:
+    name: str
+    email: str
+    role: Role = Role.MEMBER
+    team: str | None = None
+    active: bool = True
+    avatar_url: str | None = None
+    timezone: str = "UTC"
+
+def create_user(params: CreateUserParams) -> User:
+    ...
+```
+
+```typescript
+// ❌ Hàm nhận 6 tham số cứng (positional arguments)
+function renderWidget(title: string, width: number, height: number, theme: string, collapsible: boolean, icon: string) { ... }
+
+// ✅ Pattern Options Object
+interface WidgetOptions {
+  title: string;
+  width?: number;
+  height?: number;
+  theme?: "light" | "dark";
+  collapsible?: boolean;
+  icon?: string;
+}
+function renderWidget(options: WidgetOptions) { ... }
+```
+
+**Checklist:**
+- [ ] Hàm có từ 4 tham số trở lên không? Hãy đổi sang Options Object.
+- [ ] Tham số mới thêm vào chỉ là một cái Cờ (Boolean flag)? Cân nhắc dùng Enum hoặc Strategy Pattern.
+- [ ] Có tham số nào triệt tiêu nhau không? (Vd: `enable_x` và `disable_y`).
+
+---
+
+## Rò rỉ Trừu tượng (Leaky Abstraction)
+
+### Để lọt chi tiết Implementation ra ngoài
+
+```python
+# ❌ Trả về Object của ORM —— Ép caller phải biết về thư viện SQLAlchemy
+def get_users():
+    return session.query(User).filter(User.active == True).all()
+
+# ✅ Trả về Domain Object (DTO), giấu tịt lớp Database đi
+def get_active_users() -> list[UserDTO]:
+    rows = user_repo.find_active()
+    return [UserDTO.from_row(r) for r in rows]
+```
+
+```typescript
+// ❌ Component nhận trực tiếp cấu trúc của API Response
+<UserCard user={apiResponse.data.results[0]} />
+
+// ✅ Component chỉ nhận Domain Type, dùng Adapter để chuyển đổi
+interface UserSummary {
+  displayName: string;
+  avatarUrl: string;
+}
+<UserCard user={adaptUser(apiResponse)} />
+```
+
+**Checklist:**
+- [ ] Kiểu trả về (Return type) của hàm có làm lộ thư viện bên dưới không (ORM, HTTP Client, JSON format)?
+- [ ] Component UI có bị dính chặt vào cấu trúc của hệ thống bên ngoài không?
+
+---
+
+## Lạm dụng Chuỗi (String Typing / Magic Strings)
+
+### Dùng String trần trụi thay vì Enum/Constant
+
+```python
+# ❌ Magic strings rải rác khắp nơi, gõ sai chính tả là ăn lỗi
+if status == "active": ...
+if role == "admin": ...
+
+# ✅ Gom thành Enum
+class Status(StrEnum):
+    ACTIVE = "active"
+    SUSPENDED = "suspended"
+
+if user.status == Status.ACTIVE: ...
+```
+
+```typescript
+// ❌ Tên event bằng string —— Code editor không gợi ý, gõ sai không báo lỗi
+emitter.emit("userCreated", data);
+emitter.on("usercreated", handler); // BUG do gõ sai chữ C thành c
+
+// ✅ Dùng Object Constant / Enum
+const Events = {
+  USER_CREATED: "userCreated",
+} as const;
+emitter.emit(Events.USER_CREATED, data);
+```
+
+**Checklist:**
+- [ ] Có string nào dùng để đại diện cho Trạng thái (Status) / Loại (Type) mà chưa gom vào Enum không?
+
+---
+
+## Điều kiện Lồng nhau (Nested Conditions)
+
+### Khối lệnh IF/ELSE lồng nhau sâu hoắm
+
+```python
+# ❌ Chuỗi Ternary (Toán tử 3 ngôi) dài dòng
+label = (
+    "Admin" if role == "admin" else
+    "Manager" if role == "manager" else
+    "Viewer" if role == "viewer" else
+    "Unknown"
+)
+
+# ✅ Dùng Lookup Table (Dictionary / Map)
+ROLE_LABELS = {
+    "admin": "Admin",
+    "manager": "Manager",
+    "viewer": "Viewer",
+}
+label = ROLE_LABELS.get(role, "Unknown")
+```
+
+```python
+# ❌ IF lồng 3 lớp (Arrow code / Hadouken code)
+def process(order):
+    if order is not None:
+        if order.items:
+            for item in order.items:
+                if item.price > 0:
+                    ...
+
+# ✅ Early Return (Bảo vệ từ sớm)
+def process(order):
+    if not order or not order.items:
+        return
+    for item in order.items:
+        if item.price <= 0:
+            continue
+        ...
+```
+
+**Checklist:**
+- [ ] Toán tử 3 ngôi lồng nhau $\ge$ 2 lớp?
+- [ ] IF/ELSE lồng nhau $\ge$ 3 lớp?
+- [ ] Có thể thay thế bằng Lookup Table, Match/Switch, hoặc Early Return không?
+
+---
+
+## Biến thể Copy-Paste (Copy-Paste Variations)
+
+### Các khối code giống hệt nhau, chỉ khác mỗi cái tên
+
+```typescript
+// ❌ Copy-paste handler, chỉ thay đổi cái URL
+async function deletePost(id: string) {
+  await fetch(`/api/posts/${id}`, { method: "DELETE" });
+  router.push("/posts");
+}
+async function deleteComment(id: string) {
+  await fetch(`/api/comments/${id}`, { method: "DELETE" });
+  router.push("/comments");
+}
+
+// ✅ Parameter hóa (Truyền biến vào)
+async function deleteResource(resource: string, id: string) {
+  await fetch(`/api/${resource}/${id}`, { method: "DELETE" });
+  router.push(`/${resource}`);
+}
+```
+
+**Checklist:**
+- [ ] Có $\ge$ 2 đoạn code y hệt nhau, chỉ khác mỗi biến/URL/chữ không? Đưa thành hàm chung có tham số đi.
+
+---
+
+## Cập nhật Vô nghĩa (No-Op Updates)
+
+### Chọc vào State/DB ngay cả khi dữ liệu không đổi
+
+```typescript
+// ❌ Cứ mỗi 5 giây là setStatus một lần mặc kệ data có đổi hay không (khiến UI re-render)
+useEffect(() => {
+  const interval = setInterval(() => {
+    fetch("/api/status").then(r => r.json()).then(setStatus);
+  }, 5000);
+  return () => clearInterval(interval);
+}, []);
+
+// ✅ Kiểm tra trước khi set
+setStatus(prev => isEqual(prev, data) ? prev : data);
+```
+
+```python
+# ❌ Vòng lặp liên tục update DB dù giá trị bằng y hệt cũ
+for item in items:
+    item.status = compute_status(item)
+    session.commit()
+
+# ✅ Chỉ update nếu có thay đổi (Dirty check)
+for item in items:
+    new_status = compute_status(item)
+    if item.status != new_status:
+        item.status = new_status
+        session.commit()
+```
+
+---
+
+## Lỗi tương tranh TOCTOU (Time-of-Check-to-Time-of-Use)
+
+### "Kiểm tra trước - Làm sau" trong môi trường Đồng thời (Concurrency)
+
+```python
+# ❌ Kiểm tra file tồn tại rồi mới mở -> Nhỡ lúc mở file nó bị xóa rồi thì sao?
+if os.path.exists(path):
+    with open(path) as f:
+        data = f.read()
+
+# ✅ Cứ mở file đi, lỗi thì Bắt (Try/Catch)
+try:
+    with open(path) as f:
+        data = f.read()
+except FileNotFoundError:
+    data = None
+```
+
+```python
+# ❌ Lỗi kinh điển hệ thống ngân hàng: Kiểm tra số dư rồi mới trừ tiền (Không Atomic)
+if account.balance >= amount:
+    account.balance -= amount
+
+# ✅ Bỏ vào Giao dịch (Transaction) hoặc Khóa (Lock)
+with account.lock:
+    if account.balance < amount:
+        raise InsufficientFundsError()
+    account.balance -= amount
+```
+
+---
+
+## Thao tác quá rộng (Broad Operations)
+
+### Lấy nguyên xe tải hàng trong khi chỉ cần 1 củ tỏi
+
+```typescript
+// ❌ Lấy nguyên bảng Orders về RAM chỉ để lọc ra 2 đơn hàng Pending
+const allItems = await db.query("SELECT * FROM orders");
+const pending = allItems.filter(o => o.status === "pending");
+
+// ✅ Đẩy việc lọc (Filter) xuống cho Database làm
+const pending = await db.query(
+  "SELECT * FROM orders WHERE status = ?", ["pending"]
+);
+```
+
+```python
+# ❌ Đọc nguyên cái file log bự chà bá chỉ để lấy Dòng số 1
+content = Path("log.txt").read_text()
+first_line = content.split("\n")[0]
+
+# ✅ Đọc đúng 1 dòng (Stream)
+with open("log.txt") as f:
+    first_line = f.readline()
+```
+
+---
+
+## Trạng thái Dư thừa (Redundant State)
+
+### Trạng thái có thể Tự suy luận (Derived)
+
+```typescript
+// ❌ Lưu trữ thừa mứa: Đã có firstName và lastName rồi còn lưu fullName làm gì?
+interface User {
+  firstName: string;
+  lastName: string;
+  fullName: string;  // Redundant! Nếu update firstName mà quên update fullName là Toang!
+}
+
+// ✅ Tính toán tự động dựa trên gốc
+interface User {
+  firstName: string;
+  lastName: string;
+}
+const fullName = `${user.firstName} ${user.lastName}`;
+```

package/.agents/skills/qk-code-review/references/cross-cutting/code-review-best-practices.md

@@ -0,0 +1,136 @@
+# Best Practice Review Code (Code Review Best Practices)
+
+Bí kíp toàn diện để tiến hành Code Review một cách hiệu quả và chuyên nghiệp.
+
+## Triết lý Review (Review Philosophy)
+
+### Mục tiêu của Code Review
+
+**Mục tiêu Chính:**
+- Bắt lỗi (bugs) và các trường hợp biên (edge cases) trước khi đẩy lên Production.
+- Đảm bảo code dễ bảo trì (maintainability) và dễ đọc (readability).
+- Chia sẻ kiến thức (knowledge sharing) giữa các thành viên trong team.
+- Ép buộc tuân thủ chuẩn code (coding standards) một cách nhất quán.
+- Cải thiện các quyết định về Thiết kế và Kiến trúc.
+
+**Mục tiêu Phụ:**
+- Hướng dẫn (Mentor) cho các developer trẻ.
+- Xây dựng văn hóa và sự tin tưởng trong team.
+- Document lại các quyết định thiết kế thông qua quá trình thảo luận.
+
+### Code Review KHÔNG PHẢI là:
+
+- Một công cụ gác cổng hạch sách để cản trở tiến độ.
+- Một nơi để phô trương kiến thức cá nhân.
+- Nơi để bắt bẻ từng dấu phẩy, dấu cách (Việc đó để linter tự động làm).
+- Nơi để ép người khác viết lại code theo sở thích cá nhân của mình.
+
+## Thời điểm Review (Review Timing)
+
+### Khi nào thì Review?
+
+| Kích hoạt (Trigger) | Hành động (Action) |
+|---------|--------|
+| PR vừa mở | Review trong vòng 24 giờ, lý tưởng nhất là trong ngày |
+| PR đã sửa theo yêu cầu | Re-review lại trong vòng 4 giờ |
+| Phát hiện lỗi chí mạng (Blocking) | Thông báo ngay lập tức |
+
+### Phân bổ thời gian
+
+- **PR Nhỏ (<100 lines)**: 10-15 phút
+- **PR Vừa (100-400 lines)**: 20-40 phút
+- **PR Lớn (>400 lines)**: Yêu cầu chia nhỏ ra, hoặc dành >60 phút để review
+
+## Các cấp độ Review (Review Depth Levels)
+
+### Level 1: Skim Review (Lướt nhanh - 5 phút)
+- Đọc mô tả PR và các Issues được đính kèm.
+- Kiểm tra trạng thái của CI/CD (Test có pass không).
+- Lướt qua danh sách các file thay đổi.
+- Xác định xem có cần Review sâu hơn không.
+
+### Level 2: Standard Review (Chuẩn mực - 20-30 phút)
+- Đọc lướt toàn bộ luồng code (Walkthrough).
+- Kiểm tra logic có đúng không.
+- Kiểm tra xem có viết Test Cover không.
+- Quét nhanh các vấn đề bảo mật.
+
+### Level 3: Deep Review (Chuyên sâu - >60 phút)
+- Đánh giá kiến trúc hệ thống.
+- Phân tích hiệu năng (Performance).
+- Kiểm toán Bảo mật (Security audit).
+- Khám phá các rủi ro ở trường hợp biên (Edge cases).
+
+## Nguyên tắc Giao tiếp (Communication Guidelines)
+
+### Thái độ và Ngôn từ
+
+**Sử dụng ngôn từ hợp tác:**
+- "Bạn nghĩ sao về việc..." thay vì "Bạn phải làm thế này..."
+- "Chúng ta có thể thử cân nhắc..." thay vì "Cái này sai rồi!"
+- "Mình hơi thắc mắc chỗ này..." thay vì "Tại sao bạn không..."
+
+**Cụ thể và có tính Action (Actionable):**
+- Đưa ra ví dụ code (code examples) khi đề xuất thay đổi.
+- Kèm link đến tài liệu (docs) hoặc các cuộc thảo luận cũ.
+- Giải thích "TẠI SAO" (Why) lại đưa ra lời khuyên đó.
+
+### Xử lý Bất đồng (Handling Disagreements)
+
+1. **Cố gắng thấu hiểu**: Đặt câu hỏi làm rõ ý của người kia.
+2. **Ghi nhận điểm đúng**: Cho thấy bạn đã suy nghĩ ở góc độ của họ.
+3. **Đưa ra bằng chứng**: Dùng benchmark, docs, hoặc ví dụ cụ thể.
+4. **Escalate (Nâng cấp) nếu cần**: Mời Senior Dev hoặc Architect vào phân xử.
+5. **Biết khi nào nên dừng lại**: Không phải cuộc tranh cãi nào cũng đáng để sống chết bảo vệ.
+
+## Phân loại Mức độ Ưu tiên (Review Prioritization)
+
+### 🔴 Must Fix (Bắt buộc sửa / Blocking)
+- Lỗ hổng Bảo mật (Security vulnerabilities).
+- Nguy cơ làm hỏng / mất dữ liệu (Data corruption).
+- Các thay đổi làm gãy (Breaking changes) mà không có kịch bản chuyển đổi (migration).
+- Lỗi hiệu năng chí mạng.
+- Quên không bắt lỗi (Error handling) ở các tính năng hiển thị cho End-user.
+
+### 🟡 Should Fix (Nên sửa / Important)
+- Bỏ sót chưa viết Test (Test coverage gaps).
+- Rủi ro hiệu năng ở mức vừa phải.
+- Code bị lặp lại (Duplication).
+- Đặt tên tối nghĩa hoặc Cấu trúc rối rắm.
+- Logic quá phức tạp mà không có comment giải thích.
+
+### 🟢 Nice to Have (Có thì tốt / Non-blocking)
+- Sở thích về Style code (nằm ngoài scope của Linter).
+- Các tối ưu nhỏ lẻ (Minor optimizations).
+- Thêm thắt vài Test case phụ.
+- Cải thiện câu từ trong Document.
+
+## Anti-Patterns cần tránh
+
+### Anti-Patterns của người Review
+- **Rubber stamping (Đóng dấu bừa)**: Bấm Approve (Duyệt) mà không thèm xem code.
+- **Bike shedding (Tranh cãi chuyện ruồi muỗi)**: Cãi nhau nảy lửa về những tiểu tiết vớ vẩn.
+- **Scope creep (Tiện tay dắt dê)**: "Nhân tiện bạn đang sửa file này, bạn làm thêm cái tính năng X này nhé..."
+- **Ghosting (Bốc hơi)**: Thả 1 đống Request Changes rồi lặn mất tăm, không thèm quay lại xem người ta sửa chưa.
+- **Perfectionism (Chủ nghĩa hoàn hảo)**: Chặn PR (Block) chỉ vì vài khác biệt nhỏ về phong cách cá nhân.
+
+### Anti-Patterns của người Viết Code (Author)
+- **Mega PRs (PR Siêu to khổng lồ)**: Gửi 1 cục PR dài >1000 dòng bắt người ta ngồi đọc.
+- **No context (Không có ngữ cảnh)**: Để trống mô tả PR, không link issue nào.
+- **Defensive responses (Xù lông nhím)**: Cãi lại mọi lời góp ý, khăng khăng mình đúng.
+- **Silent updates (Sửa trong im lặng)**: Lẳng lặng commit sửa code nhưng không thèm Reply lại các comment báo cho người Review biết.
+
+## Số liệu và Cải tiến (Metrics and Improvement)
+
+### Nên theo dõi các Số liệu sau
+- Thời gian từ lúc mở PR đến lúc có Review đầu tiên (Time to first review).
+- Tổng thời gian hoàn thành một vòng Review (Review cycle time).
+- Số vòng Review phải đập đi xây lại (Number of review rounds).
+- Tỷ lệ lỗi lọt qua lưới (Defect escape rate).
+- Tỷ lệ Cover của quá trình Review.
+
+### Cải tiến liên tục
+- Tổ chức các buổi Retrospective để bàn về quy trình Review.
+- Chia sẻ bài học từ các con Bug lọt ra Production.
+- Cập nhật các Checklist Review liên tục dựa trên các lỗi hay gặp.
+- Tuyên dương những bài Review chất lượng, bắt được lỗi hiểm hóc.

package/.agents/skills/qk-code-review/references/cross-cutting/common-bugs-checklist.md

@@ -0,0 +1,124 @@
+# Checklist Lỗi Phổ biến (Common Bugs Checklist)
+
+Bảng tra cứu nhanh các mẫu lỗi thường gặp, được phân loại theo từng nhóm. Để xem ví dụ chi tiết, giải thích sâu hơn và checklist đầy đủ, vui lòng tham khảo cẩm nang của từng ngôn ngữ cụ thể được liên kết bên dưới.
+
+## Các vấn đề Phổ quát (Universal Issues)
+
+### Lỗi Logic
+- [ ] Lỗi lệch một đơn vị (Off-by-one errors) trong vòng lặp và truy xuất mảng.
+- [ ] Lỗi logic Boolean (Vi phạm định luật De Morgan).
+- [ ] Quên kiểm tra null/undefined.
+- [ ] Lỗi tương tranh (Race conditions) trong môi trường đồng thời (concurrent).
+- [ ] Dùng sai toán tử so sánh (Ví dụ: `==` thay vì `===`, hoặc `=` thay vì `==`).
+- [ ] Tràn số nguyên (Integer overflow/underflow).
+- [ ] Sai số khi so sánh số thực dấu phẩy động (Floating point comparison issues).
+
+### Quản lý Tài nguyên
+- [ ] Rò rỉ bộ nhớ (Memory leaks) do quên đóng connection, listener.
+- [ ] Quên đóng File handles.
+- [ ] Quên trả lại Database connections vào Pool.
+- [ ] Quên gỡ Event listeners khi không còn dùng.
+- [ ] Quên xóa Timers/intervals (gọi `clearTimeout` / `clearInterval`).
+
+### Xử lý Lỗi (Error Handling)
+- [ ] Nuốt lỗi (Swallowed exceptions) bằng các khối `catch` để trống.
+- [ ] Catch lỗi quá rộng (Generic exception handling) làm che mất lỗi thực sự.
+- [ ] Quên đẩy (propagate) lỗi lên cấp trên.
+- [ ] Ném ra (Throw) sai loại Exception.
+- [ ] Thiếu khối `finally` để dọn dẹp tài nguyên.
+
+## TypeScript/JavaScript
+
+- [ ] Dùng `==` thay vì `===`.
+- [ ] Lạm dụng `any` — Khuyến khích dùng type cụ thể hoặc `unknown` kết hợp type guards.
+- [ ] Quên `await` khi gọi hàm bất đồng bộ.
+- [ ] Không bắt lỗi promise rejections (Thiếu `try-catch` khi gọi `await`).
+- [ ] Bị mất context `this` khi gọi callback.
+- [ ] Quên truyền prop `key` khi render danh sách (list).
+- [ ] Closure vô tình giữ lại biến cũ của vòng lặp (stale loop variable).
+- [ ] Gọi `parseInt` mà không truyền tham số cơ số (radix).
+- [ ] Sửa đổi trực tiếp (Modify) mảng/object trong khi đang lặp qua nó.
+
+## React / React 19
+
+- [ ] Gọi Hooks bên trong lệnh if hoặc vòng lặp (Vi phạm Rules of Hooks).
+- [ ] Mảng phụ thuộc (dependency array) của `useEffect` bị thiếu hoặc sai.
+- [ ] `useEffect` thiếu hàm cleanup (đối với các subscriptions, timers, fetches).
+- [ ] Lạm dụng `useEffect` để tính toán state suy diễn (Derived state) — thay vào đó hãy dùng `useMemo`.
+- [ ] Lạm dụng `useMemo`/`useCallback`, hoặc dùng mà không đi kèm `React.memo`.
+- [ ] Định nghĩa Component con ngay bên trong Component cha (Khiến component bị re-mount mỗi lần render).
+- [ ] Truyền props không ổn định (inline object/function) cho các component đã được `memo`.
+- [ ] Thay đổi trực tiếp (Mutate) vào props.
+- [ ] Thiếu `key` trong mảng, hoặc lấy `index` làm key cho các mảng có khả năng sắp xếp lại (reorder).
+
+## Python
+
+- [ ] Dùng mutable data làm giá trị mặc định (`def f(x=[])`).
+- [ ] Dùng `except:` trần trụi (sẽ bắt nhầm luôn cả `KeyboardInterrupt` và `SystemExit`).
+- [ ] Chia sẻ thuộc tính (Shared mutable attributes) sai cách ở cấp độ Class (`class C: items = []`).
+- [ ] Dùng `is` thay vì `==` để so sánh giá trị (value comparison).
+- [ ] Quên khai báo tham số `self` trong các phương thức của Class.
+- [ ] Thay đổi danh sách (Modify list) trong khi đang duyệt (iterating).
+- [ ] Cộng chuỗi trong vòng lặp (Khuyến khích dùng `"".join()`).
+- [ ] Quên đóng file (Nên dùng câu lệnh `with`).
+- [ ] Thiếu Type annotations (khai báo kiểu) ở các public functions.
+
+## Go
+
+- [ ] Phớt lờ lỗi (`result, _ := SomeFunction()`).
+- [ ] Chạy Goroutine mà không có cơ chế thoát (Gây rò rỉ bộ nhớ).
+- [ ] Quên truyền, hoặc truyền sai `context.Context`.
+- [ ] Lỗi Capture biến của vòng lặp (Ở các bản Go < 1.22).
+- [ ] Gọi `defer` ở trong vòng lặp (Chỉ được thực thi khi kết thúc hàm, KHÔNG PHẢI kết thúc vòng lặp).
+- [ ] Khai báo đè biến (Variable shadowing).
+- [ ] Dùng Map trước khi khởi tạo (`make`).
+- [ ] Bọc lỗi (Error wrapping) bằng `%v` thay vì `%w` (Làm hỏng `errors.Is`/`errors.As`).
+
+## Java / Spring Boot
+
+- [ ] Viết dài dòng cho POJO/DTO thay vì dùng `record` *(Java 17+)*.
+- [ ] Quên `break` trong switch truyền thống (Nên dùng switch expressions) *(Java 14+)*.
+- [ ] Dùng Field injection (`@Autowired` thẳng vào biến) thay vì Constructor injection.
+- [ ] Lỗi N+1 query trong JPA (Quên `fetch join` hoặc `@EntityGraph`).
+- [ ] Gọi `Optional.get()` mà không chịu check `isPresent()` trước.
+- [ ] Stream operations có chứa side effects.
+
+## PHP
+
+- [ ] Thiếu `declare(strict_types=1);` ở đầu file mới.
+- [ ] So sánh yếu (`==`, `!=`) ở những chỗ nhạy cảm như login, token, thanh toán.
+- [ ] Dùng `in_array()` / `array_search()` mà không bật chế độ nghiêm ngặt (strict mode).
+- [ ] Nối chuỗi để build câu lệnh SQL (Dễ dính SQL Injection) thay vì dùng Prepared statements.
+- [ ] In dữ liệu user (echo) mà không escape (Dễ dính XSS).
+- [ ] Lưu password bằng `md5()` / `sha1()` thay vì `password_hash()`.
+- [ ] Che giấu lỗi bằng dấu `@` hoặc nuốt lỗi bằng `catch` để trống.
+
+## SQL
+
+- [ ] Nối chuỗi để tạo query (Rủi ro SQL Injection) — luôn dùng Parameterized queries.
+- [ ] Bỏ quên Index ở những cột hay bị filter/join.
+- [ ] Dùng `SELECT *` thay vì chọn các cột cụ thể.
+- [ ] Mẫu truy vấn N+1 (N+1 query patterns).
+- [ ] Truy vấn bảng lớn mà không có `LIMIT`.
+- [ ] So sánh `NULL` sai cách (`IS NULL` vs `= NULL`).
+- [ ] Quên bao bọc các thao tác liên quan vào trong một Transaction.
+- [ ] Chọn sai loại JOIN.
+
+## Thiết kế API (API Design)
+
+- [ ] Đặt tên endpoint (resource) thiếu nhất quán.
+- [ ] Chọn sai HTTP methods (Ví dụ: Dùng POST cho một thao tác Idempotent thay vì PUT/PATCH).
+- [ ] API lấy danh sách mà không có phân trang (pagination).
+- [ ] Trả về sai HTTP Status codes.
+- [ ] Không giới hạn số lượng request (Thiếu Rate limiting).
+- [ ] Thiếu kiểm duyệt (validation) và làm sạch dữ liệu đầu vào.
+- [ ] Chỉ tin tưởng hoàn toàn vào sự kiểm duyệt từ phía Client.
+
+## Testing
+
+- [ ] Chỉ chăm chăm test các chi tiết bên trong (Implementation details) thay vì test hành vi (Behavior) hiển thị ra bên ngoài.
+- [ ] Bỏ sót các trường hợp Edge case (trường hợp biên).
+- [ ] Test chạy lúc pass lúc fail (Flaky tests / Non-deterministic).
+- [ ] Test chạy thẳng vào External dependencies (Thiếu mocks).
+- [ ] Thiếu test cho các trường hợp báo lỗi (Negative tests).
+- [ ] Setup bài test quá phức tạp.