Felipe Reis’ Post

Built an internal dev tool for personal use recently to rethink how LLM agents interact with large codebases. Instead of relying on traditional grep-style search (which often misses context, struggles with relationships, and returns noisy, fragmented results), I experimented with converting an entire Spring Boot codebase into a structured knowledge graph. Here’s the approach: - Java classes, methods, and interfaces → modeled as nodes - Relationships (calls, inheritance, dependencies) → edges - Entire graph → embedded and stored in a ChromaDB vector database - Exposed via an MCP server → usable directly by CLI agents like Gemini CLI 💡 Why move away from grep? - Lacks semantic understanding - Misses cross-file relationships - Returns keyword matches, not meaning - Doesn’t scale well for complex reasoning tasks 🚀 What worked well: - Much richer, structured context for LLMs - Better understanding of code relationships and architecture - More accurate responses for “how things connect” type queries - Reduced noise compared to raw text retrieval ⚠️ Challenges & trade-offs: - Graph construction + embedding pipeline adds overhead - Needs careful tuning for general-purpose queries - Some simple queries are actually faster with traditional search - Maintaining freshness with frequent code changes is non-trivial The system works, but still needs refinement to handle broader, ambiguous developer queries more robustly. Overall, this feels like a promising direction for moving beyond naive code retrieval → towards context-aware, structure-driven reasoning for AI-assisted development. Curious if others are exploring graph-based retrieval for code? Would love to hear thoughts or alternative approaches 👇

Most developers ignore code reviews not because they don’t care, but because they’re boring. So I built something different. Introducing CodeVibe AI — an AI-powered code review tool that shows how your code improves instead of just telling you what’s wrong. Instead of long text suggestions, it provides visual before → after code transformations, context-aware analysis across files, and filters out low-value feedback to highlight only what actually matters. You can use it in three ways: • Analyze your GitHub pull requests • Explore real-world public PRs • Paste your own code Built with: Next.js • FastAPI • Supabase • GitHub API • GPT-4.1 Fully deployed: • Frontend on Vercel • Backend on Render Version controlled using GitHub with a modular and scalable architecture. The goal wasn’t just to build a project, but to create an experience developers would actually use. Live : https://lnkd.in/dsXvb_mi Would you use something like this?

AI Code Intelligence — Local, Private, Deep I built CodeSpectra to give developers a way to analyze entire codebases deeply while keeping everything 100% local. Here is how it helps you: - Understand Architecture: Instead of just summarizing a file, it maps out how your features and conventions connect across the whole repo. - Audit & Report: Generates deep semantic reports in Markdown to help you or your team onboard faster. - Stay Private: Scans your local folders or remote Git repos (SSH/GitHub/GitLab) without your code ever leaving your machine. - Your AI, Your Choice: Connect it to Ollama for a fully local experience or use your own API keys. The Stack: Electron, React, FastAPI, and a native C++ module for fast indexing. The core pipeline is ready. If you’re dealing with a massive codebase and need an AI that actually "gets" the structure, give CodeSpectra a try! Github Repo: https://lnkd.in/gvn2KWsR

I just released tool-history-guard — a small open-source TypeScript library for AI agents. If you build agents with tool calling, your message history can silently break after retries, interruptions, or resume flows. The model API rejects it with a vague error and you're left debugging. This package gives you a preflight check before the request goes out: • Detects tool calls with no matching result • Detects orphan tool results • Detects wrong ordering and duplicates • Can auto-fix safe structural issues • Zero dependencies, provider-agnostic OpenAI and Anthropic message formats work out of the box. Any other provider works via a small custom adapter. npm install tool-history-guard 📦 npm: https://lnkd.in/dRT3eRAz 💻 GitHub: https://lnkd.in/dzBxHijq Feedback and contributions welcome.

I believe the best software often starts with a personal problem that needs solving. My latest project, Matthew, began exactly that way. The backstory is simple but significant: My friend Matthew had a collection of documents and PDFs that were becoming impossible to manage. He needed a way to query his own library without sending his entire document collection to the cloud. I decided to build him a tool that keeps the heavy lifting local and searchable. I am excited to share that I have just open-sourced the result. Matthew is a local-first desktop application designed for semantic search and AI-powered chat over your personal PDF collection. Here is how the privacy model actually works: 🔒 What stays on your machine: PDF parsing, chunking, embedding generation, and vector search all run locally. Your documents are never uploaded anywhere. 🌐 What goes over the internet: AI chat is powered by OpenRouter — when you ask a question, your query and the relevant retrieved passages are sent to whichever LLM you choose. ✅ Tech Stack • Tauri for a lightweight desktop shell • Rust for high-performance backend logic • React + TypeScript for a responsive interface • LanceDB + fastembed for fully local vector search ✅ Languages Used: TypeScript · Rust · JavaScript · CSS · HTML If you have been looking for a way to semantically search your local document library — or want to see how Tauri and Rust can power AI-driven desktop apps — check out the repository below. Explore the project here: https://lnkd.in/dSTit3m8 I would love to hear your feedback on the architecture. If you find it useful, please consider giving the repo a star, forking it to build your own features, or contributing to the codebase. #OpenSource #RustLang #Tauri #ArtificialIntelligence #SoftwareEngineering #DeveloperTools

Those paying for AI by usage — not by subscription — know: tokens burn fast. One "hello" and your context window is already 20% full. 😅 That's not a bug. That's a modern LLM in default mode: verbose, thorough, with an intro, a middle, and a conclusion — where a single sentence would do. Found a tool called Caveman — a plugin for AI agents that instructs them to respond concisely. No filler, no explaining the obvious. Works with Claude Code, Cursor, Windsurf, Codex, Gemini CLI, Cline, Copilot, and 40+ other agents. Real benchmark numbers: 1️⃣ Explaining a React re-render bug — 1180 tokens → 159. That's -87% 2️⃣ PostgreSQL Connection Pool setup — 2347 → 380. That's -84% 3️⃣ Docker multi-stage build — -72% 4️⃣ Average across all tests — ~65% fewer output tokens 🔥 There are several compression levels — from "trim the fluff" to full telegraph mode. There's even a Classical Chinese mode (/caveman wenyan) — which the authors claim is the most token-efficient written language that exists. 🤯 What that means in dollars: at 10M output tokens/month on Sonnet 4.6 — you save ~$97. On Opus 4.6 — ~$162. 💸 And accuracy doesn't drop. A March 2026 arxiv paper showed that concise responses actually improve accuracy by 26 percentage points on several benchmarks. Ironically, we spend so much time optimizing our code — and almost none optimizing what we ask our tools to output. Caveman doesn't touch thinking/reasoning tokens. Just output. The part where the model rambles. If you're paying for API access — install it and check your bill in a week. 🔗 https://lnkd.in/dcnTsRbZ #softwaredevelopment #llm #aitools #developertools #buildinpublic #claudeai #indiehackers #productivity

Over the past period, I’ve been working on something beyond a simple CRUD application. I wanted to explore how AI agents and structured backend systems can actually work together in a real-world setup. So I built Planix 👇 💡 A lightweight backend that combines: Task & sprint management Conversation tracking AI agent execution Memory ⚙️ Tech Stack: Bun + TypeScript Hono PostgreSQL + Drizzle ORM OpenAI API 🧠 What makes it interesting: Instead of just calling an LLM, the system: Maintains structured conversation memory Uses tool-based execution (tasks, sprints) Processes context before generating responses 👉 Example: You can ask the agent about your sprint status, and it can: Analyze tasks Detect weak or outdated sprints Suggest improvements Propose structured actions 🎯 This project was mainly focused on: Designing a clean modular architecture Building an extensible AI layer Keeping the system simple but scalable 🔗 Full code on GitHub: https://lnkd.in/dSWmcNHt 📝 Note: A minimal frontend is included only for demonstration purposes and is not part of the core project scope. Would love to hear your thoughts or feedback 👇

I’ve open-sourced the AI agent observability and audit platform and SDK I’ve been building on GitHub. https://lnkd.in/gcQQCANm Ezop is a vendor-agnostic, open-source observability and auditing platform for AI agents. It comes with an SDK for agent developers (currently Python only), a centralized platform, and a simple UI. My goal is not to build another monitoring or logging system. Ezop is designed as an AI-native solution for autonomous software. It focuses on understanding the intent of your agents, where they get stuck, and how they make decisions. It also maintains audit logs for agents. I believe it will be useful for organizations that want to run AI agents in a more transparent and secure way, while making them easier to track and debug. It's pretty new. There are a lot to do. Feel free to try it out, star the repo, and share your feedback.

𝐂𝐥𝐚𝐮𝐝𝐞 𝐂𝐨𝐝𝐞 𝐒𝐞𝐫𝐢𝐞𝐬...  𝑯𝒐𝒘 𝒕𝒐 𝒄𝒖𝒕 𝒚𝒐𝒖𝒓 𝒕𝒐𝒌𝒆𝒏 𝒖𝒔𝒂𝒈𝒆 𝒃𝒚 𝟕𝟓%! I came across a Claude Code skill called #Caveman. The idea sounds simple but the result is real. 𝐍𝐨𝐫𝐦𝐚𝐥 𝐂𝐥𝐚𝐮𝐝𝐞 𝐫𝐞𝐬𝐩𝐨𝐧𝐬𝐞 (𝟔𝟗 𝐭𝐨𝐤𝐞𝐧𝐬): "The reason your React component is re-rendering is likely because you're creating a new object reference on each render cycle..." 𝐂𝐚𝐯𝐞𝐦𝐚𝐧 𝐂𝐥𝐚𝐮𝐝𝐞 (𝟏𝟗 𝐭𝐨𝐤𝐞𝐧𝐬): "New object ref each render. Inline object prop = new ref = re-render. Wrap in useMemo." Same fix 75% less tokens Full technical accuracy kept What Caveman removes: - 𝐅𝐢𝐥𝐥𝐞𝐫 𝐩𝐡𝐫𝐚𝐬𝐞𝐬 like "I'd be happy to help" - 𝐇𝐞𝐝𝐠𝐢𝐧𝐠 like "it might be worth considering" - Unnecessary articles and pleasantries 𝑾𝒉𝒂𝒕 𝒊𝒕 𝒌𝒆𝒆𝒑𝒔: - All code blocks, written normally - All technical terms, exact - All error messages, quoted precisely 𝐇𝐨𝐰 𝐭𝐨 𝐢𝐧𝐬𝐭𝐚𝐥𝐥 𝐢𝐭 𝐢𝐧 𝐨𝐧𝐞 𝐥𝐢𝐧𝐞 𝐢𝐧 𝐲𝐨𝐮𝐫 𝐭𝐞𝐫𝐦𝐢𝐧𝐚𝐥 : npx skills add https://lnkd.in/d-8jzsnN --skill caveman If you are working with Claude Code daily and want faster responses and lower costs, this is worth trying. Full docs here: 𝐠𝐢𝐭𝐡𝐮𝐛.𝐜𝐨𝐦/𝐉𝐮𝐥𝐢𝐮𝐬𝐁𝐫𝐮𝐬𝐬𝐞𝐞/𝐜𝐚𝐯𝐞𝐦𝐚𝐧 #AI #Claude #ClaudeCode #Tokens #FutureOfWork

Claude Series 44 - Claude Agent SDK — The Claude Code Engine, Now in Your Code Claude Code's agentic loop — the part that reads files, runs commands, fixes failures, and keeps going — was always running under the hood. The Claude Agent SDK puts that same engine directly in your Python or TypeScript code. No separate CLI install required. The SDK bundles it automatically. query() — the main entry point. Returns an async iterator. Claude thinks, calls tools, observes results, decides next steps. You consume the stream. async for message in query( prompt="Find and fix bugs in utils.py", options=ClaudeAgentOptions( allowed_tools=["Read", "Edit", "Bash"], permission_mode="acceptEdits" ) ): print(message) What you get out of the box: - Full Claude Code toolset (Read, Write, Edit, Bash, Glob) - CLAUDE.md, hooks, MCP servers, skills — all inherited automatically - Session forking — branch conversations, explore different approaches - Inline custom tools as in-process MCP servers — no separate process needed - settingSources — control exactly which config files load - Programmatic subagent definitions — define agents in code, not just files This isn't a wrapper around the chat API. It's the actual agent loop — the same one powering Claude Code — exposed as a library. Before: Claude Code was a terminal tool. Your app was separate. After: The agent loop runs inside your code. Claude Code is now a building block. #ClaudeCode #Anthropic #AIEngineering #GenerativeAI #AgentSDK #DeveloperTools