More screenshots

    Works with the AI Agents you already use

    Claude CodeClaude CodeCursorCursorCodex CLICodex CLIMuseMuseDotsDots+21 more

    Give Your Coding Agent a Memory

    1

    Three plain-text files that end agent amnesia — lessons from every correction, the project's facts and decisions, and a map of the codebase.

    $12

    Secure checkout via Stripe

    Money-back guarantee

    Converts to your local currency at checkout

    Security scanned

    Give Your Coding Agent a Memory

    Example session with this skill installed

    Add a lesson to the log: I just had to correct you for using arrow functions in the react components; we use standard function declarations here for consistency.

    • Read your context and instructions
    • Compiled the give your coding

    I have updated the lessons log to ensure this convention is followed in all future sessions. I will consult this rule before creating or refactoring any React components.

    Updated memory/lessons.md

    
    | Date | Incident | Rule |
    | :--- | :--- | :--- |
    | 2025-05-12 | Agent used arrow functions for React components | Always use standard function declarations for React components; arrow functions are for utilities only. |
    
    

    Next steps

    1. Commit the change to memory/lessons.md to persist this rule for future sessions.
    2. I will now scan the current workspace for any arrow-function components created this session to refactor them.
    3. Check memory/project.md to see if this naming convention should be elevated to a primary project rule.

    Connects securely to your tools. The creator never sees your data.

    About this skill

    A coding agent starts every session with amnesia. It forgets the correction you gave it yesterday, the convention you settled last week, and the layout of the codebase it worked in an hour ago — so it repeats mistakes and re-reads files, and you pay for both. This skill layers three kinds of memory onto any agent that can read and write files, using nothing but plain text stored in the project. No database, no service, no plugin. The product is not the files; it is the discipline — read before work, write after learning.

    Inside the package: the skill file with the three-layer design, the session routine, and the upkeep rules; memory file templates; and an example lessons log. Layer one is the lessons log: every time you correct the agent — a wrong assumption, a style violation, a broken convention — it appends one line before doing anything else: the date, what went wrong, and the rule to follow next time. Layer two is the project file: what the project is in three sentences, architecture decisions with the reason for each (a decision recorded without its reason will be re-argued by a future session), the conventions actually in force, how to run and deploy it, and the open threads left mid-flight. Layer three is a codebase map: each module, its responsibility, its entry points, and where the important types, routes, and jobs are defined — structure, not content, so the agent stops re-reading the whole repo to remember where things are.

    A run is really a routine. Start of session, before any code: read the lessons log in full and apply every rule, read the project file, skim the map for the area the task touches. During the session: corrected — log the lesson immediately, then continue; a decision or convention changed — update the project file the same session; a module moved — patch the map. End of session: leave an open-threads note saying what's done, what's half-done, and what to pick up first. Upkeep is part of the method: prune monthly, delete facts that stopped being true instead of contradicting them, tag anything the agent inferred as inferred, and never store secrets in these files — they live in repos and get shared. Small tasks are exactly where a forgotten one-line rule does its damage, so the read happens every session, not just the big ones.

    Requires agent file I/O permissions. Memory files must be committed to git to persist. Effectiveness relies on the agent consistently following the start-of-session read protocol.

    How to use

    1. 1

      Connect your agent to the Agensi MCP

      Copy the prompt and paste it into Claude, ChatGPT, Cursor or any agent that supports MCP. It sets up the connection for you. Manual setup

    2. 2

      Sign in to Agensi

      Your agent shows a sign-in link. Sign in and click Allow.

    3. 3

      Ask for what you need

      Your agent loads this skill and uses it on your task. It always asks before any payment.

    Reviews

    No reviews yet

    Be one of the first to try it. Every listed skill goes through the trust checks below.

    Security scanned

    Checked by our 8-point scan before listing

    Fresh listing

    Recently published to Agensi

    Money-back guarantee

    Doesn't do what its page promises? You get your money back.

    Trust & safety

    Security scan

    Security scan passed 6 days ago

    Requires

    A coding agent with a project codebase

    Permissions

    Read Files
    Write Files
    Network Access
    Listed6 days ago

    What's inside

    Frequently Asked Questions

    This skill creates a local, repository-based memory layer using structured markdown files that track your project's unique conventions, past mistakes, and architectural decisions. It prevents agents from repeating errors you've already corrected and saves tokens by eliminating the need for the agent to re-scan the entire codebase every session.

    It is compatible with any AI coding tool that has file read/write access, such as Cursor, Aider, Claude Code, and Windsurf. Since it relies on standardized file protocols rather than proprietary APIs, it works across different models (like GPT-4o or Claude 3.5 Sonnet) within those environments.

    You will receive a set of optimized system prompts, structured memory schemas (lessons, project, and codebase maps), and a standardized session protocol. These components work together to force the agent to consult its history before starting work and document new learnings before finishing.

    Setup is straightforward: you initialize a specific directory in your repository with the provided schema files and add the session-start instructions to your agent's system prompt or rules file. No external databases, API keys, or specialized plugins are required.

    Yes, because the memory is stored as plain text files within your repository, they should be committed to Git. This allows the agent's 'memory' to persist across different branches, machines, and even between different developers working on the same project.

    The skill includes built-in 'Memory Maintenance' protocols that instruct the agent on how to prune redundant information and resolve conflicting instructions. This ensures your context window stays focused on the most relevant facts rather than becoming bloated with outdated logs.

    New in Prompt & Skill Engineering