标签：#ai

On June 9, Anthropic shipped Claude Fable 5 — the most capable coding model the industry had ever seen. Three days later, the U.S. government ordered it offline for every user on Earth . No warning. No transition period. One directive, and the frontier vanished overnight. 📖 Read the full version with charts and embedded sources on ComputeLeap → The same week, Z.ai (Zhipu AI) released GLM-5.2 — a 744-billion-parameter coding model with a one-million-token context window, MIT-licensed open weights arriving within days. The timing was not lost on the developer community. ℹ️ The message landed clearly on Hacker News: as user Reubend put it, they're "grateful to Chinese labs for being open with their work" — especially after "the Fable 5 fiasco." Open weights aren't just a cost play anymore. They're insurance. This guide walks you through actually running GLM-5.2 on your own hardware — the VRAM you need, the quantization that fits, and the exact commands for llama.cpp, Ollama, and LM Studio. No API keys. No cloud dependency. No one can pull the plug. What GLM-5.2 Actually Is GLM-5.2 is the third major iteration in Z.ai's GLM-5 line, purpose-built for agentic coding and long-horizon software engineering . Here is what you are working with: Spec Value Architecture Mixture-of-Experts (MoE) Total Parameters 744 billion Active Parameters ~40 billion per token Context Window 1,000,000 tokens Max Output 131,072 tokens Training Data 28.5 trillion tokens License MIT (open weights) Thinking Modes High and Max The MoE architecture is the key to local viability. Only ~40 billion parameters fire per token — the rest sit idle. That is what makes aggressive quantization work: you are compressing 744B weights, but inference only touches a fraction of them at any given time. GLM-5.2 supports two thinking-effort presets: High and Max. Z.ai recommends Max as the default for coding work — it produces longer reasoning chains before generating output. The model launched on June 13 on Z.ai's C

We open sourced Centaur last month—a Slack agent we built for our own investing and engineering work. Over the past few months it's grown to 100-150 daily power users across a few organizations, handling both judgment-heavy tasks like investment research and raw horsepower work like searching massive codebases. The interesting part isn't just our internal use. We've been running a small Slack Connect with external orgs using it, and the feedback has been consistent: most SaaS tools don't cut it because companies need too much customization and their critical integrations aren't supported out of the box. Our roadmap is getting clearer as we tackle the tricky parts of multi-org collaboration. We're working on scoping Slackbot access by channel, which would finally let different organizations' agents coexist safely in the same space—almost like an Enterprise Matrixbook. But the real challenge isn't the vision, it's execution. Keeping costs low while staying self-hostable for smaller teams has forced us to rethink everything. The hard problems only become obvious once you're deep in the implementation. That said, I do think Slack has won in one sense: it's the best place for a coworker agent to emerge, rather than a standalone application. Curious whether others are seeing this pattern too.

Hermes-Crew Hybrid: A Hybrid Architecture for Secure Multi-Agent AI Workflows I built a hybrid system that combines a central orchestrator (Hermes) with temporary CrewAI micro-crews, protected by 3 layers of security. Here's what it does and why it matters. The Problem Multi-agent AI systems are powerful but dangerous. When you chain multiple agents together, a single compromised agent can poison the entire workflow. Existing solutions are either too heavy (enterprise PKI infrastructure) or too light (basic regex filters). The Solution: 3-Layer Security Layer 1 — Pre-execution (MCP Tool Auditor): Before any agent can register a tool, it's audited for malicious instructions. Layer 2 — Runtime (Agent Fixer Stage): Every output from every agent passes through a 3-stage pipeline (normalization → pattern matching → embeddings) in under 1ms. Layer 3 — Pre-commit (Code Safety Hook): Before any git commit lands, the diff is analyzed by CrewAI + Ollama local. Malicious code gets rejected automatically. Architecture Hermes (Director) │ ├── MCP Tool Auditor → verifies tools before registration │ ├── Execution: venv (fast) / Docker (isolated) / auto (smart) │ ├── Agent 1: Researcher │ ├── Agent 2: Analyst │ └── Agent 3: Writer │ ├── Security Gateway (Agent Fixer Stage) → filters output (<1ms) │ └── Consolidator → parses output + generates Obsidian notes What Makes It Different 1. Portable by design. Zero hardcoded paths. Every user configures their own .env . 2. Multi-model via LiteLLM. Works with Ollama local, OpenAI, Anthropic, Gemini, Groq, OpenRouter — any provider. 3. Local-first. Everything runs on the user's machine. No cloud dependencies required. 4. Obsidian integration. Every analysis generates a structured note with YAML frontmatter. Code Safety Hook in Action When you run git commit with malicious code: ❌ [ COMMIT RECHAZADO] Code Safety detected risks: → CrewAI detected vulnerabilities: VERDICT: FAIL → Agent Fixer Stage detected anomalies: High threat score: 1.05 Fo

Mine got flagged twice in one day. Both essays generated more engagement than anything else I've...

Most of the code in Quorum was written by directing Claude Code, an AI coding agent. That is not the interesting claim, and on its own it is not even a good one. An agent left to run unsupervised produces fast, plausible, locally-correct code that drifts into an incoherent system. The interesting part is the discipline that turned agent speed into a coherent, correct, multi-region database application. That discipline was an append-only architecture decision log. The failure mode of agent-built software An agent has no memory across sessions. It will happily contradict a decision it "made" yesterday, re-open a question that was settled last week, or quietly drift from the design because the local change in front of it looks fine. Each individual output is reasonable. The aggregate, without governance, is a system where the data model fights the access layer and the third change undoes the first. This is the part people underestimate when they talk about AI coding velocity. Speed without a source of truth does not get you to a good system faster. It gets you to entropy faster. A fast writer with no memory and no sense of consequence is a liability at scale unless something outside the agent supplies the continuity. The decision log Quorum carries a file of numbered architecture decisions, DEC-001 onward, now past two dozen. Each entry has the same shape: the context that forced the decision, the decision itself, references to the prior decisions it refines or interacts with, and a status. Three rules make it work: Append-only. Entries are never edited. A later decision can supersede an earlier one, but it does so as a new numbered entry that references the old one. The history of why the system is shaped the way it is stays intact and readable, including the choices that were later reversed and why. Committed separately from code. The decision and the code that implements it are different commits. The log reads as a clean narrative of intent, independent of the diffs

We've all been there: staring at a clunky, 10-year-old hospital web portal, clicking through endless nested menus just to book a simple check-up or download a PDF lab result. It's tedious, error-prone, and frankly, a waste of human potential. But what if you could just tell an AI, "Book me a dermatologist for next Tuesday and save my blood test results to my health folder," and it just... did it? In this tutorial, we are diving deep into the world of autonomous agents , GPT-4o , and LLM-driven web navigation . By leveraging the revolutionary Browser-use library and Playwright , we’ll build a vision-capable agent that can navigate complex UIs, handle logins, and automate the most frustrating parts of healthcare administration. 🚀 Why Traditional Scraping Fails (and Why Agents Win) Traditional automation tools like Selenium or Puppeteer rely on brittle DOM selectors ( #button-id-342 ). When a hospital updates its website, your script breaks. Using Browser-use with GPT-4o changes the game. Instead of looking for code, the agent sees the page like a human, understanding that a magnifying glass icon means "Search" regardless of the underlying HTML. The Architecture 🏗️ The system logic involves a feedback loop where the LLM perceives the browser state (screenshot + DOM tree), decides on an action, and executes it via Playwright. graph TD A[User Goal: Book Appointment/Download Report] --> B[LangChain Agent / Browser-use] B --> C{Decision Engine: GPT-4o} C --> D[Action: Click/Type/Scroll] D --> E[Playwright Browser Instance] E --> F[Hospital Portal UI] F --> G[Visual & HTML Feedback] G --> C F --> H[Download Lab Report PDF] H --> I[Structured Storage / RAG Pipeline] I --> J[Task Completed ✅] Prerequisites 🛠️ Before we start, ensure you have the following in your tech stack: Python 3.10+ Playwright (The backbone of browser control) Browser-use (The bridge between LLMs and browsers) OpenAI API Key (We'll use GPT-4o for its superior vision capabilities) pip install browser-use

The laptop was never the interesting part of coding agents. It was just the first convenient runtime. Your laptop has the repository, the shell, the secrets, the package cache, the local database, the half-working dev server, and whatever credentials you forgot were still loaded in the background. So the early version of agentic coding naturally ran there. It was close to the work. It had all the messy context. It was also a very strange place to run something that might edit code for an hour while calling tools, installing dependencies, and touching private systems. AWS published a Bedrock AgentCore post this month with a very good hook: you should be able to close your laptop while the coding agent keeps working. That is the demo-friendly version. The more important version is this: once the agent leaves the laptop, "what happened?" becomes a production question. And that is where observability stops being a nice enterprise add-on and becomes part of the product. remote is not the same as trustworthy Moving a coding agent to a hosted runtime solves some obvious problems. The agent can keep running after your machine sleeps. Multiple agents can run in parallel without fighting over the same local Postgres port. The filesystem can persist between sessions. The environment can be isolated in a microVM or container instead of sharing your real shell with everything else you do all day. Good. But remote execution also removes a useful kind of accidental visibility. When the agent is on your laptop, you can at least see the terminal, notice the fan spin up, watch the test output, and feel the blast radius because it is your machine. In a hosted runtime, that little bit of intuition disappears. The agent is now somewhere else, with its own filesystem, network path, credentials, tools, retry behavior, and bill. So the platform has to replace intuition with evidence. Not a transcript pasted into a PR. Actual operational evidence: traces, logs, metrics, command history, too

There’s something uniquely beautiful about old books. The smell of weathered paper, the texture of...

Optimizing RAG Pipelines, Migrating AI Agents, and LLM-Powered Troubleshooting Today's Highlights This week's highlights cover advanced strategies for building and maintaining robust AI systems, from fine-tuning RAG pipelines to orchestrating agent migrations. We also explore practical, real-world LLM application in IT operations. A Cognitive Benchmark for Code-RAG Retrieval: Part 2 — Why Model Rankings Depend on the Pipeline (Dev.to Top) Source: https://dev.to/miftakhov/a-cognitive-benchmark-for-code-rag-retrieval-part-2-why-model-rankings-depend-on-the-pipeline-12a4 This article delves into the critical but often overlooked aspect of RAG (Retrieval Augmented Generation) performance: how the entire pipeline, not just the underlying LLM, dictates retrieval efficacy, especially in code-RAG scenarios. It introduces a cognitive benchmark for code retrieval, moving beyond simple keyword matching to evaluate how well a RAG system understands developer intent when querying unfamiliar codebases. The core insight is that model rankings are highly dependent on the complete RAG pipeline design, including chunking strategies, embedding models, and retrieval algorithms, rather than solely on the base LLM's capabilities. For developers building code-centric RAG applications, this implies a need for holistic pipeline optimization. The article emphasizes that focusing on individual components in isolation may lead to suboptimal results. It encourages a structured approach to benchmarking that reflects real-world developer queries and challenges, such as understanding system behavior rather than just file names. This technical perspective is crucial for anyone looking to deploy robust and performant RAG systems for code generation, search augmentation, or automated code understanding. Comment: This is a crucial read for anyone moving beyond basic RAG demos. It highlights that success in production RAG systems, particularly for code, is all about the pipeline engineering , not just

Gemini Prototyping, AI Code Migration Agents, and LLM Transparency Insights Today's Highlights Today's highlights include Google Gemini's rapid app prototyping capabilities for developers, showcasing how AI can generate functional apps from prompts, alongside insights into AI agents for accelerating legacy code migration projects. We also examine the critical importance of transparency in the commercial LLM space, as a "homegrown" model was revealed to be a merge of existing models. Gemini Accelerates App Prototyping: From Prompt to Functional App in Minutes (The Verge AI) Source: https://www.theverge.com/ai-artificial-intelligence/942119/vibecoding-backyard-app-gardening-organizing This article from The Verge vividly illustrates the emergent capabilities of Google's Gemini large language model (LLM) as a powerful AI-powered developer tool for rapid application prototyping. Faced with the practical challenge of a dying yard, the author embarked on a novel approach: leveraging Gemini with a lengthy, natural language prompt to generate a functional mobile application. Within a mere five minutes, Gemini delivered not only the underlying code for a basic gardening management app but also presented an interactive version of it in a live preview window. This experience powerfully demonstrates Gemini's potential to dramatically reduce the initial time and effort traditionally associated with app development. Developers can articulate their desired functionality, user interface elements, and data models through conversational prompts, and Gemini can translate these high-level requirements into working code. While the process, as noted by a subsequent bug message, wasn't entirely flawless, the sheer speed at which a tangible, interactive prototype was generated underscores the transformative impact of LLMs on the developer workflow, enabling far faster iteration and proof-of-concept development, particularly for common application patterns and straightforward logic. This han

Build custom AI apps - chatbots, RAG pipelines, and agents - entirely on your own hardware with Dify and Ollama. No monthly fees, no data leaving your network. What You Need A GPU with 12GB+ VRAM (RTX 3060 12GB or better) Docker + Docker Compose 2.24.0+ About 20 minutes Architecture Component Role Dify Visual app builder, RAG engine, agent framework, API layer Ollama Serves local models via OpenAI-compatible API Qwen3 14B Default model - strong general chat, fits 12GB at Q4 Setup Step 1: Start Ollama docker run -d --gpus all -p 11434:11434 --name ollama \ -v ollama:/root/.ollama \ ollama/ollama Pull your default model: docker exec ollama ollama pull qwen3:14b Step 2: Start Dify git clone https://github.com/langgenius/dify.git cd dify/docker cp .env.example .env docker compose up -d Step 3: Connect Ollama to Dify Open http://localhost/install and create your admin account Go to Settings > Model Provider Click Ollama and fill in: Model Name: qwen3:14b Base URL: http://host.docker.internal:11434 (Docker Desktop) or http://YOUR_IP:11434 (Linux) Click Save Build Your First App Chatbot Studio > Create Application > Chatbot. Select your model, add a system prompt, publish. Your chatbot gets a public URL and API endpoint. RAG Pipeline Knowledge > Create Knowledge. Upload documents, choose chunking strategy, create an app that uses this knowledge base. Now your chatbot answers from your documents. Agent Studio > Create Application > Agent. Add tools (web search, code interpreter), give it a goal, Dify orchestrates the tool calls. Cost vs Cloud Local Dify Cloud + OpenAI Monthly $0 $59-599 + API usage Hardware ~$300 once $0 Data privacy Stays on your machine Sent to cloud AI calls Unlimited, free Per-token billing After about 5 months the GPU has paid for itself versus a mid-tier Dify Cloud plan. Full guide with detailed troubleshooting and alternatives: https://everylocalai.com/stack/dify-ollama-local-app-builder

TL;DR: Two tools cut Claude Code token usage at two different layers. RTK is a shell proxy that compresses command output before it ever reaches the context window. context-mode is a Claude Code plugin that does heavy tool work in a sandbox and hands back only the answer. They stack cleanly on top of each other, and a single skill installs both. This article explains how each one works and how to wire them in. Two commands into a session, my context window was already a third full, and I hadn't written a line of code yet. A pnpm install had dumped its entire dependency tree, a git log paid out two hundred commits, then a stack trace landed in full. None of that was work I'd asked for - it just sat there in the context window eating tokens on every turn. Most of the token budget goes on that boring output - the installs, the logs, the traces - which piles up and gets re-read on every single turn, never on the clever reasoning you actually wanted. Two tools attack that pile from two directions. Here's how they work, and how to install both in one command. This is the last article in the series, and it builds on the skill pattern from the third. You can pass this article URL straight to Claude Code and follow along. Where the tokens actually go Picture the context window as a desk. Everything Claude needs stays on the desk so it can glance at it: your prompts, its replies and the output of every command it ran. The desk has a size limit, and once something is on it, it gets re-read on every turn until it falls off the edge. Two kinds of clutter land there: Command output that arrives bloated. A dependency install, a long log, a verbose test run. It enters once and costs tokens on every turn after. The accumulated pile itself. Even reasonably sized outputs add up across a long session until the desk is buried. The two tools map onto those two problems. RTK trims the output before it ever reaches the desk. context-mode keeps the heaviest work off the desk altogether. Lay

Started looking for a tourism dataset on Kaggle for a new project. Found one with real UNWTO data, but it only went up to 2022 — not enough for what I wanted (post-COVID trends). Then found a better-looking one: "Global Tourism & Travel Trends (2019-2024)," 24 upvotes, great coverage range. Almost picked it on the spot. Then I actually read the full description. Turns out it's synthetic — 10,000 generated records, not real recorded stats. Had to rename the whole project: from "Travel Recovery Analysis" to "Travel Behavior & Satisfaction Trends (2019-2024)" — same dataset, just honest framing. Still great for practice: 33 features, zero nulls, covers spend, satisfaction, eco-choices, transport modes. Anyone else ever almost build a project around the wrong assumption about their data? 👀

Hi everyone, I've been hacking on a local personal memory system called Hillock . Honestly, it's very much a work in progress and it isn't some flawless breakthrough, but I wanted to see if we could build a lightweight, completely offline memory layer for local LLMs without the overhead of running a heavy neural vector database or wasting precious VRAM. The project is named after the biological Axon Hillock —the exact gatekeeper region of a human neuron that sums up incoming electrical charges and decides whether to fire (open the gate) or remain silent (block). How the architecture works: The Ground Truth (SQLite) : Stores hard facts as simple database triples (Subject-Predicate-Object) so the system has a solid symbolic foundation. The Synapses (Hebbian Plasticity) : Tracks which concepts co-occur during a conversation to dynamically build gradient-free associative weights. The Context (Hyperdimensional Computing) : Maintains a 10,000-dimensional leaky context vector that rolls, binds, and accumulates history. This helps the system resolve pronouns (like "he/she") and decide when to block a query to prevent hallucinations. The Honest Benchmarks (Yes, it breaks!) I wrote a tough, 30-sentence scientific benchmark with complex sentence structures and hard negatives (like asking what Einstein discovered when the text only mentions Curie discovering radioactivity and Einstein working with her). Running Qwen 1.5B locally on my computer, here is how it actually did: Extraction Precision : 10.6% Extraction Recall : 22.7% Retrieval Accuracy : 30.0% Gate Accuracy : 30.0% Why are these scores low? Because a tiny 1.5B model completely trips over complex English grammar during ingestion (it gets confused and creates weird predicates). However, the actual HDC vector-matching itself is incredibly stable. I enforce a Constant-Component-Count of exactly 3 components per fact, which balances the vector norms and keeps retrieval highly reliable once the facts are actually in the dat

Hello, I'm Shrijith Venkatramana. I'm building git-lrc, an AI code reviewer that runs on every commit. Star Us to help devs discover the project. Do give it a try and share your feedback for improving the product. Every developer eventually discovers the same frustrating pattern. Your application sends a 20,000-token prompt to an LLM. The first request takes 2 seconds. The next request contains the exact same 20,000 tokens plus a tiny user message at the end. And somehow the model processes the entire thing again. At least, that's what many developers assume. Modern LLM systems have a trick called prompt caching that can dramatically reduce latency and cost by reusing work from previous requests. But unlike traditional application caches, prompt caching isn't storing generated text. It's storing something much deeper inside the model. To understand how prompt caching works, we need to follow a prompt all the way through the transformer itself. The Expensive Part of Processing a Prompt When a prompt enters a transformer model, it isn't immediately generating text. First, the model must process every input token through every layer of the network. Imagine a prompt like: System: You are a helpful coding assistant. Project Documentation: [20,000 tokens of documentation] User: How does authentication work? Before generating a single output token, the model performs: Tokenization Embedding lookup Multi-head attention Feed-forward networks Layer normalization ...across dozens or even hundreds of transformer layers. For a large model, this preprocessing is often more expensive than generating a short answer. If another user asks: System: You are a helpful coding assistant. Project Documentation: [Same 20,000 tokens] User: Explain the database schema. Most of the prompt is identical. Without caching, the model would recompute everything from scratch. Prompt caching exists to avoid that waste. The Key Insight: Cache Internal Transformer State, Not Text A common misconception

Introduction Artificial intelligence is now much more advanced than chatbots. With little assistance from humans, modern AI systems are capable of reasoning, planning, using tools, remembering previous interactions, and carrying out complicated tasks. We refer to these systems as AI Agents. AI agents are quickly emerging as a crucial component of contemporary software engineering, from coding assistance to research automation and customer service systems. We'll look at what AI agents are, how they operate, and why they are influencing software development in the future in this post. Actually, What Is an AI Agent? An AI Agent is a system that can: Understand a goal Decide what actions to take Use available tools Remember relevant information Execute tasks Evaluate results Unlike traditional software,the AI Agents are goal-oriented rather than rule-oriented. AI Agents vs Traditional Chatbots Traditional chatbots primarily answer questions and respond to prompts. AI Agents go further by completing tasks, maintaining memory, planning actions, and executing multi-step workflows. A chatbot responds; an AI Agent acts. Core Components of an AI Agent Large Language Model (LLM) The LLM acts as the brain of the agent. Popular models include those from OpenAI, Anthropic, and Google DeepMind. The model understands instructions and generates decisions. Tools Agents become powerful when connected to tools such as: Web search Databases APIs Email systems Calendars Code execution environments Without tools, an agent can only generate text. With tools, it can take actions. Memory Memory allows agents to retain information. Short-Term Memory: Used during the current task, such as user preferences and conversation context. Long-Term Memory: Stores information across multiple interactions, such as historical data, preferences, and recurring workflows. Planning Planning enables agents to break large goals into smaller tasks. Example: Goal: Build a market research report. Plan: Collect da

Here are some ways you can get a Kindle Unlimited membership at a discounted price.

According to a new report from Semafor, the White House's decision to impose export restrictions on Anthropic's Mythos was driven in part by fears that it had been accessed by a group linked to China. If the Chinese government actually had access to Mythos 5 or Fable 5, it would present a serious national security […]

Originally published at llmkube.com/blog/making-self-hosted-llm-agents-trustworthy . Cross-posted here for the dev.to audience. Running a single local LLM node is a solved problem. You write an InferenceService, the operator schedules it, llama.cpp or MLX serves it, and you get an OpenAI-compatible endpoint. We have been doing that for months. Running a fleet of them is where it stops being easy. My fleet is heterogeneous on purpose: CUDA pods in the cluster, and Apple Silicon Macs sitting off-cluster on the homelab network, each one running two separate agents (one for inference, one for the agentic coding harness). The day I shipped 0.8.4 to that fleet, I learned exactly how it does not scale. I updated each Mac by hand. The control plane had no idea what version any agent was running. And the launchd reload I used to restart an agent was a silent no-op on an already-loaded service, so the old binary kept running while I believed I had updated it. I found that out by hand-inspecting a process tree. Three machines made it annoying. Thirty would make it impossible, and the whole pitch for sovereign, on-prem AI is that you run a lot more than three. So the last stretch of work on LLMKube was not about a faster runtime or a bigger model. It was about making the fleet trustworthy : able to update itself safely, and unable to lie to the control plane about its own state. Here is what that took. Helm and brew for the edge The fix is a new cluster-scoped CRD, AgentRelease , and a self-update path in the agents themselves. You describe the release you want once, the operator rolls it out, and the agents pull and apply it. The design borrows directly from prior art that already solved this for Kubernetes nodes: Rancher's system-upgrade-controller, k0s autopilot's per-platform SHA-256 staging, and Teleport's outbound-only poll model. The properties that make it safe to leave running: Declarative and approved. An AgentRelease names the agent, the version, and the per-platform

In early 2026, Anthropic researchers ran an experiment with 52 junior developers. Half used an AI assistant to learn an unfamiliar Python library. The other half worked without one. Both groups finished the task. But when tested on how well they understood the code they had just written, the AI-assisted group scored 50% on a comprehension quiz - versus 67% for the unassisted group. That 17-percentage-point gap has a name: cognitive debt. It is one of the most important concepts in software engineering right now, and most developers are not paying enough attention to it. What Is Cognitive Debt? Cognitive debt describes the growing gap between the volume of code that exists in a system and the amount that any developer genuinely understands. It is not a new term, but it crystallized across multiple research streams in early 2026. Addy Osmani (Google Chrome) described it as "comprehension debt" - the hidden cost that accumulates when code becomes cheap to generate but understanding still requires deliberate effort. Margaret-Anne Storey (University of Victoria) formalized the concept in a March 2026 arXiv paper, framing it as a team-level problem and extending it into a Triple Debt Model: technical debt in the code, cognitive debt in the people, and intent debt - the missing rationale that both humans and AI agents need to safely work with code. Cognitive Debt vs. Technical Debt These two ideas are easy to conflate, but they are fundamentally different problems. Technical debt lives in the code - it shows up as slow builds, tangled dependencies, and failing tests. Cognitive debt lives in people - it surfaces as an inability to explain, debug, or extend code that the team themselves wrote. The critical difference: technical debt announces itself through friction. Cognitive debt breeds false confidence. Your tests are green, velocity looks fine, and nobody realizes the system is fragile until something breaks in production and the team cannot reason through why. What the