const user = new User();
user.
//    ^ IDE parses User class → offers .id, .email, .save()

# TabNine circa 2020 — knows that catch blocks often contain:
try:
    result = fetch_user(user_id)
except Exception as e:
    # → suggests: logger.error(e) / raise / return None
    # Based on: "what do most codebases do here?"
    # NOT based on: "what does THIS codebase do here?"

[CONTEXT ASSEMBLED FOR: "write a sendWelcomeEmail function"]

1. Current file (full):          api/users.ts
2. Recently visited:             services/email.ts, db/models/user.ts
3. Imported by current file:     utils/auth.ts, config/constants.ts
4. Type definitions:             types/User.d.ts, types/Email.d.ts
5. Related tests:                __tests__/users.spec.ts
6. Config:                       tsconfig.json, package.json
7. RAG-retrieved chunks:         [see next section]

// Source code chunk:
function validateEmail(email: string): boolean {
  return /^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(email);
}

// After embedding model processes it:
→ [0.23, -0.87, 0.44, 0.91, -0.12, 0.67, ...]
//  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
//  768 numbers encoding "email validation logic"

// Another chunk, completely different file:
it('should reject emails without @ symbol', () => {
  expect(validateEmail('notanemail')).toBe(false);
});

→ [0.21, -0.83, 0.48, 0.88, -0.09, 0.71, ...]
//  Similar vector = semantically related

Your query: "write a function that sends a welcome email to new users"

→ Query vector: [0.19, -0.79, 0.51, 0.85, -0.14, 0.63, ...]

Vector DB finds nearest neighbours:
  ✓ validateEmail()         — distance: 0.12  (email logic)
  ✓ UserProfile interface   — distance: 0.18  (user data shape)  
  ✓ emailService.sendGrid() — distance: 0.21  (email sending)
  ✓ NEW_USER_TEMPLATE const — distance: 0.24  (email templates)
  ✓ user.spec.ts fixture    — distance: 0.31  (test patterns)

Bi-encoder retrieval (fast, less accurate):
  → Scores chunks independently against query vector

Cross-encoder reranking (slow, highly accurate):
  → Reads query + chunk together
  → Models their actual interaction
  → Re-ranks the candidate set

Final top-10 chunks injected into context window ✓

// You type this (incomplete, invalid syntax):
function processOrder(order: Order) {
  const items = order.li
  //                   ^ cursor here, code is broken

// Tree-sitter still produces:
FunctionDeclaration
  name: "processOrder"
  parameters:
    Parameter { name: "order", type: "Order" }
  body:
    VariableDeclaration
      name: "items"
      initializer: MemberExpression (incomplete)
        object: Identifier "order"
        property: Identifier "li" [ERROR]

const userId = 'admin';           // scope: module

function getUser(userId: string) { // scope: function (shadows outer)
  return db.find(userId);          // which userId? Tree-sitter knows.
}

Nodes:  functions, classes, types, constants, interfaces
Edges:  calls, imports, implements, uses, tests

Example subgraph:
  checkout()
    ├─ calls → validateCart()
    │            ├─ calls → getInventory()
    │            └─ uses  → CartItem (type)
    ├─ calls → processPayment()
    │            └─ calls → stripe.charge()
    ├─ uses  → Order (type)
    │            └─ uses  → LineItem (type)
    └─ tested by → checkout.spec.ts
                     ├─ uses fixture → mockCart
                     └─ uses fixture → mockPayment

// You're about to change:
interface User {
  id: number;
  email: string;
  // adding:
  accountId: string;  // ← new field
}

// Semantic graph instantly knows:
// → 23 files reference this interface
// → 4 will have type errors (missing accountId)
// → 2 tests use User fixtures that need updating
// → 1 DB migration needs to add the column
// → GraphQL schema needs a new field

// Ask: "how does Promise.allSettled differ from Promise.all?"
// Model answers from parametric knowledge — reliable, no retrieval needed

Promise.all([p1, p2, p3])
// → Rejects immediately if ANY promise rejects
// → Returns values array only on full success

Promise.allSettled([p1, p2, p3])
// → Waits for ALL promises to finish
// → Returns [{status, value/reason}, ...] always

// Ask: "write a new admin route using our middleware pattern"
// Model reads YOUR code to understand YOUR conventions:

// Retrieved chunk from api/users.ts:
router.get('/users', authenticate, authorize('admin'), async (req, res) => {
  const users = await UserService.getAll();
  res.json({ data: users, meta: buildMeta(req) });
});

// Retrieved chunk from api/orders.ts:
router.get('/orders', authenticate, authorize('admin'), async (req, res) => {
  const orders = await OrderService.getAll(req.query);
  res.json({ data: orders, meta: buildMeta(req) });
});

// Now generates for your new route — matching YOUR patterns:
router.get('/products', authenticate, authorize('admin'), async (req, res) => {
  const products = await ProductService.getAll(req.query);
  res.json({ data: products, meta: buildMeta(req) });
});
// ✓ Same middleware order
// ✓ Same response shape
// ✓ Same meta helper
// ✓ Same query-forwarding pattern

Task: "Add input validation to the POST /orders endpoint"

Loop iteration 1:
  AI reads:  api/orders.ts, types/Order.ts, existing validators
  AI writes: validation middleware using zod schema
  AI runs:   npm test -- orders
  AI reads:  "FAIL: missing validation for lineItems array"

Loop iteration 2:
  AI reads:  types/LineItem.ts (retrieved by semantic search)
  AI writes: adds lineItems schema to zod validator
  AI runs:   npm test -- orders
  AI reads:  "FAIL: test expects 422 status, got 400"

Loop iteration 3:
  AI reads:  api/users.ts (how validation errors are returned elsewhere)
  AI writes: changes error status to match project convention (422)
  AI runs:   npm test -- orders
  AI reads:  "PASS: 8 tests passed"
  AI done ✓

Cause: RAG didn't retrieve the right chunks.
Fix:   @mention the file explicitly in your prompt.
       "In the style of @api/users.ts, write a..."

Cause: Background indexing lagged after a large refactor.
Fix:   Trigger a manual reindex. Start a fresh chat session.

// AI generates (using parametric knowledge of Mongoose v5):
User.findOne({ email }).exec().then(...)

// Your project uses Mongoose v8 (async/await preferred):
await User.findOne({ email })  // ← no .exec() needed

Cause: Parametric knowledge doesn't match your installed version.
Fix:   Include your package.json or the actual function signature
       in your prompt context.

Cause: Window is full. Old context gets dropped.
Fix:   Start a new conversation for each new task.
       Don't rely on the AI retaining earlier context indefinitely.

Your query
    ↓
RAG pipeline        — finds relevant code across your entire repo
    ↓
Tree-sitter         — provides precise structural grounding
    ↓
Semantic graph      — maps relationships between symbols
    ↓
Long context window — holds enough to reason coherently
    ↓
Language model      — combines parametric + retrieved knowledge
    ↓
Agentic loop        — iterates until tests pass
    ↓
Your editor