Phần 2: Context Engineering: AGENTS.md, Cursor Rules, và Codebase RAG

Answer-first: Context Engineering chuẩn hóa ngữ cảnh cho AI thông qua AGENTS.md, llms.txt, Cursor Rules và Codebase RAG. Cung cấp đúng phạm vi ngữ cảnh theo từng Bounded Context giúp AI sinh code chuẩn xác, tuân thủ quy ước dự án và loại bỏ hoàn toàn các giả định sai lệch.

Điều kiện tiên quyết: Đã hoàn thành Phần 1: Vibe Coding Paradigm; nắm vững cấu trúc thư mục dự án, cú pháp Markdown, cấu trúc cây cú pháp trừu tượng (AST), và nguyên lý hoạt động của Context Window.

Phiên bản Tiếng Anh: 📖 Bản tiếng Anh (English Edition)

← Chương trước: Phần 1: Vibe Coding Paradigm | Mục lục Series | Chương tiếp theo: Phần 3: AI Bug Taxonomy →

1. Vấn Đề Cốt Lõi: Mô Hình AI Bắt Đầu Từ Tờ Giấy Trắng

Năm 2025, METR — tổ chức nghiên cứu uy tín về an toàn và năng lực AI — đã tiến hành một thử nghiệm ngẫu nhiên có đối chứng (RCT) trên 16 kỹ sư mã nguồn mở giàu kinh nghiệm thực hiện 246 tác vụ phần mềm thực tế. Kết quả bất ngờ: các lập trình viên sử dụng AI bị chậm hơn 19% đối với các tác vụ phức tạp trên codebase quy mô lớn.

Nguyên nhân không nằm ở năng lực suy luận của mô hình; nguyên nhân nằm ở Chất Lượng Ngữ Cảnh (Context Quality). Khi không có thông tin ngữ cảnh đầy đủ, AI hoạt động như một lập trình viên junior rất tự tin, chưa từng đọc tài liệu dự án và tự động áp dụng các mẫu mã phổ biến nhất trên mạng Internet — vốn thường xung đột trực tiếp với các quy ước nội bộ của nhóm bạn.

flowchart TD
    subgraph RawContextInflow ["Dòng Dữ Liệu Ngữ Cảnh Thô (Context Ingestion)"]
        RepoDocs["AGENTS.md & Quy Ước Bounded Context"] --> IngestPipeline["Context Ingestion Engine"]
        CursorRules[".cursor/rules/*.mdc & System Prompts"] --> IngestPipeline
        CodeAST["AST Symbol Graph & Biểu Đồ Phụ Thuộc"] --> IngestPipeline
        ActivePr["Diff Thay Đổi Pull Request & Git Logs"] --> IngestPipeline
    end

    subgraph OptimizationStage ["Tối Ưu Hóa & Lọc Nhiễu (ContextOps)"]
        IngestPipeline --> SemanticFilter["Bộ Lọc Ngữ Nghĩa & Loại Bỏ Dead Code"]
        SemanticFilter --> ChunkBudget["Phân Bổ Ngân Sách Token (Context Budgeting)"]
        ChunkBudget --> CompactView["Tập Ngữ Cảnh Tinh Gọn (Compacted Context)"]
    end

    subgraph ModelExecution ["Thực Thi & Giám Định Mã Nguồn"]
        CompactView --> ReasoningEngine["Mô Hình AI (Claude 3.7 / GPT-5 / Cursor)"]
        ReasoningEngine --> CleanCode["Mã Nguồn Tuân Thủ Kiến Trúc & Zero Hallucination"]
    end

Kỹ thuật ngữ cảnh (Context Engineering) là kỷ luật cấu trúc hóa và truyền tải tri thức của tổ chức đến các AI agent dưới một định dạng mà chúng có thể sử dụng một cách xác định (deterministic). Đây chính là “khoảnh khắc DevOps” dành cho công nghệ AI.

2. Hệ Thống Phân Cấp Ngữ Cảnh: 4 Tầng Phòng Thủ Cho Codebase

Các môi trường lập trình AI hiện đại hỗ trợ ngữ cảnh ở bốn tầng riêng biệt, từ các tệp quy tắc tĩnh cho đến các đường ống truy xuất dữ liệu động:

sequenceDiagram
    autonumber
    actor Dev as Lập Trình Viên
    participant IDE as Cursor IDE / Context Engine
    participant AST as AST Symbol Resolver
    participant RAG as Vector + Graph Codebase RAG
    participant LLM as Frontier Model

    Dev->>IDE: Gửi yêu cầu: "Hiện thực hóa DeductBalance() cho User Service"
    IDE->>IDE: Tự động nạp Tầng 1: Quy tắc AGENTS.md & .cursorrules
    IDE->>AST: Truy vấn Tầng 2: Tìm interface UserService và model User
    AST-->>IDE: Trả về chữ ký hàm (Signatures) & Kiểu dữ liệu chính xác
    IDE->>RAG: Truy vấn Tầng 3: Tìm mẫu thiết kế transaction tương tự trong repo
    RAG-->>IDE: Trích xuất đoạn mã mẫu từ internal/ledger/service.go
    IDE->>LLM: Tổng hợp ngữ cảnh tinh gọn (Prompt + Rules + Signatures + Example)
    LLM-->>Dev: Trả về mã nguồn Go 1.25+ chuẩn Clean Architecture không bị rò rỉ GORM

Tầng 1: Các Tệp Quy Tắc Thường Trực (AGENTS.md, CLAUDE.md, llms.txt)

Đây là tầng nền tảng được tự động tiêm vào mọi phiên làm việc với AI. Trong giai đoạn 2026–2027, định dạng chuẩn AGENTS.md kết hợp với llms.txt ở thư mục gốc của repository đóng vai trò như bản hiến pháp dự án. Chúng hoạt động như những mệnh lệnh thường trực của agent: các ràng buộc kiến trúc, các tiêu chuẩn hành vi, và các điều cấm rõ ràng áp dụng cho mọi việc mà agent thực hiện.

Ví dụ về một tệp AGENTS.md chuẩn mực trong một hệ thống Microservices Go:

# Quy Ước Kiến Trúc Hệ Thống (Project Architecture Standards)
Dự án được xây dựng trên nền tảng Go 1.25+ tuân thủ Clean Architecture & Domain-Driven Design (DDD).

## Ranh Giới Phân Tầng (Layer Boundaries):
1. `api/proto/`: Chứa định nghĩa protobuf và mã gRPC sinh tự động. Không được sửa tay.
2. `internal/biz/`: Chứa Use Cases và Domain Entities nghiệp vụ thuần túy.
   - NGHIÊM CẤM: Tuyệt đối không import thư viện database (gorm, sqlx) hay web framework (gin, fiber).
   - Mọi tương tác lưu trữ phải thông qua Domain Interfaces (Repositories).
3. `internal/data/`: Chứa mã hiện thực việc lưu trữ dữ liệu (PostgreSQL, Redis).
4. `internal/service/`: Lớp điều phối gRPC/HTTP adapters, gọi Use Case và chuyển đổi DTO.

## Quy Tắc An Toàn & Concurrency:
- Bắt buộc truyền `ctx context.Context` làm tham số đầu tiên cho mọi phương thức I/O.
- Tuyệt đối không dùng `panic()`, trả về `error` có bọc ngữ cảnh bằng `fmt.Errorf("%w")`.
- Tránh xa Global Variables; mọi tài nguyên phải được inject qua struct constructors.

Tính cụ thể chính là điểm mấu chốt. Một chỉ dẫn chung chung như “hãy tuân theo clean architecture” sẽ tạo ra những kết quả thiếu nhất quán. Một chỉ dẫn cụ thể như “lớp biz không bao giờ được import gorm.DB trực tiếp” sẽ tạo ra kết quả mang tính xác định (deterministic).

So Sánh Thực Tế: Ngăn Chặn Rò Rỉ Kiến Trúc (Architecture Leakage)

Hãy xem xét yêu cầu nghiệp vụ: “Lấy thông tin hồ sơ người dùng bằng email trong lớp service.”

• Khi KHÔNG có tệp quy tắc (AGENTS.md): AI sẽ chọn con đường ngắn nhất và viết câu truy vấn GORM trực tiếp bên trong service adapter, phá vỡ hoàn toàn nguyên tắc phân tầng:

  // File: internal/service/user.go
  func (s *UserService) GetProfileByEmail(ctx context.Context, req *pb.GetProfileReq) (*pb.GetProfileReply, error) {
      var user biz.User
      // VI PHẠM NGHIÊM TRỌNG: Logic database bị rò rỉ trực tiếp vào lớp service adapter
      if err := s.db.WithContext(ctx).Where("email = ?", req.Email).First(&user).Error; err != nil {
          return nil, fmt.Errorf("truy vấn người dùng thất bại: %w", err)
      }
      return &pb.GetProfileReply{Name: user.Name, Email: user.Email}, nil
  }
  

• Khi CÓ tệp quy tắc (AGENTS.md): AI bắt buộc phải tuân theo sự cô lập ranh giới, điều hướng truy cập thông qua Domain Use Case:

  // File: internal/service/user.go
  func (s *UserService) GetProfileByEmail(ctx context.Context, req *pb.GetProfileReq) (*pb.GetProfileReply, error) {
      // CHÍNH XÁC: Lớp service chỉ đóng vai trò điều phối Use Case nghiệp vụ
      user, err := s.userUseCase.FindByEmail(ctx, req.Email)
      if err != nil {
          return nil, fmt.Errorf("gọi use case tìm người dùng thất bại: %w", err)
      }
      return &pb.GetProfileReply{Name: user.Name, Email: user.Email}, nil
  }
  

Tầng 2: Quản Lý Phiên Làm Việc (Active Session Hygiene)

Ngay cả khi các tệp quy tắc đã được thiết lập, những phiên làm việc kéo dài vẫn sẽ bị suy giảm chất lượng do hiện tượng Ngữ Cảnh Mục Nát (Context Rot): khi một session tích lũy quá nhiều các nỗ lực thất bại, các thông báo lỗi biên dịch và các thảo luận kế hoạch bị hủy bỏ, tỷ lệ tín hiệu trên nhiễu (signal-to-noise ratio) trong cửa sổ ngữ cảnh sẽ sụt giảm nghiêm trọng.

flowchart LR
    subgraph SessionHygiene ["Quy Trình Quản Trị Phiên Làm Việc (Session Hygiene)"]
        SessStart["Khởi Động Session Mới (Clean Slate)"] --> TaskExec["Thực Thi Tác Vụ Đơn Lẻ (Single Task)"]
        TaskExec --> TokenCheck{"Tiêu Thụ Token > 50%?"}
        TokenCheck -- Có --> RunCompact["Thực Thi Lệnh /compact Hoặc Tóm Tắt"]
        TokenCheck -- Không --> FinishTask["Hoàn Thành Tác Vụ"]
        RunCompact --> GenHandoff["Ghi Nhận Vào HANDOFF.md"]
        GenHandoff --> CloseSess["Đóng Session Ngay Lập Tức"]
        FinishTask --> CloseSess
    end

Chiến Lược Phiên Làm Việc Mới (The Fresh Session Strategy)

Các nhóm kỹ thuật có hiệu suất cao coi các session AI như các hàm không trạng thái (stateless functions): một tác vụ riêng biệt cho mỗi session. Khi bạn hoàn thành việc sửa một lỗi, hãy đóng session đó lại. Khi bạn bắt đầu một tính năng mới, hãy mở một session mới. Quy tắc vận hành: Ranh giới tác vụ chính là ranh giới session.

Bàn Giao Có Cấu Trúc (Structured Handoffs)

Khi một nhiệm vụ kỹ thuật lớn đòi hỏi nhiều bước thực hiện, đừng để session phình to đến cạn kiệt bộ nhớ. Hãy thực hiện quy trình bàn giao ba bước:

1. Yêu cầu AI tóm tắt: “Liệt kê các quyết định kiến trúc đã thống nhất, trạng thái tệp hiện tại, và các công việc còn lại.”
2. Lưu trữ nội dung tóm tắt vào tệp .agents/HANDOFF.md trong thư mục làm việc.
3. Mở phiên làm việc mới, nạp tệp HANDOFF.md cùng tệp quy tắc AGENTS.md để tiếp tục công việc với 100% độ tập trung.

Tầng 3: Lập Chỉ Mục Kho Lưu Trữ (Repository Indexing & Selective Context)

Lập chỉ mục kho lưu trữ giải quyết bài toán: cung cấp cho AI kiến thức chính xác về những thành phần đã tồn tại trong codebase nhằm tránh Hiện Tượng Phát Minh Lại Bánh Xe (The N+1 Re-invention Problem).

Nếu không có ngữ cảnh của kho lưu trữ, các AI agent sẽ viết lại các hàm tiện ích đã có sẵn, tạo ra các bảng database mới trùng lặp, định nghĩa các kiểu lỗi (error types) xung đột với chuẩn dự án và import các package vi phạm kiến trúc.

Tuy nhiên, việc đẩy sỉ toàn bộ repository vào context (Full-Repo Dump) là một sai lầm phổ biến. Khi đưa 500 tệp mã nguồn vào context, mô hình sẽ bị phân tâm bởi các đoạn mã cũ (legacy code) hoặc tài liệu deprecated. Nguyên tắc vàng của Context Engineering là Lựa Chọn Ngữ Cảnh Có Chủ Đích (Intentional Context Selection): chỉ nạp những tệp thực sự liên quan đến ranh giới Bounded Context của tác vụ hiện tại.

Tầng 4: Codebase RAG & Lập Chỉ Mục Dựa Trên AST (AST-Aware Chunking)

Khi dự án vượt quá 50.000 dòng mã, bạn không thể chọn tệp thủ công mãi được. Các hệ thống Codebase RAG thế hệ mới áp dụng phương pháp phân tách theo AST (Abstract Syntax Tree):

• Phân tách ngữ nghĩa (Semantic Chunking): Tách mã nguồn theo đúng đơn vị logic (Function, Struct, Interface) thay vì cắt ngang theo số dòng cố định.
• Biểu đồ phụ thuộc (Dependency Graph Embeddings): Lưu trữ mối quan hệ gọi hàm (Call Graph) giữa các module vào cơ sở dữ liệu đồ thị (Graph Database), giúp AI hiểu được rằng việc sửa đổi hàm CalculateTax() sẽ ảnh hưởng trực tiếp đến module InvoiceGenerator().

4. Hiện Thực Hóa: Codebase Context Extractor Bằng Go 1.25+

Dưới đây là một công cụ phân tích tĩnh mã nguồn Go 1.25+, tự động trích xuất các chữ ký hàm và cấu trúc kiểu dữ liệu từ repository, nén thành bản tóm tắt ngữ cảnh tinh gọn (Symbol Skeleton) giúp tiết kiệm 80% ngân sách token:

package contextengine

import (
	"bytes"
	"context"
	"errors"
	"fmt"
	"go/ast"
	"go/parser"
	"go/printer"
	"go/token"
	"io/fs"
	"path/filepath"
	"strings"
	"time"
)

// SymbolSummary chứa thông tin chữ ký tóm tắt của một thành phần mã nguồn.
type SymbolSummary struct {
	Name       string   `json:"name"`
	Kind       string   `json:"kind"`
	Signature  string   `json:"signature"`
	DocComment string   `json:"doc_comment"`
	Line       int      `json:"line"`
}

// FileContextPayload đại diện cho ngữ cảnh tinh gọn của một tệp mã nguồn Go.
type FileContextPayload struct {
	RelativePath string          `json:"relative_path"`
	PackageName  string          `json:"package_name"`
	Imports      []string        `json:"imports"`
	Symbols      []SymbolSummary `json:"symbols"`
	TokenEstimate int            `json:"token_estimate"`
}

// ContextExtractor thực hiện quét và trích xuất cấu trúc ngữ cảnh từ thư mục dự án.
type ContextExtractor struct {
	fset *token.FileSet
}

// NewContextExtractor khởi tạo một bộ trích xuất ngữ cảnh mới.
func NewContextExtractor() *ContextExtractor {
	return &ContextExtractor{
		fset: token.NewFileSet(),
	}
}

// ExtractFileSymbols phân tích một tệp Go đơn lẻ và sinh ra cấu trúc ngữ cảnh rút gọn.
func (ce *ContextExtractor) ExtractFileSymbols(ctx context.Context, relPath string, content string) (*FileContextPayload, error) {
	select {
	case <-ctx.Done():
		return nil, ctx.Err()
	default:
	}

	node, err := parser.ParseFile(ce.fset, relPath, content, parser.ParseComments)
	if err != nil {
		return nil, fmt.Errorf("không thể phân tích cú pháp tệp %s: %w", relPath, err)
	}

	payload := &FileContextPayload{
		RelativePath: relPath,
		PackageName:  node.Name.Name,
		Imports:      make([]string, 0),
		Symbols:      make([]SymbolSummary, 0),
	}

	for _, imp := range node.Imports {
		if imp.Path != nil {
			payload.Imports = append(payload.Imports, imp.Path.Value)
		}
	}

	for _, decl := range node.Decls {
		switch d := decl.(type) {
		case *ast.FuncDecl:
			var sigBuf bytes.Buffer
			// Sao chép hàm nhưng xóa bỏ phần thân (Body) để tiết kiệm token
			cleanFunc := &ast.FuncDecl{
				Doc:  d.Doc,
				Recv: d.Recv,
				Name: d.Name,
				Type: d.Type,
				Body: nil,
			}
			if err := printer.Fprint(&sigBuf, ce.fset, cleanFunc); err == nil {
				pos := ce.fset.Position(d.Pos())
				doc := ""
				if d.Doc != nil {
					doc = strings.TrimSpace(d.Doc.Text())
				}
				payload.Symbols = append(payload.Symbols, SymbolSummary{
					Name:       d.Name.Name,
					Kind:       "FUNCTION",
					Signature:  sigBuf.String(),
					DocComment: doc,
					Line:       pos.Line,
				})
			}
		case *ast.GenDecl:
			if d.Tok == token.TYPE {
				for _, spec := range d.Specs {
					if ts, ok := spec.(*ast.TypeSpec); ok {
						var typeBuf bytes.Buffer
						if err := printer.Fprint(&typeBuf, ce.fset, ts); err == nil {
							pos := ce.fset.Position(ts.Pos())
							payload.Symbols = append(payload.Symbols, SymbolSummary{
								Name:       ts.Name.Name,
								Kind:       "TYPE_SPEC",
								Signature:  typeBuf.String(),
								DocComment: strings.TrimSpace(d.Doc.Text()),
								Line:       pos.Line,
							})
						}
					}
				}
			}
		}
	}

	// Ước tính token thô sơ: ~4 ký tự cho mỗi token
	totalChars := len(payload.PackageName)
	for _, imp := range payload.Imports {
		totalChars += len(imp)
	}
	for _, sym := range payload.Symbols {
		totalChars += len(sym.Signature) + len(sym.DocComment)
	}
	payload.TokenEstimate = totalChars / 4

	return payload, nil
}

// BuildRepoSkeleton quét toàn bộ cây thư mục và xây dựng khung ngữ cảnh cho AI.
func BuildRepoSkeleton(ctx context.Context, rootDir string, fileSystem fs.FS) ([]FileContextPayload, error) {
	extractor := NewContextExtractor()
	var results []FileContextPayload

	err := fs.WalkDir(fileSystem, ".", func(path string, d fs.DirEntry, walkErr error) error {
		if walkErr != nil {
			return walkErr
		}
		if d.IsDir() {
			name := d.Name()
			if name == "vendor" || name == ".git" || name == "node_modules" {
				return fs.SkipDir
			}
			return nil
		}

		if filepath.Ext(path) == ".go" && !strings.HasSuffix(path, "_test.go") {
			data, err := fs.ReadFile(fileSystem, path)
			if err != nil {
				return fmt.Errorf("đọc tệp %s thất bại: %w", path, err)
			}
			payload, err := extractor.ExtractFileSymbols(ctx, path, string(data))
			if err != nil {
				// Bỏ qua các tệp hỏng cú pháp nhưng tiếp tục quét các tệp khác
				return nil
			}
			results = append(results, *payload)
		}
		return nil
	})

	if err != nil {
		return nil, errors.New("quá trình duyệt thư mục thất bại: " + err.Error())
	}
	return results, nil
}

Nhờ công cụ trích xuất này, bạn có thể truyền toàn bộ “bộ khung xương” (skeleton) của một dự án 100.000 dòng code vào cửa sổ ngữ cảnh của Claude hoặc GPT-5 với dung lượng chỉ vỏn vẹn 8.000 token, giúp AI nắm bắt toàn bộ kiểu dữ liệu và chữ ký phương thức mà không bị bão hòa bộ nhớ.

5. Chiến Lược Giữ Sạch Ngữ Cảnh: Tránh Hiện Tượng “Ngữ Cảnh Mục Nát” (Context Rot)

Khi một phiên làm việc với AI kéo dài qua nhiều giờ, cửa sổ ngữ cảnh sẽ tích lũy một lượng lớn các thử nghiệm thất bại, các đoạn log lỗi và các giả định sai lầm. Hiện tượng này được gọi là Ngữ Cảnh Mục Nát (Context Rot).

Các nguyên tắc vận hành thực chiến của các đội ngũ kỹ thuật hàng đầu:

1. Một Nhiệm Vụ - Một Phiên Làm Việc (Task Boundary = Session Boundary): Hãy đóng ngay session khi hoàn thành một pull request hoặc một bài sửa lỗi. Bắt đầu tính năng mới bằng một phiên làm việc hoàn toàn sạch sẽ.
2. Quy Trình Bàn Giao Có Cấu Trúc (Structured Session Handover): Nếu một nhiệm vụ quá lớn không thể giải quyết trong một phiên, hãy yêu cầu AI tóm tắt trạng thái hiện tại thành một tệp HANDOFF.md, sau đó khởi động session mới với tệp tóm tắt này.
3. Chủ Động Nén Ngữ Cảnh (Proactive Compaction): Tận dụng các lệnh /compact trong Cursor hoặc Claude Code khi số lượng token tiêu thụ vượt quá 50% giới hạn cửa sổ ngữ cảnh để giữ cho tỷ lệ tín hiệu trên nhiễu luôn ở mức tối ưu.

6. Giao Thức Model Context Protocol (MCP): Chuẩn Hóa Cung Cấp Ngữ Cảnh Động

Vào năm 2026, Model Context Protocol (MCP) do Anthropic khởi xướng đã trở thành tiêu chuẩn công nghiệp mở (Open Standard) để kết nối các trợ lý lập trình AI với các nguồn dữ liệu và công cụ cục bộ thông qua giao thức JSON-RPC 2.0.

Thay vì phải copy-paste schema cơ sở dữ liệu hay tài liệu API vào khung chat một cách thủ công, MCP server cho phép AI agent tự động truy vấn thông tin trực tiếp từ môi trường phát triển:

• Truy vấn cấu trúc Schema thời gian thực: AI agent gửi yêu cầu qua MCP đến máy chủ cơ sở dữ liệu cục bộ để lấy định nghĩa bảng mới nhất cùng các ràng buộc khóa ngoại (Foreign Keys).
• Thực thi phân tích cú pháp AST cục bộ: AI agent có thể gọi trực tiếp các công cụ phân tích tĩnh của dự án để kiểm tra xem đoạn mã dự kiến sinh ra có vi phạm linter hay không trước khi hiển thị kết quả cho người dùng.
• Truy cập tài liệu nội bộ đã được lập chỉ mục: MCP server đóng vai trò cầu nối an toàn, chỉ cấp quyền đọc có kiểm soát vào các kho tài liệu kỹ thuật của doanh nghiệp mà không làm lộ thông tin mật ra bên ngoài.

flowchart TD
    subgraph MCPEcosystem ["Hệ Sinh Thái Giao Thức Model Context Protocol (MCP)"]
        AIAssistant["Cursor / Claude Code Agent"] -->|JSON-RPC 2.0 via Stdio/SSE| MCPHost["MCP Client Router"]
        MCPHost --> DBMCP["PostgreSQL MCP Server (Schema & Constraints)"]
        MCPHost --> ASTMCP["Go AST Tool Server (Symbol Table & Call Graph)"]
        MCPHost --> GitMCP["Git Context Server (Recent Diffs & Blame Logs)"]
    end
    DBMCP -.->|Truy xuất an toàn| LocalPostgres[("Cơ Sở Dữ Liệu Dev")]
    ASTMCP -.->|Phân tích cú pháp| LocalRepo["Mã Nguồn Cục Bộ"]

7. ContextOps: Quy Trình CI/CD Tự Động Kiểm Duyệt Tệp Ngữ Cảnh

Một vấn đề phổ biến trong các dự án quy mô lớn là Sự Trôi Dạt Của Tệp Ngữ Cảnh (Context Drift): khi lập trình viên cập nhật mã nguồn (ví dụ: đổi tên hàm hoặc thay đổi kiến trúc thư mục) nhưng lại quên cập nhật tệp AGENTS.md hoặc .cursorrules. Hậu quả là AI tiếp tục dựa vào những chỉ dẫn lỗi thời để sinh ra mã nguồn sai lệch.

Để giải quyết triệt để vấn đề này, các nhóm kỹ thuật tiên tiến triển khai quy trình ContextOps trong hệ thống GitHub Actions CI/CD:

1. Kiểm Tra Tính Hợp Lệ Của Đường Dẫn (Path Validation): Tự động quét toàn bộ các đường dẫn tệp và thư mục được đề cập trong AGENTS.md. Nếu một tệp đã bị xóa hoặc đổi tên trong Git mà vẫn còn xuất hiện trong tài liệu chỉ dẫn, CI sẽ đánh trượt PR ngay lập tức.
2. Kiểm Tra Trôi Dạt Biểu Tượng (Symbol Drift Check): Đối chiếu các chữ ký hàm và interface mẫu trong AGENTS.md với mã nguồn thực tế của dự án. Nếu interface nghiệp vụ đã thêm tham số mới mà tài liệu chỉ dẫn của AI vẫn dùng chữ ký cũ, hệ thống sẽ cảnh báo lập trình viên cập nhật ngữ cảnh.
3. Đo Lường Hiệu Quả Token (Token Efficiency Telemetry): Theo dõi số lượng token tiêu tốn cho mỗi tương tác AI và tỷ lệ mã được chấp nhận (Acceptance Rate). Nếu một quy tắc trong .cursorrules chiếm quá nhiều token nhưng không mang lại sự cải thiện về chất lượng mã, quy tắc đó sẽ được gắn cờ để tái cấu trúc hoặc loại bỏ.

Nhờ có ContextOps, tệp chỉ dẫn ngữ cảnh không còn là một tài liệu tĩnh bị lãng quên theo thời gian, mà trở thành một thành phần sống động, luôn đồng bộ 100% với trạng thái vận hành của codebase.

8. Nghiên Cứu Tình Huống Trước & Sau: Xây Dựng Export Service

Để thấy rõ sức mạnh của Context Engineering, hãy so sánh kết quả khi yêu cầu AI xây dựng một dịch vụ xuất báo cáo người dùng (User Export Service) có chứa 100.000 bản ghi:

• Khi KHÔNG có Context Engineering:

  • AI tải toàn bộ 100.000 bản ghi vào một mảng trong bộ nhớ RAM, gây sập server vì lỗi Out-Of-Memory (OOM).
  • Tự động cài đặt thêm một thư viện export CSV lạ từ bên ngoài thay vì sử dụng utility pkg/csvwriter đã có sẵn trong dự án.
  • Bỏ quên việc kiểm tra quyền truy cập của người dùng đối với dữ liệu nhạy cảm.

• Khi CÓ Context Engineering (với AGENTS.md chuẩn mực):

  • AI tự động nhận biết quy ước streaming và sử dụng io.Pipe() kết hợp với cơ chế phân trang con trỏ (Cursor-based Pagination) để truyền tải dữ liệu từng đợt, giữ mức tiêu thụ RAM ổn định dưới 20MB.
  • Tái sử dụng chính xác thư viện nội bộ pkg/csvwriter và áp dụng đúng middleware kiểm tra quyền hạn RequirePermission(PermExportUserData).
  • Tự động bổ sung thông tin đo kiểm phân tán (OpenTelemetry Spans) theo đúng tiêu chuẩn đã được định nghĩa trong tệp quy tắc.

Sự khác biệt không nằm ở năng lực của mô hình AI; sự khác biệt nằm ở chất lượng của chiếc neo ngữ cảnh mà bạn đã trao cho nó.

← Chương trước: Phần 1: Vibe Coding Paradigm | Mục lục Series | Chương tiếp theo: Phần 3: AI Bug Taxonomy →