# 🛠️ Debug Workflow JavaScript/ES2025 với Windsurf Cascade AI

> **Mục đích:** Tối ưu hóa quá trình debug JS/ES2025 khi làm việc với Cascade — biết hỏi đúng, đánh giá đúng, tin đúng chỗ.

---

## 📋 MỤC LỤC

1. [Câu hỏi prompt hiệu quả cho Cascade](#1-câu-hỏi-prompt-hiệu-quả-cho-cascade)
2. [Checklist trước khi submit bug](#2-checklist-trước-khi-submit-bug-cho-cascade)
3. [Đánh giá độ tin cậy response của Cascade](#3-đánh-giá-độ-tin-cậy-response-của-cascade)
4. [Lỗi JS/ES2025 Cascade làm tốt vs không tốt](#4-lỗi-jses2025-cascade-làm-tốt-vs-không-tốt)

---

## 1. 💬 Câu Hỏi Prompt Hiệu Quả Cho Cascade

### 🔴 Template Prompt Chuẩn

```
Context: [môi trường, version Node/Deno/Browser]
Code: [paste snippet hoặc mô tả]
Error: [exact error message + stack trace]
Đã thử: [những gì bạn đã làm]
Hỏi: [câu hỏi cụ thể]
```

---

### ⏱️ 1.1 Async Bug Prompts

#### ❌ Prompt yếu
```
Tại sao code async của tôi bị lỗi?
```

#### ✅ Prompt mạnh

**Khi bị Race Condition:**
```
Code này có race condition không? Hai async function cùng 
write vào `userState` mà không có lock. Node.js 22, không dùng 
worker thread. Trace qua execution order giúp tôi.

[paste code]

Expected: userState luôn consistent
Actual: userState bị overwrite ngẫu nhiên
```

**Khi Promise không resolve:**
```
Promise này hang vô thời hạn trong môi trường test (Jest 29 + 
jsdom). Không hang khi chạy production. 

Hỏi: 
1. Tại sao behavior khác nhau giữa jest và browser?
2. Promise.race() với timeout có phải solution tốt không?
3. Có pattern nào tốt hơn cho case này?

[paste code]
```

**Khi await trong loop sai:**
```
Tôi dùng await trong forEach và kết quả không đúng thứ tự.
ES2025, Node.js 22.

Hỏi:
- Tại sao forEach không await đúng?
- So sánh for...of vs Promise.all() vs for await...of cho case này
- Case nào nên dùng cái nào?
```

**Prompt mẫu cho Async Error Boundary:**
```
Async function throw error nhưng không bị catch bởi 
try/catch bên ngoài. Stack trace:

[paste stack trace]

Hỏi: Error này xảy ra ở microtask hay macrotask queue? 
Tại sao try/catch miss? Fix đúng cách?
```

---

### 📦 1.2 ESM Conflict Prompts

**Khi bị "Cannot use import statement":**
```
Environment: Node.js 22, package.json KHÔNG có "type": "module"
Error: SyntaxError: Cannot use import statement in a module

File structure:
- index.js (dùng import/export)  
- package.json [paste nội dung]
- tsconfig.json (nếu có) [paste]

Đã thử: Thêm .mjs extension → vẫn lỗi với dependency X

Hỏi:
1. Root cause chính xác là gì?
2. Cách fix không break CJS dependencies?
3. Dual package hazard có xảy ra ở đây không?
```

**Khi bị "ERR_REQUIRE_ESM":**
```
Library X (ESM-only) được require() bởi legacy CJS code.
Node.js 22. Không thể rewrite toàn bộ codebase sang ESM ngay.

Hỏi:
1. Dynamic import() workaround có side effect gì?
2. Bundler (Webpack 5 / Rollup / Vite) nào handle tốt nhất?
3. Tôi có thể dùng createRequire không? Khi nào nên/không nên?
```

**Khi circular import:**
```
Module A import từ B, B import từ A. Không báo error nhưng 
function undefined lúc runtime.

[paste dependency graph hoặc mô tả]

Hỏi:
1. Giải thích ESM circular dependency resolution order
2. Tại sao undefined thay vì error?
3. Refactor strategy không phá vỡ architecture hiện tại?
```

---

### 🧠 1.3 Memory Leak Prompts

**Template chuẩn cho memory leak:**
```
Environment: Node.js 22, long-running server process
Triệu chứng: Heap tăng từ 50MB → 800MB sau 6 tiếng, không 
về baseline sau GC (--expose-gc test)

Đã profiling: Chrome DevTools heap snapshot → thấy nhiều 
[ClassName] objects không được release

Code patterns nghi ngờ:
[paste các đoạn code liên quan]

Hỏi:
1. Pattern nào trong code trên likely gây leak?
2. Cách viết test để reproduce leak deterministically?
3. Fix từng pattern với giải thích tại sao nó leak?
```

**Khi leak từ Event Listener:**
```
Tôi add event listener trong component/class nhưng không 
remove khi destroy. 

Hỏi:
1. Tại sao listener giữ reference đến object đã "chết"?
2. Pattern AbortController vs removeEventListener, cái nào 
   tốt hơn cho ES2025?
3. WeakRef có giúp ích ở đây không? Khi nào WeakRef phù hợp?
```

**Khi nghi ngờ closure leak:**
```
Function này được gọi hàng nghìn lần, mỗi lần tạo closure 
mới. Suspicion: closure giữ reference đến large object.

[paste code]

Hỏi:
1. Vẽ ra reference chain từ closure đến object bị giữ
2. Restructure code để break reference chain?
3. FinalizationRegistry có nên dùng ở đây không?
```

---

### 🗂️ 1.4 State Management Prompts

**Khi state không update đúng:**
```
Framework: [React 19 / Vue 4 / Vanilla JS]
Pattern: [Redux / Zustand / Signals / custom]

State update được gọi nhưng UI không re-render. 
DevTools confirm state đã thay đổi.

[paste reducer/store code]
[paste component code]

Hỏi:
1. Tại sao state change không trigger re-render?
2. Reference equality vs deep equality trong trường hợp này?
3. Immutable update pattern đúng cho nested object này?
```

**Khi state bị stale closure:**
```
Event handler đọc state cũ (stale closure). 
React 19, hooks.

[paste code]

Hỏi:
1. Giải thích tại sao closure "capture" giá trị cũ
2. useRef vs useCallback vs setState functional update — 
   cái nào fix đúng cho case này?
3. Nếu dùng Signals (TC39 proposal) thì có tránh được không?
```

**Khi concurrent state update conflict:**
```
Nhiều async operations cùng update một piece of state.
Kết quả cuối cùng không deterministic.

Pattern hiện tại: [mô tả]
Hỏi:
1. Đây có phải vấn đề của tearing không?
2. Optimistic update với rollback nên implement thế nào?
3. So sánh approach: queue updates vs pessimistic locking vs CRDTs
```

---

## 2. ✅ Checklist Trước Khi Submit Bug Cho Cascade

### 📝 Pre-Submit Checklist

#### 🔍 Thông tin cơ bản
- [ ] **Runtime version** đã ghi rõ (Node 22.x, Deno 2.x, Chrome 131, Safari 18...)
- [ ] **ES version target** đã xác định (ES2025, ESNext, ES2020...)
- [ ] **Package versions** của các lib liên quan đã paste (package.json snippet)
- [ ] **Môi trường** đã nêu rõ (local dev / CI / production / test)
- [ ] **OS** nếu bug có thể platform-specific (Windows path issues, etc.)

#### 🐛 Mô tả bug
- [ ] **Error message chính xác** đã paste (không paraphrase, copy nguyên văn)
- [ ] **Stack trace đầy đủ** đã paste (không cắt bớt)
- [ ] **Expected behavior** đã mô tả rõ ràng
- [ ] **Actual behavior** đã mô tả rõ ràng
- [ ] **Steps to reproduce** đã list theo thứ tự
- [ ] **Tần suất xảy ra** đã nêu (luôn luôn / đôi khi / chỉ under load)

#### 💻 Code quality
- [ ] **Code đã được tối giản** (minimal reproducible example — không paste cả file 500 dòng)
- [ ] **Thông tin nhạy cảm đã xóa** (API keys, passwords, PII)
- [ ] **Code đã format** (dễ đọc hơn → Cascade hiểu tốt hơn)
- [ ] **Comments giải thích intent** đã thêm vào chỗ quan trọng
- [ ] **Imports đã đầy đủ** (Cascade cần biết dependencies)

#### 🔬 Đã tự debug
- [ ] **Đã search error message** trước (Google, MDN, GitHub Issues)
- [ ] **Đã thử những gì** đã liệt kê (tránh Cascade đề xuất thứ bạn đã thử)
- [ ] **Đã isolate bug** (biết chắc vấn đề ở đoạn nào)
- [ ] **Console logs / debugger output** đã paste nếu có
- [ ] **Heap snapshot / Performance trace** đã đính kèm nếu là perf bug

#### 🎯 Câu hỏi rõ ràng
- [ ] **Câu hỏi cụ thể** (không hỏi "fix giúp tôi" — hỏi "tại sao X gây Y?")
- [ ] **Số lượng câu hỏi hợp lý** (2-4 câu liên quan, không scatter)
- [ ] **Ưu tiên đã nêu** (muốn hiểu nguyên nhân hay chỉ cần fix nhanh?)
- [ ] **Constraint đã nêu** (không được dùng lib X, phải support IE11, etc.)

---

### 🚦 Quick Pre-Submit Checklist (Phiên bản rút gọn)

```
Trước khi submit, tự hỏi:
□ Cascade có đủ context để hiểu vấn đề không?
□ Error message đã paste nguyên văn chưa?
□ Code đã tối giản chưa (MRE)?
□ Tôi muốn Cascade giúp gì cụ thể?
□ Tôi đã thử gì rồi?
```

---

## 3. 🔎 Đánh Giá Độ Tin Cậy Response Của Cascade

### 🟢 Dấu hiệu Response ĐÁNG TIN

#### ✅ Về kỹ thuật
- [ ] **Giải thích cơ chế** (không chỉ "làm thế này" mà giải thích "tại sao thế này hoạt động")
- [ ] **Nêu trade-offs** ("solution A nhanh hơn nhưng tốn memory hơn solution B")
- [ ] **Phân biệt use cases** (không one-size-fits-all)
- [ ] **Code có thể chạy được** (không pseudocode mơ hồ, imports đầy đủ)
- [ ] **Xử lý edge cases** (null check, error handling, boundary conditions)
- [ ] **Consistent với spec** (có thể verify trên MDN / TC39 proposals)

#### ✅ Về thái độ
- [ ] **Thừa nhận không chắc** ("Tôi không chắc 100%, bạn nên verify...")
- [ ] **Hỏi lại nếu thiếu context** (thay vì đoán mò)
- [ ] **Không over-engineer** (solution phù hợp với problem size)
- [ ] **Chỉ ra giả định** ("Tôi giả sử bạn đang dùng ESM, nếu CJS thì...")

---

### 🔴 Dấu hiệu Response KHÔNG ĐÁNG TIN

#### ❌ Red flags kỹ thuật

| Dấu hiệu | Vấn đề | Cách kiểm tra |
|-----------|--------|---------------|
| API không tồn tại | Hallucination | Check MDN/Node docs |
| Version sai (nói ES2025 có X nhưng X là ES2026) | Kiến thức lỗi thời | Check TC39 proposals |
| Bỏ qua async/await trong code async | Bug tiềm ẩn | Trace code manually |
| Không có error handling | Code không production-ready | Test với bad inputs |
| Circular dependency trong solution | Tạo bug mới | Vẽ dependency graph |
| Magic numbers không giải thích | Không hiểu code | Hỏi lại tại sao |

#### ❌ Red flags về câu trả lời

```
🚩 "Đây là cách tốt nhất" — không có context về "tốt nhất" cho ai
🚩 "Luôn luôn dùng X" — không có absolute rule trong engineering  
🚩 Code dài 200 dòng cho bug 5 dòng — over-engineering
🚩 Không mention performance implications cho code trong hot path
🚩 Copy-paste solution không giải thích tại sao nó fix bug
🚩 Confident về experimental API như thể đã stable
🚩 Không hỏi lại dù question mơ hồ — đang đoán
```

---

### 🧪 Quy Trình Verify Response Của Cascade

```
Step 1: ĐỌC HIỂU (đừng copy-paste ngay)
  └─ Bạn có hiểu TẠI SAO solution hoạt động không?
  └─ Nếu không → hỏi Cascade giải thích thêm

Step 2: CHECK API/SYNTAX
  └─ MDN Web Docs (browser APIs)
  └─ nodejs.org/api (Node APIs)  
  └─ tc39.es/proposals (ES proposals)
  └─ npmjs.com (package APIs)

Step 3: TEST LOCALLY
  └─ Chạy với exact version của bạn
  └─ Test edge cases (null, undefined, empty, large input)
  └─ Test error paths

Step 4: BENCHMARK nếu là perf solution
  └─ Dùng Benchmark.js hoặc Node --prof
  └─ Test với realistic data size

Step 5: SECOND OPINION nếu vẫn nghi ngờ
  └─ Hỏi lại Cascade theo góc độ khác
  └─ Search Stack Overflow / GitHub Issues
  └─ Hỏi senior trong team
```

---

### 📊 Bảng Đánh Giá Nhanh Response

```
Chấm điểm response (1-5 cho mỗi tiêu chí):

[ ] Giải thích rõ root cause          /5
[ ] Solution code chạy được           /5  
[ ] Có handle edge cases              /5
[ ] Nêu được limitations              /5
[ ] Consistent với documentation      /5

Total: _/25
  20-25: Tin tưởng cao, vẫn test
  15-19: Tin tưởng vừa, verify kỹ
  10-14: Nghi ngờ, research thêm
  <10:   Không tin, tìm nguồn khác
```

---

## 4. 🎯 Lỗi JS/ES2025 Cascade Làm Tốt vs Không Tốt

### 🟢 Cascade Làm TỐT

#### ✅ 1. Async/Await Patterns & Promise Chains

```javascript
// Cascade giải thích rất tốt vấn đề này:

// ❌ Sai - forEach không await
async function processItems(items) {
  items.forEach(async (item) => {  // BUG: forEach không chờ
    await saveToDb(item);
  });
}

// ✅ Đúng - for...of
async function processItems(items) {
  for (const item of items) {
    await saveToDb(item);
  }
}

// ✅ Đúng - parallel
async function processItems(items) {
  await Promise.all(items.map(item => saveToDb(item)));
}
```

**Cascade giỏi:** Giải thích tại sao forEach không work với async, phân biệt sequential vs parallel, gợi ý đúng pattern cho từng use case.

---

#### ✅ 2. Closure & Scope Issues

```javascript
// Cascade debug tốt classic closure bugs:

// ❌ Bug cổ điển
for (var i = 0; i < 5; i++) {
  setTimeout(() => console.log(i), 100); // In ra 5,5,5,5,5
}

// ✅ Fix với let
for (let i = 0; i < 5; i++) {
  setTimeout(() => console.log(i), 100); // In ra 0,1,2,3,4
}

// Cascade cũng giải thích được stale closure trong React hooks
function Counter() {
  const [count, setCount] = useState(0);
  
  useEffect(() => {
    const interval = setInterval(() => {
      // ❌ Stale closure - count luôn là 0
      setCount(count + 1);
      
      // ✅ Functional update - không depend vào closure
      setCount(prev => prev + 1);
    }, 1000);
    return () => clearInterval(interval);
  }, []); // Empty deps
}
```

---

#### ✅ 3. ESM vs CJS Syntax Errors

```javascript
// Cascade handle tốt các conflict phổ biến:

// package.json confusion
{
  "type": "module"  // Cascade giải thích impact rõ ràng
}

// Named export vs default export confusion
// moduleA.js
export const foo = 'foo';        // named
export default function bar() {} // default

// ❌ Sai cách import
import foo from './moduleA.js';         // Lấy default, không phải named foo
import { default as bar } from './moduleA.js'; // Verbose nhưng đúng

// ✅ Đúng
import bar, { foo } from './moduleA.js';
```

---

#### ✅ 4. Prototype Chain & Class Inheritance

```javascript
// Cascade debug tốt prototype issues:

class Animal {
  #name; // Private field - ES2022+, Cascade hiểu rõ
  
  constructor(name) {
    this.#name = name;
  }
  
  getName() { return this.#name; }
}

class Dog extends Animal {
  #breed;
  
  constructor(name, breed) {
    super(name); // Cascade nhắc nhở super() phải trước this
    this.#breed = breed;
  }
}

// Cascade giải thích tốt: tại sao private fields không accessible 
// từ subclass (khác protected trong Java/C#)
```

---

#### ✅ 5. Destructuring Edge Cases

```javascript
// Cascade rất tốt với destructuring bugs:

// Default values với nullish
const { a = 'default' } = { a: null };
console.log(a); // null (không phải 'default'!)
// Cascade giải thích: default chỉ apply khi undefined

// Nested destructuring với optional chaining
const { user: { profile: { avatar } = {} } = {} } = data;
// Cascade suggest pattern tốt hơn:
const avatar = data?.user?.profile?.avatar;

// Array destructuring skip
const [, second, , fourth] = [1, 2, 3, 4];
// Cascade biết và giải thích pattern này
```

---

#### ✅ 6. Error Handling Patterns

```javascript
// Cascade đề xuất tốt modern error handling:

// Pattern: Result type (không throw)
async function fetchUser(id) {
  try {
    const user = await db.find(id);
    return { ok: true, data: user };
  } catch (error) {
    return { ok: false, error: error.message };
  }
}

// ES2025: Error cause
throw new Error('Database connection failed', { 
  cause: originalError  // Cascade biết feature này
});

// AggregateError cho multiple errors
const errors = await Promise.allSettled(promises);
const failed = errors.filter(r => r.status === 'rejected');
if (failed.length) {
  throw new AggregateError(
    failed.map(f => f.reason), 
    'Multiple operations failed'
  );
}
```

---

#### ✅ 7. Memory Leak Patterns (Common Cases)

```javascript
// Cascade nhận diện tốt leak patterns phổ biến:

// ❌ Leak: Event listener không remove
class Component {
  mount() {
    document.addEventListener('scroll', this.handleScroll);
  }
  // Không có unmount/cleanup → leak!
}

// ✅ Fix với AbortController (ES2025 idiomatic)
class Component {
  #controller = new AbortController();
  
  mount() {
    document.addEventListener('scroll', this.handleScroll, {
      signal: this.#controller.signal
    });
  }
  
  unmount() {
    this.#controller.abort(); // Tự động remove tất cả listeners
  }
}
```

---

### 🔴 Cascade Làm KHÔNG TỐT (Cần Cẩn Thận)

#### ❌ 1. TC39 Proposal Status Confusion

```javascript
// ⚠️ CẢNH BÁO: Cascade hay nhầm lẫn proposal stages

// Cascade có thể nói những thứ này như đã stable khi thực ra còn là proposal:

// Decorators - Stage 3 (2024), có thể nói như stable
@observable  // Cần transpiler, chưa native
class Store {}

// Pipeline operator - Stage 2, CHƯA stable
const result = value |> double |> addOne; // Chưa dùng được native

// Pattern matching - Stage 2, CHƯA stable
match (status) {
  when 'loading': <Spinner />
  when 'error': <Error />
}

// ✅ VERIFY: Luôn check https://tc39.es/proposals/
// trước khi dùng feature Cascade đề xuất
```

> 🚨 **Luôn check stage** trên tc39.es khi Cascade đề xuất "ES2025 feature mới"

---

#### ❌ 2. Complex Race Conditions

```javascript
// Cascade hay miss subtle race conditions:

// ❌ Cascade có thể không catch được race này:
class DataManager {
  #cache = new Map();
  
  async getData(key) {
    if (this.#cache.has(key)) {
      return this.#cache.get(key);
    }
    
    // BUG: Nếu 2 calls cùng lúc miss cache,
    // sẽ fetch 2 lần và race to set cache
    const data = await fetchFromAPI(key);
    this.#cache.set(key, data);
    return data;
  }
  
  // ✅ Fix cần request deduplication mà Cascade 
  // đôi khi không suggest automatically:
  #pendingRequests = new Map();
  
  async getData(key) {
    if (this.#cache.has(key)) return this.#cache.get(key);
    
    if (!this.#pendingRequests.has(key)) {
      this.#pendingRequests.set(
        key,
        fetchFromAPI(key).finally(() => {
          this.#pendingRequests.delete(key);
        })
      );
    }
    
    const data = await this.#pendingRequests.get(key);
    this.#cache.set(key, data);
    return data;
  }
}
```

---

#### ❌ 3. Performance Optimization Accuracy

```javascript
// Cascade đôi khi đề xuất optimization sai hoặc premature:

// Cascade có thể suggest dùng Web Workers cho task
// mà thực ra quá nhỏ để xứng đáng overhead

// Hoặc suggest memoization không đúng chỗ:
// ❌ Cascade suggest memo cho component re-render ít
const HeavyComponent = React.memo(({ value }) => {
  return <div>{value}</div>; // Quá đơn giản, memo overhead > benefit
});

// Cascade cũng hay không tính đến:
// - V8 optimization deopt triggers  
// - Hidden class transitions
// - Megamorphic call sites
// → Cần benchmark thực tế, đừng tin Cascade về micro-optimization
```

---

#### ❌ 4. TypeScript + JS Interop Edge Cases

```javascript
// Cascade hay confuse TypeScript type-level với JS runtime:

// Cascade có thể suggest type assertion như là runtime fix:
const element = document.getElementById('app') as HTMLDivElement;
// ⚠️ Type assertion chỉ compile-time, runtime vẫn có thể null!

// ✅ Runtime check cần thiết:
const element = document.getElementById('app');
if (!(element instanceof HTMLDivElement)) {
  throw new Error('App element not found or wrong type');
}

// Cascade cũng hay suggest .d.ts solutions 
// khi vấn đề thực ra là runtime behavior
```

---

#### ❌ 5. Node.js-specific vs Browser APIs

```javascript
// Cascade đôi khi mix up environments:

// Suggest Buffer khi cần Uint8Array (Node vs Browser):
// ❌ Buffer chỉ Node.js
const buf = Buffer.from('hello', 'utf8');

// ✅ Universal (Cascade không always suggest này):
const encoder = new TextEncoder();
const buf = encoder.encode('hello');

// Suggest __dirname trong ESM context:
// ❌ __dirname không tồn tại trong ESM
console.log(__dirname); // ReferenceError!

// ✅ ESM equivalent (Cascade đôi khi miss)
import { fileURLToPath } from 'url';
import { dirname } from 'path';
const __dirname = dirname(fileURLToPath(import.meta.url));

// Suggest process.env khi cần Deno.env.get()
```

---

#### ❌ 6. Regex & String Manipulation Edge Cases

```javascript
// Cascade hay không handle Unicode edge cases:

// ❌ Regex không có Unicode flag
const hasEmoji = /\p{Emoji}/u.test(str); 
// Cascade suggest đúng pattern nhưng đôi khi miss flag u

// String length với surrogate pairs:
const emoji = '😀';
console.log(emoji.length); // 2! Không phải 1
// Cascade không always warn về này

// ✅ Đúng cách đếm grapheme clusters:
const segmenter = new Intl.Segmenter();
const graphemes = [...segmenter.segment(str)];
console.log(graphemes.length); // Đúng

// Regex global flag + exec() stateful gotcha:
const regex = /\d+/g;
regex.exec('abc 123'); // Match
regex.exec('abc 456'); // Cascade đôi khi không warn về lastIndex reset issue
```

---

### 📊 Bảng Tổng Kết: Cascade Confidence Level

| Loại Lỗi | Cascade Tốt? | Confidence | Cần Verify? |
|-----------|-------------|------------|-------------|
| Async/Await cơ bản | 🟢 Rất tốt | 90% | Nhẹ |
| Promise chains | 🟢 Tốt | 85% | Nhẹ |
| ESM/CJS conflicts | 🟢 Tốt | 80% | Nên verify |
| Closure & scope | 🟢 Rất tốt | 90% | Nhẹ |
| Memory leak phổ biến | 🟡 Khá | 70% | Verify |
| State management | 🟡 Khá | 75% | Verify |
| Race conditions phức tạp | 🔴 Yếu | 50% | Verify kỹ |
| TC39 proposal status | 🔴 Yếu | 50% | Luôn verify |
| Micro-optimization | 🔴 Yếu | 40% | Benchmark |
| Unicode/Intl | 🟡 Trung bình | 65% | Verify |
| Node vs Browser APIs | 🟡 Trung bình | 65% | Verify env |
| TypeScript runtime vs type | 🔴 Cẩn thận | 55% | Verify kỹ |

---

## 🎓 Nguyên Tắc Vàng Khi Dùng Cascade Debug JS

```
┌─────────────────────────────────────────────────┐
│                                                 │
│  1. 🎯 PROMPT CỤ THỂ → nhận response tốt hơn   │
│                                                 │
│  2. 📋 CHUẨN BỊ TRƯỚC → tiết kiệm thời gian    │
│                                                 │
│  3. 🧪 LUÔN TEST CODE → đừng tin blindly        │
│                                                 │
│  4. 📚 VERIFY SPEC → MDN/TC39 là nguồn thật     │
│                                                 │
│  5. 🤝 CASCADE = PAIR PROGRAMMER GIỎI,         │
│         không phải oracle không sai             │
│                                                 │
└─────────────────────────────────────────────────┘
```

---

*📅 Cập nhật cho ES2025, Node.js 22, Windsurf Cascade (2025)*  
*🔗 References: MDN Web Docs, TC39 Proposals, Node.js Docs, Windsurf Documentation*