Atelier

Atelier is a memory layer for AI agents that connects codebases and conversations. It turns repositories into a 3D dependency graph and chat history into reusable context.

Comment

Inspiration

Atelier is inspired by the problems I've faced as a developer using AI tools. As developers, I think we've all been there, 30 messages deep into an AI conversation about refactoring your auth system, and suddenly the responses start drifting. The AI forgets what you decided 20 messages ago. You burn through credits repeating context. You wish you could just, you know, start fresh, but only with the good parts. Or maybe you're onboarding to a new codebase. Your AI assistant is trying to work on the database. Everythings going smooth until it doesn't. Just like with the chat, AI started to forget which functions were called where and what the name was. If a change was made which files cascade? What's the actual flow? You need a map, not a file tree. Atelier was born from these frustrations. I wondered what if developer tools felt less like utilities and more like exhibits: beautiful, explorable, designed to reveal insight at a glance?

What it does

Atelier is a developer tool that turns codebases and conversations into structured, reusable memory for AI systems. It helps developers understand unfamiliar codebases faster, navigate them visually, and carry architectural knowledge into AI-assisted workflows

  1. Chat Curator: Compress AI conversations into portable context.md files. Take a 50-message thread, extract only the decisions and key insights, edit out the noise, and export it. Drop that context into a fresh chat and pick up exactly where you left off, without burning credits on redundant history.
  2. Code Explorer: Simply connect your GitHub repository and see your entire codebase as an interactive 3D graph. Functions become nodes, calls become edges. -Zoom out to understand system architecture -Zoom in to trace execution paths -Rotate and explore dependencies spatiallyThink Google Earth for code.
  3. AI Context Bridge: Export that 3D graph as architecture.md; a structured markdown file mapping every function signature, call chain, and module relationship. Feed it to any AI (Claude, GPT, etc.) and suddenly the AI has X-ray vision into your codebase. No more hallucinated suggestions that break dependencies three modules away.

How I built it

GitHub Tree API to fetch and filter repository structure (200-file cap with proportional directory sampling)

Static analysis to resolve imports and build dependency graphs

Three.js + WebGL for real-time 3D visualization with custom shader-based edge rendering

Batched AI classification (Claude Sonnet) for chat segmentation and scoring

Regex-based normalization pipeline for fast, cost-free context compression

Used Claude Code to streamline development, designed and hand drew logo using Ibis and designed frontend using Figma

Challenges I ran into

  1. CORS + API Headers The Anthropic API requires custom headers (x-api-key, anthropic-version) that browsers block in CORS requests. I proxied through Vite's dev server (/api/claude → https://api.anthropic.com), forwarding headers server-side.
  2. GitHub Rate Limits Unauthenticated API calls cap at 60/hour. For 200-file repos, we'd hit that in one load. I implemented aggressive caching (localStorage for tree structure, 1-hour TTL) and batch file fetches (20 concurrent requests max).

Accomplishments that I'm proud of

Works with any AI system :outputs are simple, portable markdown

No second AI call needed: formatting and compression handled locally

Reduced context size from ~600 tokens to ~270 tokens while preserving key decisions

Built a system where AI behavior improves directly from better context

What I learned

Effective memory requires trade-offs between completeness and clarity

Not all conversation is valuable: identifying decisions vs noise is critical

Phrases like “I think” or “user decided” are filler in structured memory

Human intuition is good at spotting noise, but must be translated into consistent rules

What's next for Atelier

Persistent storage : IndexedDB cache for graph state (reload without re-fetching GitHub)

Collaborative curation: Teams can share and merge context.md files like code reviews

Smarter memory layering (short-term vs long-term context for AI workflows)

Built With

  • claudecode
  • figma
  • githubapi
  • ibispaintx
  • react
  • tailwind-css
  • three.js-(via-react-force-graph-3d)
  • vite
Share this project:

Updates