Unlocking AI Potential with Claude Code

In the era of AI agents, the key advancement may no longer lie in building more sophisticated search engines, but in developing agents that can utilize search tools more effectively.

// Is Grep All You Need? // Pay attention to this, AI devs. (bookmark it) They find that grep-style text search, when wrapped in the right agent harness, matches or beats embedding-based retrieval on coding-agent tasks. Are vector databases even needed where this is all going? It might be that what coding agents needed was not better embeddings. It was a better harness design around primitive tools. If you operate a coding-agent stack that depends on a vector DB, it might be time to re-evaluate. My personal experience on this has been that agentic search, if done right, is more than good enough for a lot of use cases. But you also have to understand how to properly index and structure information for the agents to take advantage. At scale, vector databases do shine, so take that into account as well. In most cases, a hybrid approach often works best, but that's something we haven't figured out really well as of yet.

A boring but useful way I used AI this week: A member asked me where to find a prompt I'd shared a few months back. I knew exactly the one they were looking for, but also knew it was buried in 48 published posts. Members shouldn't have to dig like that. If you've been publishing on Substack for a while, you know this problem. Your best frameworks, prompts, and templates end up scattered across an archive that's hard to search through. The old way to fix it: open every post one by one, dig out every reusable piece, manually add each piece to a database. I'd been dreading this for months. But 48 posts in, it was time. So I had Codex do it. I switched on its Chrome connector and let it click through all 48 posts on its own, pulling out every prompt, template, recording, and workflow as it went, then sorting them into a Notion database it built and tagged itself. The result is the Mise Library: 75+ reusable resources, filterable by type, by tool, and by use case. The best part was the new connector ran in the background. While Codex worked through the whole archive, I kept using the same browser to write. It handed back a sorted, searchable library, and I got to focus on the work I do best.

⛳ The AI agent stack in 2026 looks very different from what we saw in 2025. Here’s a nice way to think of it... I wrote a similar article back in 2025 but, just like everything in AI, much has changed. Now I believe, there are nine layers, here's an overview (I also explain my rationale in much more detail in the post linked below):  ⛳ Interfaces, Workspaces, and Harnesses: where humans meet the agent. Ranges from a Slack channel to a full coding harness like Claude   Code, Cursor, or Codex. ⛳ Agent Runtimes: the orchestration layer. LangGraph, OpenAI Agents SDK, Google ADK, Microsoft Agent Framework, AutoGen, CrewAI, Agno,   DSPy, Letta.                                                                 ⛳Protocols and Interoperability: MCP, A2A, AG-UI, A2UI. The most consequential change of the year.  ⛳ Tools, Actions, and Sandboxes: what the agent can do. E2B, Browserbase, Composio, computer-use, browser-use.               ⛳ Knowledge, Context, and Retrieval: vector DBs, enterprise search, document intelligence (Pinecone, Weaviate, Glean, LlamaIndex).     ⛳ Memory and State Management: Zep, Letta, Mem0, Cognee. A different problem from retrieval, and one that finally got its own layer.    ⛳ Models, Inference, and Routing: the foundation. OpenAI, Anthropic, Gemini, plus inference platforms (Groq, Together, Fireworks) and    routers (LiteLLM, OpenRouter).                                                        ⛳ Observability, Evals, and Quality: first vertical rail. LangSmith, Langfuse, Braintrust, Arize, Phoenix, Promptfoo.            ⛳ Governance, Security, and Human Control: second vertical rail. The conversation every enterprise contract opens with now.                                           Full article: https://lnkd.in/g_BCgzSg

New post: The Cost of Cheap Code I (attempt to) follow AI releases through a newsletter called The Rundown AI. On a typical Tuesday: four new product releases across three providers. That's normal volume for a weekday. It's a lot. A lot a lot. But this speed is exposing an issue we will see more and more: it's the gap between how fast vendors can ship code and how fast a customer can actually derive value from it. The simplest concept I've thought of is calling it the Absorption Gap. Ironically, as code becomes cheaper, human judgment becomes more expensive. The person who can tell you which three features will actually move your North Star metric is the most valuable person in the room. Festina lente. Not slower. Smarter. https://lnkd.in/eHKVz448

I don't use AI memory. At a recent event, I had to explain why. It comes down to one question: where does the memory actually come from? Three sources: 1. Your messages 2. The model's own reasoning 3. Tool call results (1) is unreliable. I ask hypotheticals to get better answers. "What if I migrated our DB to Postgres?" doesn't mean I want it. But the memory stores it as "user wants Postgres," and every future answer is poisoned. (2) is worse. The model decides something about you mid-task: "you prefer minimal abstractions" and saves it as fact. You never said it, but the model just made it up. (3) is the only one I'd trust. When the agent does a WebFetch, it knows what page it actually saw. When the Slack MCP reads messages, those are real messages from real people. Compress a few thousand of them and you get a real signal of how I communicate, not what I claimed in a prompt. What makes this work: tool results are external facts. "Page X said Y", "Person A wrote B". Even if the claim itself is wrong, what the tool returned really happened. This is a solid ground to look at the problem from different angles. Building a small PoC this week, scoping memory to MCP tool outputs only. Am I missing something obvious?

Nobody is going to fire you because of AI. Your colleague might, though. The one who quietly figured it out six months ago and now ships twice as fast while you're still debating whether to trust the autocomplete. Uncomfortable? Good. Let's keep going. I'll be honest. I was that guy. Loudly, proudly anti-AI-for-everything. My IDE, fine. Generating a bit of boilerplate, sure. But using it for actual thinking? Absolutely not. I earned my scars the hard way, and I wore them like a badge. I mean, I fell in love with programming the day I first got Java to print "Hello World" on screen. You know what it took? An entire ceremony of code just to say hello to a world that didn't ask to be greeted. A public class. A main method. A system.out.println. Just to say hi. A lesser person would have quit. I chose to stay. That stubbornness was my identity. So yeah, AI threatening to make things easier felt personal. Then one day I looked up and realized I was falling behind not on the hard stuff, on the routine stuff. The stuff I was too proud to automate. That's a specific kind of FOMO that hits differently at 11pm when your colleague's PR is already reviewed and merged. Here's the thing nobody says clearly enough: what's happening now isn't a productivity upgrade. It's a redefinition of what software development even means. AI now writes close to half of all code committed by active developers. Teams that used to need 25 people are shipping with 10. An 8-year migration project somewhere got done in weeks. Weeks. And most developers are still just using AI as a faster keyboard. Tab, accept, move on. That's the trap. The ones who will actually matter in 3 years aren't moving faster through the same work. They're doing work they couldn't touch before, real system design, catching the weird business logic error hiding inside perfectly clean AI-generated code, thinking architecturally at a level that used to require 15 years of grey hair. The ceiling just got higher. Not lower. Two types of engineers are living through this moment right now. The first is defending their territory, avoiding the tools, hoping the whole thing is a phase, protecting what they know or too busy to think AI. The second is asking a different question entirely: "what can I own now that I couldn't before?" One of them will be irreplaceable in 3 years. The other will be a slide in someone's business school case study. I still believe in learning the hard way. I still think you should know why the code works, not just that it does. But I've also accepted that the hard way now means mastering how to think with AI, not against it. The craft isn't disappearing. It's moved to a higher floor. The elevator is open and slightly embarrassingly, I was one of the last ones to get on. What about you? Were you an early adopter, a skeptic who came around, or are you still holding out? No judgment, I was firmly in camp 2 until recently.

Here's how smart AI/Claude Code is. I was trying to get it to push a feature live. It crashed while trying to deploy, I'd say about 8 times. I kept showing it logs. It kept trying to readjust. Over and over. I got frustrated. I looked at the logs. I told it: Set up the database table LIKE THIS (and I provided it). It pushed -> No crash. If you don't know how to design a database, or if someone doesn't know how to troubleshoot, what do you do there?

Your AI forgets everything the moment you close the tab. I got tired of that. Every chat starts from zero. You read something useful, take notes, come back two weeks later and you're googling the same thing again. AI didn't fix this, it just made the forgetting faster. So I built a system around an idea from @AndrejKarpathy, instead of asking AI to retrieve from raw documents, you have it maintain a persistent wiki. Every source you feed it gets broken down into structured, interlinked markdown pages. New sources don't replace old knowledge, they enrich it. Contradictions get flagged. Cross-references form automatically. The setup is Claude Code + Obsidian. Claude Code maintains the wiki (reads sources, writes pages, updates links). Obsidian just visualizes it there's a graph view that shows your entire knowledge base as a network of nodes and edges. Day one, after ingesting my existing notes and sheets 60+ connected pages, zero manual linking. Things I'd written separately over months, now visibly connected. The clip attached is what the graph looks like now. Each node is a page. The clusters around topics I've spent the most time on are obvious. So are the gaps. Wrote up the full architecture and the exact config file you need to replicate this Substack article and GitHub README both linked in the comments if you want to build your own. Built on Anthropic Claude Code + Obsidian Substack : https://lnkd.in/gT_6Q2Kq Github: https://lnkd.in/grH5qCvG #BuildingInPublic #SoftwareEngineering #AITools #ClaudeCode

Most people start building LLM apps the same way: Input → LLM → Output. And honestly, that’s enough… until you try to ship something real. What works in a demo often falls apart in production. Because real users don’t behave predictably. Queries change. Tools fail. Models hallucinate. Flows break. That’s the point where you stop thinking in chains — and start thinking in agents. Here’s the difference 👇 🔗 Chains → predictable, linear, controlled A chain follows a fixed sequence of steps. Perfect for things like: • Summarisation • Classification • Structured extraction • Simple RAG flows They’re fast, reliable, and easy to reason about. But they have one big limitation: They can’t adapt. If something goes wrong, the chain doesn’t “think.” It just continues executing the next step. ━━━━━━━━━━━━━━ 🕸 Agents → dynamic, stateful, decision-driven Agents work differently. Instead of following a strict path, they decide what to do next based on the current state. That means an agent can: • Use a tool and decide the next action from the result • Retry when an output is poor • Loop until a task is completed • Choose between multiple strategies dynamically This is where frameworks like LangGraph change the game. You’re no longer building a fixed pipeline. You’re building systems that can reason about their own workflow. ━━━━━━━━━━━━━━ 🔍 The part most teams ignore → observability Chains or agents — doesn’t matter. Without tracing, you’re basically debugging in the dark. You need visibility into: • The exact prompt sent to the model • The model response • Tool calls and outputs • Latency and token usage • Where failures actually happened Because when an AI system breaks, the hardest part is figuring out "Why". ━━━━━━━━━━━━━━ 🧠 The mindset shift → Chains = you control the flow → Agents = the model influences the flow → Observability = the only way to trust either one That’s the real evolution happening in AI engineering right now. ━━━━━━━━━━━━━━ 💡 If you’re starting out: ✔️ Begin with chains ✔️ Add agents only when branching/decision-making is genuinely needed ✔️ Add tracing from day one — not later The teams building reliable AI products are not winning because they have access to better models. They’re winning because they designed better systems. What are you building right now — chains, agents, or fully observable AI systems? 👇