The Context Crisis: Why Your AI Coding Assistant Keeps Forgetting Everything

If you've spent any time working with AI coding agents lately, you've probably developed your own personal bag of tricks for keeping them from going off the rails. Maybe it's a carefully maintained memory file. Maybe it'sCLAUDE.md orAGENTS.md files scattered throughout your repositories. Maybe you've even started using enterprise tools like Glean or Notion to try to create some semblance of organizational knowledge that your AI assistant can actually access.

The question is: why are we still doing this manually in 2025?

The Three-Layer Mess

Let's talk about what's actually happening in most engineering teams. You're likely dealing with context at three distinct levels:

Personal context lives in your head, your Slack DMs, and increasingly, your collection of MCP tools and personal markdown files. This is the stuff that's only relevant to you—your coding preferences, your pet peeves about variable naming, your specific workflow habits.

Repository-level context is supposed to be captured inCLAUDE.md, AGENTS.md, or similar files that live in the codebase itself. The idea is that anyone (or any AI) looking at the repo should understand the project conventions, architecture decisions, and coding standards.

Organization-wide context is the wild west. Some teams use tools like Glean, Notion, or custom wikis. Most just rely on tribal knowledge, scattered Confluence pages nobody maintains, and Slack threads that disappear after 90 days.

Here's the problem: these three layers are supposed to work together seamlessly, but in reality, they're barely holding hands.

Why Layer 3 Is the Neglected Stepchild

The Hacker News discussion that sparked this post highlighted something interesting: most of the conversation and tooling innovation is happening at layers 1 and 2. Developers are obsessed with perfecting their personal AI workflows and repo-level documentation. But layer 3—organizational context—remains surprisingly underdeveloped.

Why? Because it's genuinely hard. Organization-wide context involves:

• Multiple teams with different conventions
• Legacy decisions that nobody documented
• Knowledge spread across a dozen different tools
• The eternal problem of keeping documentation current

It's easier to optimize your personal setup or write a betterAGENTS.md file than to solve the fundamental problem of organizational memory. So we don't. We just keep patching layers 1 and 2 harder.

The Redundancy Illusion

Here's a tempting argument: "If I have perfect layers 1 and 2, why do I need layer 3 at all?"

This is seductive but dangerous. Personal context and repo context can patch some gaps, but they create a different problem: knowledge silos. When every developer has their own elaborate personal context system, you lose:

• Onboarding efficiency: New team members can't benefit from collective knowledge
• Consistency: Different devs get wildly different AI behavior
• Institutional memory: When someone leaves, their carefully crafted context files often leave with them

A strong layer 3 wouldn't replace layers 1 and 2—it would make them unnecessary for anything beyond personal preference. Your AI agent would already understand the organization's standards, the team's conventions, and the project history. Your personal files would just be... personal.

What a Real Solution Might Look Like

Imagine an AI coding assistant that naturally understands your organization's context without you having to explicitly feed it everything. That's not science fiction—it's what good context plumbing should provide.

At NameOcean, we've been thinking about this problem through the lens of what we call "vibe hosting"—the idea that your development environment should understand you and your project naturally, reducing the friction between intent and execution.

Some approaches worth exploring:

1. Semantic code search that understands your codebase's architecture, not just keywords
2. Decision logs that capture why things were built a certain way, automatically
3. Living documentation that updates itself based on actual code changes
4. Cross-repository context that connects related projects and shared libraries

The tools exist. The question is whether we'll actually invest in building the infrastructure that makes them work together.

The Real Question

Here's what I keep coming back to: we're spending enormous energy making AI agents useful by manually managing context, when the whole point of AI is that it should understand context naturally.

Maybe the answer isn't betterAGENTS.md files. Maybe it's rethinking how we capture and share knowledge at the organizational level—so that AI agents can actually access the context they need, when they need it, without every developer having to become a context management expert.

Until then, we'll keep duct-taping our three-layer messes together. But I suspect the teams that crack layer 3 are going to have a significant advantage.

What's your context plumbing setup look like? Are you a minimalist who keeps it all in your head, or do you have elaborate documentation systems? Drop your thoughts below—we're genuinely curious how other developers are solving (or not solving) this problem.