Building structured knowledge in codebases

Turn your entire codebase into a queryable knowledge graph! Graphify is an AI coding assistant skill that maps your entire project into a knowledge graph you can query. Works with Claude Code, Codex, Cursor, Gemini CLI, OpenCode, and 20+ more coding agents. Type "/graphify ." and it processes everything in your project. Code across 36 languages, SQL schemas, shell scripts, docs, PDFs, images, and videos, all mapped into one graph. Processing happens locally, no API needed for code. The output is three files. An interactive HTML visualization you can open in a browser. A Markdown report with key concepts, surprising connections, and suggested questions. And a JSON graph you can query directly. Instead of grepping through files or hoping your AI finds the right context, you query the graph. "What connects auth to the database?" "Find the path between UserService and DatabasePool." The graph answers precisely because it has the full picture, not just what's in the context window. Builds a Git hook for auto-rebuild on every commit so the graph stays current as the codebase changes. Pushes to Neo4j for team sharing via MCP server. Generates a PR dashboard showing graph impact before merge. Key capabilities: • Maps code, docs, PDFs, images, and videos into one knowledge graph • 36 languages via tree-sitter, processed locally • Works with Claude Code, Codex, Cursor, Gemini CLI, OpenCode, and 20+ agents • Query the graph instead of grepping through files • Auto-rebuild on commit via Git hook • Neo4j and FalkorDB integration for team sharing • PR dashboard with graph impact analysis 100% open source. I've shared the link in the replies! _____ ♻️ Share this with your network if you found this insightful ➕ If you’re into ML, LLMs, and AI agents, join AI Engineering (it’s free): https://lnkd.in/gfkzKZYk

After 2,000+ hours using Claude Code across real production codebases, I can tell you the thing that separates reliable from unreliable isn't the model, the prompt, or even the task complexity. It's context management. About 80% of the coding agent failures I see trace back to poor context - either too much noise, the wrong information loaded at the wrong time, or context that's drifted from the actual state of the codebase. Even with a 1M token window, Chroma's research shows that performance degrades as context grows. More tokens is not always better. I built the WISC framework (inspired by Anthropic's research) to handle this systematically. Four strategy areas: W - Write (externalize your agent's memory) - Git log as long-term memory with standardized commit messages - Plan in one session, implement in a fresh one - Progress files and handoffs for cross-session state I - Isolate (keep your main context clean) - Subagents for research (90.2% improvement per Anthropic's data) - Scout pattern to preview docs before committing them to main context S - Select (just in time, not just in case) - Global rules (always loaded) - On-demand context for specific code areas - Skills with progressive disclosure - Prime commands for live codebase exploration C - Compress (only when you have to) - Handoffs for custom session summaries - /compact with targeted summarization instructions These work on any codebase. Not just greenfield side projects! I've applied this on enterprise codebases spanning multiple repositories, and the reliability improvement is consistent. I also just published a YouTube video going over the WISC framework in a lot more detail. Very value packed! Check it out here: https://lnkd.in/ggxxepik

There’s no shortage of “AI coding tools” out there. Most can autocomplete a function, suggest a snippet, or even generate a CRUD app. But few — very few — actually understand your system. Over the last week, I’ve been experimenting with Qoder — an Agentic Coding Platform that moves beyond code generation to system-level reasoning. And I have to say, it genuinely feels like the next step in how AI and developers will collaborate. What makes Qoder different While most tools assist line-by-line, Qoder operates at the architectural level. It becomes aware of your entire codebase, your repository structure, and the relationships between components. It doesn’t just “generate.” It analyzes, reasons, and orchestrates. Here’s what stood out for me: Conversational Pair Programming — you can discuss design decisions, not just syntax. Repo Wiki — Qoder automatically documents architecture, data flow, and APIs — keeping knowledge in sync with code. Quest Mode — lets it autonomously complete long-running engineering tasks with traceable reasoning steps. Codebase Awareness — it understands the context of your system and ensures every new file fits perfectly. What I built with it To test it, I built a Smart Email Orchestrator Agent — from scratch. I started with a simple scaffold, connected it to Qoder, and watched it come alive: It created missing modules and test files Fixed broken imports Generated a structured Repo Wiki And even prepared the deployment configuration It was the first time I’ve seen an AI tool think like an engineer — aware of dependencies, architecture, and flow. Why this matters This is what Agentic Coding really means. We’re entering an era where developers won’t just “prompt” models — they’ll collaborate with intelligent systems that reason, design, and execute. The value isn’t in speed. It’s in understanding — in how these systems maintain architectural integrity and engineering quality at scale. If you’re building with AI, take a moment to explore https://lnkd.in/dC3fPTTP. This isn’t another code generator — it’s a glimpse into the future of how real software will be built.

We've been running an AI agent called Iris inside our engineering team for months. It writes code, files PRs, reviews its teammates' work. Real people depend on it daily, including me. One of the biggest things building Iris taught us: agents consume knowledge completely differently than humans. When we watched external coding agents try to use our documentation, same thing happened. They'd pull in entire pages of prose, lose context halfway through, produce code that mixed conventions from three different versions. Our docs weren't bad. They were just written for humans who read linearly. Agents need structure. Pattern, constraints, what to avoid. Less tutorial, more contract. That insight reshaped how we build our developer platform. So we started designing for machine consumption first. Not tutorials repackaged for machines. A different artifact entirely. Skills are structured instruction packs. They activate based on what you're building. Project scaffolding, agent design, task design, live docs access. Your coding agent picks up CrewAI conventions immediately. No re-explaining the framework every session. - npx skills add crewaiinc/skills - llms.txt is our entire documentation in a single machine-readable file. One fetch. No scraping, no HTML parsing, no stale cache. - AGENTS.md ships with every new CrewAI project. Your coding agent reads it first and already knows how the codebase is structured. No more "how is this project organized?" five times per session. - crewai deploy takes your local crew to a live REST endpoint in minutes. Build to production in one AI coding session. We learned from Iris that agents get better when knowledge is structured, permanent, and testable. Same principle applies to every developer platform. The ones that figure this out first will have agents choosing to build on them. skills.crewai.com

AGENTS.md is the new "just add more comments." A lazy solution everyone adopted because no one questioned it. Every AI coding agent reads from a single flat file. AGENTS.md. CLAUDE.md. CURSOR.md. One file for your entire codebase. As the project grows, that file becomes a graveyard. Design decisions buried under 500 lines of stale context. Architecture notes mixed with test commands. No links between concepts. The agent reads the whole thing. Understands maybe 30% of it. Hallucinates the rest. Lat.md fixes this with a fundamentally different approach. Instead of one file, you get a knowledge graph. A lat.md/ directory at your project root with interconnected markdown files linked by wiki-style references. Here's what that looks like: 1) Architecture lives in architecture.md - Design decisions, system boundaries, key tradeoffs - Links to related files: [[auth#OAuth Flow]], [[tests#Integration Specs]] 2) Code links back to knowledge - Inline comments like // @lat: [[auth#OAuth Flow]] tie implementation to concepts - Agents trace from code to context without grepping blindly 3) The CLI keeps it honest - lat check validates every link and code reference - lat search runs semantic queries across the graph - lat section navigates from concept to concept 4) Test specs enforce themselves - Sections with require-code-mention: true must be referenced by actual test code - lat check catches the gap automatically The real insight here is not the tooling. It's that agents don't need more context. They need structured context. A graph they can traverse instead of a wall of text they have to parse. Knowledge from past sessions persists. Design decisions stay connected to the code that implements them. Coverage gets enforced without manual review. One npm install. Link in the comments. I'm Shrey Shah & I teach AI assisted coding and agents.

CLAUDE dot md files don't scale beyond modest codebases. If you're building serious software with Claude Code or any agentic tool, a single AGENTS dot md will eventually fail you. This paper shows what comes next. A 1,000-line prototype can be fully described in a single prompt. A 100,000-line system cannot. The AI must be told, repeatedly and reliably, how the project works, what patterns to follow, and what mistakes to avoid. Single-file manifests hit a ceiling fast. This new paper, Codified Context, documents a three-tier infrastructure built during real development of a 108,000-line C# distributed system across 283 sessions over 70 days. The system uses a three-tier memory architecture: a hot-memory constitution (660 lines, always loaded), 19 specialized domain-expert agents (9,300 lines total) invoked per task, and a cold-memory knowledge base of 34 specification documents (~16,250 lines) queried on demand via an MCP retrieval server. Across 283 sessions, this produced 2,801 human prompts, 1,197 agent invocations, and 16,522 autonomous agent turns, roughly 6 autonomous turns per human prompt, with a knowledge-to-code ratio of 24.2%. Crucially, none of it was designed upfront: each new agent and specification emerged from a real failure, a recurring bug, an architectural mistake, a convention forgotten, and was codified so it could never require re-explanation again, turning documentation into load-bearing infrastructure that agents depend on as memory, not reference.

An `AGENTS.md` (or equivilant) has the highest configuration point for agents. It's injected into every conversation. But research shows that doing it wrong actively hurts performance. Here's how to do it right, backed by data ## Less Is More - Auto-generated AGENTS.md reduce success rates by ~3% while increasing inference cost by over 20% - Human-written AGENTS.md only marginally improve performance (~4%) - Stronger models don't generate better context files. - Codebase overviews in AGENTS.md don't help agents navigate faster. - LLM-generated files are redundant with existing docs. - Instructions ARE followed. Agents respect AGENTS.md instructions, but unnecessary requirements make tasks harder. ## What to Include - The WHAT: Your tech stack, project structure, and what each part does. Critical for monorepos. - The WHY: The purpose of the project and its key components. Help the agent understand intent, not just structure. - The HOW: How to build, test, and verify changes. Include non-obvious tooling (e.g., `uv` instead of `pip`, `bun` instead of `npm`). Tools mentioned in AGENTS.md get used 160x more often than unmentioned ones. ## What NOT to Include - Detailed codebase overviews or directory listings. The paper found these don't help agents navigate faster, and agents can discover structure themselves. - Code style guidelines. Use linters and formatters instead, they're faster, cheaper, and deterministic. - Task-specific instructions that only apply sometimes. Since AGENTS.md goes into every session, non-universal instructions dilute focus. - Auto-generated content. Don't let the agent write its own AGENTS.md. The data shows this hurts more than it helps. ## How to Structure It - Keep it short. General consensus is <300 lines; HumanLayer keeps theirs under 60 lines. Every line goes into every session, make each one count. - Use progressive disclosure. Don't put everything in AGENTS.md. Instead, keep task-specific docs in separate files (e.g., `agent_docs/running_tests.md`, `agent_docs/database_schema.md`) and list them in AGENTS.md with brief descriptions so the agent reads them only when relevant. - Prefer pointers over copies. Reference `file:line` locations rather than embedding code snippets that will go stale. - Write it yourself, deliberately. A bad line in AGENTS.md cascades into bad plans, bad code, and bad results across every session. Paper: https://lnkd.in/dh7wqU2z Blog: https://lnkd.in/d6ih8DuM).

Someone built a tool that turns any codebase into an interactive knowledge graph you can explore, search, and ask questions about. It's called Understand Anything. Here's what actually happens when you run it => Six agents analyze your project in parallel. A knowledge graph gets built of every file, function, class, and dependency. An interactive dashboard opens, color-coded by architectural layer, fully searchable, every node clickable with plain-English explanations. Then you get => → /understand-chat - ask anything about the codebase in plain English → /understand-diff - see what your changes affect before committing → /understand-explain - deep dive into any specific file or function → /understand-onboard - generate an onboarding guide for new team members → /understand-domain - extract business domain knowledge as a horizontal graph → /understand-knowledge - analyze a wiki and surface implicit relationships as a navigable idea graph The persona-adaptive UI is a detail I hadn't seen before, the dashboard adjusts its detail level depending on whether you're a junior dev, PM, or power user. It supports multilingual output too. Run /understand --language zh and the entire dashboard generates in Chinese. It works with Claude Code, Cursor, Copilot, Gemini CLI, Codex, OpenCode, Vibe CLI, Cline, KIMI CLI. Here's the GitHub Repo: https://lnkd.in/gMSziJyr

We have been writing code to ingest unstructured PDFs, Confluence pages, and API docs; chopped them into arbitrary text chunks, generated high-dimensional vector embeddings, and executed cosine similarity at query time. For the past several years, the standard architecture for enterprise context injection followed a predictable blueprint augmenting LLMs with a vector database and building a RAG pipeline. This probabilistic approach sufficed for conversational search and informal discovery, but it rapidly collapses when applied to high-stakes, autonomous agentic operations: Structural Dissolution: Arbitrary chunking slices apart nested data schemas, complex multi-column tables, and multi-step conditional business logic. Probabilistic Unreliability: Vector retrieval relies on mathematical proximity rather than deterministic truth. An agent requesting a critical operational rule might retrieve an accurate chunk, or it might retrieve a stale, superseded, or contradictory fragment. Continuous Embedding Drift: Maintaining synchronized embeddings across constantly changing microservices, BigQuery schemas, and regulatory policies requires continuous, expensive re-indexing pipelines. Authority Blindness: Standard vector search treats all retrieved chunks as equally authoritative, lacking native mechanisms to distinguish between a draft Slack message and a machine-verified compliance directive. To address this systemic bottleneck, we at Google Cloud have open-sourced the Open Knowledge Format (OKF). OKF is not a cloud database, a proprietary framework, or an SDK. It is a vendor-neutral, portable open specification that formalizes the “LLM Wiki” paradigm—establishing a structured, interconnected knowledge brain originally conceptualized by AI researchers like Andrej Karpathy. OKF shifts enterprise strategy from probabilistic retrieval over unstructured text dumps to deterministic navigation across a living, human- and agent-readable knowledge graph. Let me know your thoughts in the comments section! and if you find it informative recycle this post to propogate this open, standards based initiative!

Building AI agents that can synthesize scattered knowledge like expert developers 🧠 I have a tutorial about building intelligent AI memory systems with Cognee in my 'Agents Towards Production' repo that solves a critical problem - developers navigate between documentation, community practices, and personal experience, but traditional approaches treat these as isolated resources. This tutorial shows how to build a unified knowledge graph that connects Python's design philosophy, real-world implementations from its creator, and your specific development patterns. The tutorial covers 3 key capabilities: - Knowledge Graph Construction: Building interconnected networks from Guido van Rossum's actual commits, PEP guidelines, and personal conversations - Temporal Analysis: Understanding how solutions evolved over time with time-aware queries - Dynamic Memory Layer: Inferring implicit rules and discovering non-obvious connections across knowledge domains The cross-domain discovery is particularly impressive - it connects your validation issues from January 2024 with Guido van Rossum's actual solutions from mypy and CPython. Rather than keyword matching, it understands semantic relationships between your type hinting challenges and historical solutions, even when terminology differs. Tech stack: - Cognee for knowledge graph construction - OpenAI GPT-4o-mini for entity extraction - Graph algorithms for pattern recognition - Vector embeddings for semantic search The system uses semantic graph traversal with deep relationship understanding for contextually aware responses. Includes working Python code, complete Jupyter notebook with interactive visualizations, and production-ready patterns. Part of the collection of practical guides for building production-ready AI systems. Direct link to the tutorial: https://lnkd.in/eSsjwbuh Ever wish you could query all your development knowledge as one unified intelligent system? ♻️ Repost to let your network learn about this too!