Standard Library Preference

Standard Library & Native Primitive Protocol (Zero-Wheel Reinvention)

Overview

When solving common programming requirements (e.g., deep cloning an object, memoizing a function, generating a UUID, or grouping records by category), naive AI agents often write 25 to 50 lines of custom procedural helper code or prompt the user to install heavy third-party libraries (npm install lodash, npm install uuid).

Reinventing built-in primitives:

1. Wastes Output Tokens: Generating 40 lines of boilerplate caching or cloning logic burns 350+ tokens.
2. Introduces Edge-Case Bugs: Custom clone/memoization implementations frequently fail on circular references, symbol keys, and prototype chains.
3. Bloats package.json: Adds dependency supply-chain risks and maintenance overhead.

The Standard Library Preference Protocol mandates using modern built-in native language primitives and standard libraries, achieving maximum runtime performance in 1 to 2 lines of code.

Custom Boilerplate Helper vs. Built-in Native Primitive

┌─────────────────────────────────────────────────────────────┐
│                 Code Density & Safety Impact                │
│                                                             │
│  Custom Helper Wheel Reinvention (25 Lines / 185 Tokens):   │
│  function deepCloneObject(obj) {                            │
│    if (obj === null || typeof obj !== 'object') return obj; │
│    const copy = Array.isArray(obj) ? [] : {};               │
│    for (let key in obj) {                                   │
│      if (obj.hasOwnProperty(key)) {                         │
│        copy[key] = deepCloneObject(obj[key]);               │
│      }                                                      │
│    }                                                        │
│    return copy;                                             │
│  }                                                          │
│  ↳ 185 tokens billed, fails on Date, Map, Set, and Blobs!   │
│                                                             │
│  Native Standard Primitive (1 Line / 6 Tokens - 96.7% Cut!):│
│  const cloned = structuredClone(sourceObject);              │
│  ↳ 6 clean tokens, 100% engine-native C++ performance       │
└─────────────────────────────────────────────────────────────┘

The Modern Standard Library Arsenal

1. JavaScript & TypeScript Modern Built-ins

Replace heavy npm libraries with native runtime APIs (Node 18+, Modern Browsers):

2. Python Standard Library Power Tools

# 1. High-Performance Memoization / LRU Cache
from functools import lru_cache
@lru_cache(maxsize=128)
def expensive_compute(query: str) -> dict: ...

# 2. Grouping / Frequency Counting
from collections import Counter, defaultdict
freq_map = Counter(tokens)
grouped = defaultdict(list)

# 3. Cryptographically Secure Tokens
import secrets
token = secrets.token_urlsafe(32)

# 4. Combinatorics & Iteration
import itertools
pairs = list(itertools.combinations(items, 2))

3. Go Modern Standard Library

import (
    "slices" // Go 1.21+
    "maps"
)

// Sorting, searching, cloning in 1 line
slices.Sort(userList)
clonedMap := maps.Clone(originalMap)

Benchmark Comparison

Evaluation across 30 standard algorithmic and data utility tasks:

Agent Operational Directive

MANDATORY: Agents must default to native standard library primitives (structuredClone, crypto.randomUUID, Python functools, collections). Never write custom algorithmic helpers or install third-party packages for tasks supported natively by the language runtime.