Nobody Uses the Old Model. Yet It Can't Be Turned Off
The article argues that the real problem with retiring old AI models is not the shutdown itself, but an architecture in which the model is called directly and an organization that does not know who depends on it — the "undeclared consumers" described by Sculley et al. (NIPS 2015). The author walks through tools for discovering dependencies (telemetry and distributed tracing before the scream test), model states in registries (MLflow aliases, Vertex AI), deprecation timelines at OpenAI, Azure, Amazon and Anthropic, and architectural prevention: an anti-corruption layer, an AI gateway, versioned prompts, two vector indexes, and blue/green with champion/challenger. It closes with a governance layer — a service catalog (Backstage), model cards, and consumer-driven contracts.
Certified Lie: When Corporate AI Answers from an Incomplete Horizon
The article describes an overlooked risk of enterprise AI assistants built over internal documents: not data leakage (oversharing) but undersharing — the assistant answers from an incomplete horizon and backs the answer with a truthful citation, producing a "certified lie": a factually wrong answer with impeccable sources. The author argues that the center of gravity of enterprise RAG failure lies not in the model but in authorization, and proposes three artifacts that must be finished before licenses are purchased: a content contract with four visibility modes, silence rules with calibrated abstention and disclosure of the horizon, and written commitments to employees. The text grounds its argument in work on Permission-Aware RAG (IEEE Access 2025), Microsoft documentation, the German BAG decision 1 ABR 20/21, Art. 26(7) of Regulation (EU) 2024/1689, and § 316 of the Czech Labour Code, and notes the parallel with cover stories in multilevel-secure databases.
Quantize, don't truncate: a float32 embedding is mostly empty space
The article argues that for embedding storage it pays to reduce numeric precision (quantization to int8, int4, or a single bit via RaBitQ/BBQ with oversampling and reranking), not the number of dimensions — a float32 vector carries barely two significant digits, and the rest of the mantissa dissolves into noise under cosine similarity. High dimensionality helps quantization; below ~384 dimensions binary quantization breaks down. Matryoshka Representation Learning, according to the author, solves a different problem — runtime dimension flexibility, not index compression; at the same compression ratio, quantization beats it even on Matryoshka-trained models (the CoRECT comparison).
Who Reviews the Code After the AI — and Why a Weaker Model Won't Do
Article draws on peer-reviewed studies and preprints to show that language models systematically overlook errors in their own output (64.5% of cases, per one paper) and cannot reliably self-correct without external feedback. What matters, therefore, is not the size of the reviewing model but its independence from the code's author. It also examines the strongest counterargument — verification asymmetry, which holds mainly for tasks with objective ground truth — and maps the interests of the players involved, from academia to code-review tool vendors. Practical takeaway: stop asking which model to deploy and start asking how many independent layers (deterministic tools, a different strong model, a human) to put between generated code and production — and measure error-catch rates on your own codebase.
AI Speeds Up Development. Without Tests It Speeds Up Chaos Too
The article warns that while AI makes code changes dramatically cheaper and faster, without a solid net of automated checks it multiplies bugs, technical debt, and system incoherence just as fast. The author rejects test coverage as proof of quality and, instead of the testing pyramid, proposes an interconnected web of verification — from unit and mutation tests through service contracts to validation of configuration, deployment, and production metrics. Key thesis: AI can strengthen testing as a tool, but must not be the final gatekeeper — deterministic mechanisms should decide whether a change passes, and tests must be treated as living infrastructure with clear ownership.
AI writes the code, the tests, and the checks on them. The chain can't see its own blind spot
The article describes a methodology of AI-assisted development in which the machine writes the contract, the implementation, the tests, and the checks on them, while the human is left only with intent and a single final review. The main risk is that when one model passes through all the layers, its single blind spot propagates through the entire chain — something the system cannot check on its own. The author therefore calls for enforced independence — mutation-tested and property-based tests, model diversity, and human review at the level of intent — drawing on Brooks, design by contract, data from SWE-bench, and Article 14 of the EU AI Act.
When Code Outpaces Understanding
The essay argues that generative AI decouples code from the program's "theory" in the developer's head (Naur's Programming as Theory Building): the model produces a correct-looking artifact faster than a person can build up an understanding of it. The author grounds the hypothesis in a triangulation of data — declining refactoring (GitClear), a slowdown despite the opposite feeling (METR), impaired learning (Anthropic), security vulnerabilities (Veracode), and declining delivery stability (Faros, DORA) — and fairly acknowledges the counterarguments, as well as the fact that this is directional rather than peer-reviewed data.
Tool calling in open-source models: who can do it and who just pretends
The article compares the tool-calling capabilities of open-source language models – that is, an LLM's ability to call external APIs and tools via structured requests. In production deployment, Llama 3.3 70B comes out on top with a zero parsing error rate, while Gemma is unsuitable for tool calling and Llama 4's reputation is tarnished by a benchmark scandal. The article explains the principles of tool calling, parallel calls, the formats (OpenAI JSON, Hermes XML, Pythonic) and the MCP standard, and evaluates the models based on the BFCL benchmark.