v0.1.0 · Go CLI · AI Powered

DevMem

developers memory

Auto codebase documentation. Change capture on every commit.
Changelog management tied to git. Because your memory has limits - DevMem doesn't.

Get started → go install github.com/Surya-sourav/devmem@latest

PROBLEM

Developers have a context window too.
And it's getting smaller.

Modern software grows fast. AI-assisted development grows faster. Every pull request, every AI-generated function, every refactor adds layers that no single engineer can hold in their head. The codebase your team wrote six months ago is already a foreign country.

The rise of AI coding tools makes this worse, not better. AI slop - code generated quickly, merged faster, understood by no one - accumulates silently. Without a system that captures what changed, why it changed, and how it fits into the whole, your codebase becomes archaeology.

Documentation written once is documentation that lies. The only documentation that stays true is documentation written at the moment of every change - automatically, tied to the commit that caused it.

SOLUTION

One command. Living documentation.
Version-controlled, always accurate.

"It's like version controlling your documentation throughout your code - one arrow, two solutions."

DevMem watches your git commits and automatically updates your architectural documentation, your module docs, and your changelog - every time. It uses AI to understand what changed and why, then writes it down so your future self (and your team) actually has a chance.

HOW IT WORKS

Three commands. Complete memory.

devmem init

Crawl & Document

DevMem crawls your entire codebase, detects module boundaries, and generates architectural documentation for every module in parallel - using AI to understand structure, not just list files.

devmem capture

Capture Every Change

On every git commit, DevMem reads the diff, identifies which modules changed, and surgically updates their documentation. A changelog entry is written with the commit hash as its ID - permanently linking code history to documentation history.

devmem query "..."

Ask Your Codebase

Ask natural language questions grounded in your living documentation. Which modules depend on the database? How does authentication work? What changed in the last sprint? DevMem answers from context, not hallucination.

devmem - zsh

$ devmem init

  Crawling codebase...           done  (312 files, 0.1s)
  Detecting modules...           found 7 candidates

  Detected modules:
    auth       src/auth/         (score: 7)
    api        src/api/          (score: 6)
    db         internal/db/      (score: 5)
    worker     internal/worker/  (score: 4)
    config     pkg/config/       (score: 3)

  Confirm? [Y/n]: Y

  Analysing modules (7 total, max 5 parallel)...
    [1/7] auth      ✓ done  (1.2s)
    [3/7] api       ✓ done  (1.4s)
    [2/7] db        ✓ done  (1.8s)
    [5/7] config    ✓ done  (0.9s)
    [4/7] worker    ✓ done  (2.1s)

  Generating master architecture...  ✓ done  (2.3s)

  devmem initialised. 7 modules documented.

REAL OUTPUT

From init to query, captured in your repo.

DevMem Root Directory Snapshot

After running init and capture, documentation artifacts live under .devmem with modules, changelog, state, config, and architecture files.

DevMem root directory showing .devmem docs, modules, changelog, state, and config files

Query Mode Example

Query responses are grounded in live module docs and architecture context, so answers stay aligned with your current codebase.

devmem query - zsh

$ devmem query "can you explain me the cmd module ?"

## Purpose
The cmd module implements the main CLI interface, providing various commands that users can run to interact with the DevMem system.

## Available Commands
- root command
- capture command
- init command
- query command
- status command

## Key Files
- capture.go
- init.go
- query.go
- root.go
- status.go

## Dependencies
- ai
- crawler
- state

## Technical Notes
The module follows the Cobra CLI pattern with each command in separate files. capture.go and init.go contain the most complex workflows for change capture and initialization.

WHY DEVMEM

Built for how developers actually work.

Language agnostic

Works on any codebase - Go, TypeScript, Python, Rust, Ruby. DevMem reads structure and git history, not syntax trees.

Parallel analysis

Module documentation is generated concurrently. A 20-module codebase takes the same time as a 3-module one.

Git-native changelog

Every changelog entry ID is a commit hash. Documentation history and code history are permanently linked - no drift, no orphans.

Surgical updates

On capture, only the sections that changed are rewritten. Unchanged documentation is never touched - no noise, no false diffs.

Offline first

Your documentation lives in .devmem/ inside your repo. It is git-tracked, diffable, and readable without any external service.

Ask your codebase

The query command gives every developer on your team an AI answer grounded in real, current documentation - not hallucinated from training data.

Start in 30 seconds.

Step 1

go install github.com/Surya-sourav/devmem@latest

Step 2

devmem help

Step 3

cd your-project && devmem init

Requires Go 1.21+ · macOS, Linux, Windows · Anthropic API key