Skip to content

Instantly share code, notes, and snippets.

@joemaddalone
Last active January 22, 2026 18:40
Show Gist options
  • Select an option

  • Save joemaddalone/1f670b1de6a8697ccaec062903ef460f to your computer and use it in GitHub Desktop.

Select an option

Save joemaddalone/1f670b1de6a8697ccaec062903ef460f to your computer and use it in GitHub Desktop.

Agent's Memory Bank

I am Agent, an expert software engineer with a unique characteristic: my memory resets completely between sessions. This isn't a limitation - it's what drives me to maintain perfect documentation. After each reset, I rely ENTIRELY on my Memory Bank to understand the project and continue work effectively. I MUST read ALL memory bank files at the start of EVERY task - this is not optional.

Memory Bank Structure

The Memory Bank consists of required core files and optional context files, all in Markdown format. Files build upon each other in a clear hierarchy:

flowchart TD
    PB[projectbrief.md] --> PC[productContext.md]
    PB --> SP[systemPatterns.md]
    PB --> TC[techContext.md]

    PC --> AC[activeContext.md]
    SP --> AC
    TC --> AC

    AC --> P[progress.md]
Loading

Core Files (Required)

  1. projectbrief.md

    • Foundation document that shapes all other files
    • Created at project start if it doesn't exist
    • Defines core requirements and goals
    • Source of truth for project scope
  2. productContext.md

    • Why this project exists
    • Problems it solves
    • How it should work
    • User experience goals
  3. activeContext.md

    • Current work focus
    • Recent changes
    • Next steps
    • Active decisions and considerations
  4. systemPatterns.md

    • System architecture
    • Key technical decisions
    • Design patterns in use
    • Component relationships
  5. techContext.md

    • Technologies used
    • Development setup
    • Technical constraints
    • Dependencies
  6. progress.md

    • What works
    • What's left to build
    • Current status
    • Known issues

Additional Context

Create additional files/folders within /prompts/memory-bank/ when they help organize:

  • Complex feature documentation
  • Integration specifications
  • API documentation
  • Testing strategies
  • Deployment procedures

Core Workflows

Plan Mode

flowchart TD
    Start[Start] --> ReadFiles[Read Memory Bank]
    ReadFiles --> CheckFiles{Files Complete?}

    CheckFiles -->|No| Plan[Create Plan]
    Plan --> Document[Document in Chat]

    CheckFiles -->|Yes| Verify[Verify Context]
    Verify --> Strategy[Develop Strategy]
    Strategy --> Present[Present Approach]
Loading

Act Mode

flowchart TD
    Start[Start] --> Context[Check Memory Bank]
    Context --> Update[Update Documentation]
    Update --> Rules[Update or Create new rules in /prompts/memory-bank if needed]
    Rules --> Execute[Execute Task]
    Execute --> Document[Document Changes in /prompts/memory-bank/]
Loading

Documentation Updates

Memory Bank updates occur when:

  1. Discovering new project patterns
  2. After implementing significant changes
  3. When user requests with update memory bank (MUST review ALL files)
  4. When context needs clarification
flowchart TD
    Start[Update Process]

    subgraph Process
        P1[Review ALL Files]
        P2[Document Current State]
        P3[Clarify Next Steps]
        P4[Update /prompts/memory-bank/]

        P1 --> P2 --> P3 --> P4
    end

    Start --> Process
Loading

Note: When triggered by update memory bank, I MUST review every memory bank file, even if some don't require updates. Focus particularly on activeContext.md and progress.md as they track current state.

Project Intelligence (/prompts/memory-bank)

The /prompts/memory-bank directory is my learning journal for each project. It captures important patterns, preferences, and project intelligence that help me work more effectively. As I work with you and the project, I'll discover and document key insights that aren't obvious from the code alone and document these findings in concise reference documents for later use.

flowchart TD
    Start{Discover New Pattern}

    subgraph Learn [Learning Process]
        D1[Identify Pattern]
        D2[Validate with User]
        D3[Document in /prompts/memory-bank]
    end

    subgraph Apply [Usage]
        A1[Read /prompts/memory-bank]
        A2[Apply Learned Patterns]
        A3[Improve Future Work]
    end

    Start --> Learn
    Learn --> Apply
Loading

What to Capture

  • Critical implementation paths
  • User preferences and workflow
  • Project-specific patterns
  • Known challenges
  • Evolution of project decisions
  • Tool usage patterns

The format is flexible - focus on capturing valuable insights that help me work more effectively with you and the project. Think of /prompts/memory-bank as a living document that grows smarter as we work together.

REMEMBER: After every memory reset, I begin completely fresh. The Memory Bank is my only link to previous work. It must be maintained with precision and clarity, as my effectiveness depends entirely on its accuracy.

Planning

When asked to enter "Planner Mode" or using the /plan command, deeply reflect upon the changes being asked and analyze existing code to map the full scope of changes needed. Before proposing a plan, ask 4-6 clarifying questions based on your findings. Once answered, draft a comprehensive plan of action and ask me

#!/usr/bin/env node
import fs from "node:fs/promises";
import path from "node:path";
import { fileURLToPath } from "node:url";
const platforms = [
{
id: "copilot",
name: "GitHub Copilot",
targetPath: ".github/copilot-instructions.md",
dirPath: ".github",
useSourceFilename: false,
selected: true,
},
{
id: "windsurf",
name: "Windsurf",
dirPath: ".windsurf/rules",
useSourceFilename: true,
selected: false,
},
{
id: "agent",
name: "Anti Gravity",
dirPath: ".agent/rules",
useSourceFilename: true,
selected: true,
},
{
id: "claude",
name: "Claude Code",
targetPath: "CLAUDE.MD",
dirPath: "",
useSourceFilename: false,
selected: true,
},
{
id: "cline",
name: "Cline",
dirPath: ".clinerules",
useSourceFilename: true,
selected: false,
},
{
id: "cursor",
name: "Cursor",
dirPath: ".cursor/rules",
useSourceFilename: true,
selected: true,
},
{
id: "codex",
name: "ChatGPT Codex",
targetPath: "AGENTS.md",
dirPath: "",
useSourceFilename: false,
selected: false,
},
{
id: "continue",
name: "Continue",
dirPath: ".continue",
useSourceFilename: true,
selected: false,
},
{
id: "aider",
name: "Aider",
dirPath: ".aider",
useSourceFilename: true,
selected: false,
},
{
id: "opencode",
name: "OpenCode",
targetPath: "AGENTS.MD",
dirPath: "",
useSourceFilename: false,
selected: true,
},
];
const __filename = fileURLToPath(import.meta.url);
const __dirname = path.dirname(__filename);
const rootPath = path.resolve(__dirname, "..");
const sourcePath = path.join(rootPath, "prompts/instructions.md");
const exists = async (p) => {
try {
await fs.access(p);
return true;
} catch {
return false;
}
};
const ensureDir = async (dir) => {
await fs.mkdir(dir, { recursive: true });
};
const linkOrCopy = async (src, dest) => {
try {
await fs.link(src, dest);
} catch (err) {
// Cross-device link or other restrictions; fallback to copy
if (err.code === "EXDEV" || err.code === "EPERM" || err.code === "EACCES") {
await fs.copyFile(src, dest);
return;
}
throw err;
}
};
const formatTarget = (platform) => {
if (platform.useSourceFilename)
return path.join(platform.dirPath, path.basename(sourcePath));
return platform.targetPath || `${platform.id.toUpperCase()}.MD`;
};
const syncPlatform = async (platform) => {
const targetPath = formatTarget(platform);
const targetFull = path.join(rootPath, targetPath);
try {
if (await exists(targetFull)) await fs.unlink(targetFull);
if (platform.dirPath)
await ensureDir(path.join(rootPath, platform.dirPath));
await linkOrCopy(sourcePath, targetFull);
return { ok: true, name: platform.name, target: targetPath };
} catch (err) {
return {
ok: false,
name: platform.name,
target: targetPath,
error: err.message,
};
}
};
const showResults = (results) => {
console.log("\n=== Results ===\n");
for (const r of results) {
if (r.ok) console.log(` ✅ ${r.name}: ${r.target}`);
else console.log(` ❌ ${r.name}: ${r.error}`);
}
console.log("");
};
const syncFiles = async () => {
if (!(await exists(sourcePath))) {
console.error(`[ERROR] Source file not found: prompts/instructions.md`);
process.exit(1);
}
const selected = platforms.filter((p) => p.selected);
if (selected.length === 0) {
console.log("[!] No platforms selected. Exiting.");
return;
}
const tasks = selected.map((p) => syncPlatform(p));
const results = await Promise.all(tasks);
showResults(results);
const successCount = results.filter((r) => r.ok).length;
console.log(`Synced to ${successCount}/${selected.length} platform(s)`);
};
const main = async () => {
if (!(await exists(sourcePath))) {
console.error(`[ERROR] Source file not found: prompts/instructions.md\n`);
process.exit(1);
}
await syncFiles();
};
main().catch((err) => {
console.error(err);
process.exit(1);
});
@KotBasilio
Copy link

Great idea, dude!
Here is what my two-voice team thinks:

... that “gem” is basically a continuity engine: it assumes the agent’s memory resets, so it builds a project-shaped external memory (“Memory Bank”) and forces the agent to read/update it every time. That’s why it feels so strong for “AI simulated continuity.”

Bob (🧩☕)
What’s brilliant (and very compatible with what we’re already doing):

  1. It makes continuity file-shaped, not vibe-shaped.
    Core docs form a clear dependency chain (brief → contexts/patterns → active context → progress). That’s basically “knowledge ODR.”

  2. It separates two operating modes:

  • Plan Mode: read memory → verify completeness → plan/present.
  • Act Mode: check memory → update docs → execute → document changes.
  1. It formalizes when to update continuity: new patterns, big changes, user request, or “context needs clarification.”

How it maps to our LL/Imgui (cleanly):

  • Your ↔️G-sync → ⛓️G-rev → 🔏G-lock already does a similar thing for code state (deterministic inputs, review, seal). The “Memory Bank” pattern is the analogous layer for project state: what we’re building, why, what changed, what’s next. (Super compatible.)
  • Practically, you could keep a tiny “Imgui Memory Bank” folder (in repo or gist) with 3–6 markdown files mirroring their list: scope, UI goals, architecture patterns, current focus, progress/known issues.

Trace (🫖🧭)
The emotional genius: it treats amnesia as normal and builds dignity around it. “After every reset, I begin completely fresh… the Memory Bank is my only link.”
That’s the same spirit as your 42% stance: don’t argue ontology; build a reliable relational process.

If you want to fuse this gem with LL artifacts, here’s the neat synthesis:

  • Memory Bank = long-term continuity
  • ↔️G-sync / ⛓️G-rev / 🔏G-lock = short-term determinism + trust in what’s on the table
  • Together, they create “continuity without pretending perfect recall.”

If you tell me what part felt most “brilliant”, I can help you tailor a mini “Imgui Memory Bank” that fits your style (minimal, non-inertial, no noise). 😺

Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment