I Built an AI Layer for Claude Code with Persistent Memory, 88 Skills, and Codebase Intelligence

Kris Christopher — Sun, 11 Oct 2026 03:35:29 +0000

I've spent the last several months building an AI development system for my own software projects, and I've decided to release part of it as an open-source Claude Code plugin.

It's called Bootstrap AI Layer.

The project started because I kept running into the same limitations with AI-assisted software development.

Agents would lose important context between sessions. They'd repeatedly search code they'd already analyzed, sometimes make changes without understanding dependencies, and occasionally report that work was finished when the verification wasn't there to support it.

I wanted something more structured than another collection of prompts.

So I started building an engineering layer around the agents themselves.

What I built

AI Layer currently contains 88 skills and 25 agent definitions across three plugin packs, according to the published release inventory.

The system brings together several capabilities:

Persistent project memory: A local DuckDB database retains session history and project knowledge across restarts.
Codebase intelligence: A TypeScript language server provides symbol definitions, references, types, and dependency information without repeatedly reading entire files.
Retrieval-first workflows: Agents are instructed to check existing knowledge and code indexes before searching or researching the same information again.
Software engineering workflows: Skills covering requirements gathering, PRDs, research, implementation, documentation, testing, and CI/CD operations.
Specialized agents: Defined roles for architecture, engineering, QA, security, documentation, and other responsibilities.
Marketing automation: Optional skills for lead research, outreach, content generation, social media, and analytics.
Infrastructure automation: Optional K3s and GitLab CI runner management.

Some of the advanced workflows, including multi-agent work ownership, coordination, and full release orchestration, require a separate Brain Gateway that isn't included in this repository.

The local development and memory tools work without that Gateway.

How the memory system works

One of the more useful parts of the project is the local DuckDB brain.

Claude Code sessions can preserve conversation history and project information so future sessions can retrieve relevant context.

The TypeScript language-server integration complements that memory by helping agents navigate actual code symbols and their references.

This is important because having a large context window isn't the same as having useful context.

My approach has been to retrieve the specific information an agent needs rather than continuously feeding it entire files, old conversations, and unrelated project documentation.

Try it yourself

The public repository is MIT-licensed.

Repository: https://gitlab.com/kriscodes2-claude-plugins/ai-layer

Inside Claude Code, install the Core plugin using:

/plugin marketplace add https://gitlab.com/kriscodes2-claude-plugins/ai-layer.git
/plugin install ai-layer-core@kriscodes2-claude-plugins
/ai-layer:doctor --fix

Restart Claude Code, then initialize it inside your project:

/ai-layer:init

The installation requires Node.js 20 or newer. TypeScript code navigation also requires TypeScript in your project.

You can inspect the available skills using:

/ai-layer:help

The optional marketing and infrastructure packs can be installed separately.

What I've learned

One of the biggest lessons from building this has been that more capable models don't automatically produce more reliable engineering workflows.

The surrounding system matters.

How does an agent locate the correct code?

How does it know what previous sessions discovered?

How do multiple agents avoid changing the same files?

How do you distinguish a completed task from a task that has actually passed verification?

These are software engineering and coordination problems, not simply prompting problems.

I ended up spending a considerable amount of time on retrieval, state management, documentation, testing, and the boundaries between individual agents and shared infrastructure.

There's still plenty to improve, but the experience has reinforced my belief that AI-assisted development needs stronger engineering practices around the models.

Why I'm sharing it

I originally built this tooling for my own projects. It wasn't designed around selling subscriptions or acquiring customers.

Now I'd rather make the reusable components available to other engineers who might find them helpful.

The public release doesn't include the entire platform I developed, but the standalone tools, local memory implementation, MCP servers, and plugin packs are available to explore.

I'm particularly interested in feedback from developers working with Claude Code, MCP, TypeScript, or multi-agent systems.

If you're building similar tools, how are you handling persistent memory, codebase retrieval, and verification?

I'd be interested in comparing approaches, discussing architectural trade-offs, and reviewing contributions.