Centralized Governance in Developer Tooling: Control-Plane Pattern

I Made Claude Prove its hallucination I built an evidence-first 4-agents code+infra reviewer Everyone rushing to trust AI answers faster with multiple prompts. I did the opposite. Built a local multi-agent debugging copilot using Claude Code’s new experimental agent-teams feature. Router → Retriever → Skeptic → Verifier. Evidence first, explanation later. Logs, schema, deploy diff in. Root cause + proof out. ⚠️ Still experimental. Treat it as a thinking partner not a decision engine. The real trick is forcing answers to earn evidence before anyone acts. Ref - https://lnkd.in/gH_x2uN7 https://lnkd.in/gTDYbWVW

This is the part that stands out to me most: the skeptic layer. A lot of people are focused on getting AI to answer faster. I’m more interested in getting it to answer with proof. Having a skeptic in the loop changes the game. It pushes the system to challenge its own assumptions, look for weak spots in the reasoning, and actually earn confidence before giving an answer. That matters a lot when you’re debugging code, reviewing infra changes, or trying to avoid hallucinations that sound convincing but are flat-out wrong. That evidence-first mindset feels way more useful than just stacking prompts and hoping for the best.

Had a great time vibe coding some evals with Hamel Husain My biggest takeaway: you have to own your evals. Own your skills. Own your code. Tools like Claude Code are massive accelerants — but only if you bring the right practices, guardrails, and infrastructure. Don't let agents rip before you've learned the fundamentals from people like Hamel Husain who've been doing this work for years. Automate the boring, monotonous parts. But always verify. Force the coding agents to prove their work. The loop is definitely not closed — yet 😜 Arize AI #ArizePhoenix #OSS

Claude Code deny rules are not a reliable security boundary — and the permission system behaves differently than the docs imply. I’ve started a new series called “Navigating Claude Code”. The first article covers the bare minimum setup: the file hierarchy, CLAUDE.md, and why I skip deny rules entirely — with a practical suggestion on what to use instead. https://lnkd.in/eiCEK3X9 Happy to hear your thoughts or feedback! #ClaudeCode #AI #DeveloperTools #SoftwareEngineering #Anthropic

Context rot is the silent killer of enterprise AI projects. Your AI assistant works great on Day 1. By Day 30, it’s hallucinating field names, forgetting business rules, and generating code that contradicts decisions made two sprints ago. This isn’t a model problem. It’s a governance problem. I built Enterprise Intelligence — a governance and context management layer for Claude Code — specifically to solve this. It’s built on Kimball dimensional modeling methodology, the same framework that’s powered enterprise data warehouses for decades, now adapted for the AI era. In this demo, I show exactly how Enterprise Intelligence defeats context rot in real time — maintaining consistent, accurate context across sessions while Claude Code builds production software. No prompt hacks. No hope-based engineering. Actual architectural governance. If your engineering team is using AI coding tools at scale, this is the gap you didn’t know you had. 🎥 Full demo (no email gate): https://lnkd.in/esJ5Jxmp #AI #ClaudeCode #EnterpriseAI #DataGovernance #ContextManagement #Anthropic #AIEngineering

I have watched AI coding tools lose coherence on tasks that take longer than 20 minutes. This session ran for 3.5 hours and never drifted. The difference is not a better model. It is structured governance that tells the AI what your organization expects before it writes a single line. (h/t Paul W. Encephalon)

Claude Code now remembers what it learns across sessions - automatically tracking debugging patterns, project context, and preferred working methods without manual input. More: https://lnkd.in/dvXt875j

We (my agents and I) deleted 2,000 lines of code yesterday. The system works better. Our Control Tower - the brain that coordinates our AI agents - had grown to 2,700 lines across 3 files. 20+ config knobs. Observation backoff curves. Multi-tier escalation. Event debouncing. Cycle versioning. It didn't work. Agents weren't receiving tasks. Session keys were overflowing. The observation loop was sleeping for minutes between cycles. Our review agent was rubber-stamping everything. Every fix added more mechanism. Every mechanism added more failure modes. The codebase was a graveyard of solutions to problems caused by previous solutions. So we deleted it all. The rewrite: 650 lines. Three functions. gather_state() plan() dispatch() One loop, ticks every 60 seconds. The LLM still makes all the decisions - we just removed everything standing between "here's the state" and "do what it says." Before: 2,700 lines, 50+ functions, 20+ config knobs After: 650 lines, 4 core functions, 7 config values Result: fully autonomous, dispatching tasks, agents building, dual review pipeline running, 1,294 tests passing. The lesson we should have started with: Complexity is not sophistication. It's a sign you stopped asking whether the simpler solution would work. Every mechanism you add is a mechanism that can break. Every config knob is a knob someone will set wrong. The best version of our system is the one where we deleted 2,000 lines. If you can't name the simpler alternative you considered, you haven't thought hard enough.

I had a conversation with Claude last week that I did not want to lose. We were planning a major overhaul to how my AI collaborator handles session continuity. It was a 45-message back-and-forth where we brainstormed, debated trade-offs, rejected approaches, and landed on an architecture. The kind of conversation where the reasoning matters as much as the result. Then I cleared the context. The plan was captured in a handoff document, but when the next session tried to implement it, things went sideways. The handoff had the decisions but not the reasoning. It had the "what" but not the "why not." This morning I learned something: those conversations are not actually gone. Every Claude Code session is automatically saved as a JSONL transcript file on your machine. No configuration required. I had 150 session transcripts sitting on disk and did not know it. The raw files are not useful on their own — a 2MB JSONL file full of tool calls and metadata is not something you want to read. So I built a skill that extracts the human-readable conversation and saves it as a clean, searchable markdown file. The real insight is not the tool. It is this: the biggest gap in working with AI is not capability. It is state. The model is smart enough. The question is whether it has what it needs to make the right call. Full post: https://lnkd.in/gPV4knES

I deleted 400 lines of code yesterday. The system got better. A voice AI agent we built had a complex routing engine — 14 decision branches for handling different caller intents. Took 3 weeks to build. Sophisticated. Elegant. And slow. Average response time: 2.8 seconds. Callers were hanging up. I replaced the whole thing with 3 rules and a fallback. Response time dropped to 0.9 seconds. Caller completion rate went from 67% to 84%. The complex version was technically superior. The simple version was actually useful. In production, every millisecond of latency and every unnecessary decision branch is a place where things can break. Simplicity isn't laziness. It's engineering discipline. When was the last time deleting code improved your system?