Works with the AI Agents you already use

    Claude CodeClaude CodeCursorCursorCodex CLICodex CLIMuseMuseDotsDots+21 more

    infernoflow: git-native memory for coding agents

    1

    Memory for coding agents: gotchas, decisions, dead ends, bookmarks and session handoffs, saved as plain text in your git repo.

    Free

    2 usesSecurity scanned
    infernoflow: git-native memory for coding agents

    infernoflow: git-native memory for coding agents

    Example session with this skill installed

    Add error handling to the login call in src/api/auth.js

    • Read your context and instructions
    • Compiled the infernoflow

    Summary

    Loaded project memory first. There's a gotcha logged for this file, so I didn't rely on response.ok.

    🔥 (from infernoflow memory) gotcha at src/api/auth.js:42: the auth API returns 200 even on errors. Check the response body, not the status code.

    export async function login(email, password) {
      const res = await fetch("/api/auth/login", {
        method: "POST",
        headers: { "Content-Type": "application/json" },
        body: JSON.stringify({ email, password }),
      });
      const data = await res.json();
    
      // The auth API returns 200 on failures too (see memory), so trust the body.
      if (!data.ok) {
        throw new AuthError(data.error?.code ?? "LOGIN_FAILED", data.error?.message);
      }
      return data.user;
    }
    
    Memory usedTypeWhere
    Auth API returns 200 on errorsgotchasrc/api/auth.js:42
    Opaque session tokens, not JWTs, so sessions can be revokeddecisionsrc/auth.js

    Logged to memory

    • decision: login() throws AuthError with the server's error code so the UI can map it to a message (src/api/auth.js)

    Next steps

    • Map the AuthError codes to messages in the login form
    • Run infernoflow status to see the new entry

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

    About this skill

    You come back to a repo after a week and spend an hour working out why you didn't use that library, or how you fixed that weird build error last time. Your agent has it worse: it starts every session from zero. This skill gives it a memory that lives inside your repo, using infernoflow.

    What it does

    • Logs gotchas: undocumented behavior and config quirks that cost you time
    • Records decisions together with the reason behind them
    • Tracks dead ends, so nobody tries the same failed fix twice
    • Remembers lasting preferences across sessions
    • Drops bookmarks: named resume points with where you stopped and what's next
    • Writes a handoff for the next session, so you, a teammate or another agent start with context
    • Keeps working when the agent forgets to log: prompt hooks catch moments like "still broken" and record them

    How it works

    1. The first time, the skill asks before installing anything, then runs npm install -g infernoflow and infernoflow init --yes. That creates the .ai-memory/ store, the rule files and the MCP config.
    2. At the start of a session the agent calls amp_resume to load recent bookmarks, decisions and open dead ends.
    3. While you work it logs with amp_write (gotcha, decision, attempt, preference).
    4. Before trying something, it checks memory with amp_read or amp_search.

    What makes it different

    • The memory is plain JSONL in .ai-memory/, committed with your code. You can read it, diff it and review it in a PR.
    • It travels with your branch. A teammate who checks out your branch gets your findings too.
    • No server, no database, no account.
    • The same memory works in Claude Code, Cursor and GitHub Copilot.

    Frameworks & tools

    Needs the free infernoflow npm package (Node 18+). Works with Claude Code, Cursor and VS Code Copilot through MCP, or with any agent through the CLI. macOS, Linux and Windows.

    Use cases

    • Picking up a big refactor after a weekend without losing the thread
    • Bringing a new teammate or agent up to speed on the repo's tribal knowledge
    • Stopping the agent from suggesting a library you already tried and dropped
    • Keeping architectural decisions and the reasons behind them in one place

    Privacy

    The npm install is the only network call. infernoflow makes none after that, and telemetry stays off unless you turn it on. Secrets are redacted before anything is written.

    Free and open source (MIT).

    Website: https://infernoflow.dev · npm: https://www.npmjs.com/package/infernoflow · GitHub: https://github.com/ronmiz/infernoflow · VS Code extension: https://marketplace.visualstudio.com/items?itemName=infernoflow.infernoflow

    Requires Node 18+ and a one-time global npm install. Memory entries can become stale if referenced files are modified. Shared via git, so team members must pull to see updates.

    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

    2 uses

    Times used to date

    Free forever

    No account required to browse

    Trust & safety

    Security scan

    Security scan passed 1 month ago

    • Free with an Agensi account

    Requires

    Npmjs
    infernoflow (npm)
    Node.js 18+
    git
    infernoflow
    Node.js

    Permissions

    Write Files
    Terminal / Shell
    Read Files
    Network Access

    Allowed Hosts

    npmjs.com

    File Scopes

    .ai-memory/**
    CLAUDE.md
    .cursorrules
    .github/copilot-instructions.md
    .mcp.json
    .cursor/**
    .vscode/mcp.json
    .claude/**
    .gitignore

    Shell: runs the infernoflow CLI (resume, ask, log, bookmark). Network: only the one-time npm install, and only after the user agrees. infernoflow makes no network calls after that, and telemetry is off unless the user opts in. Files: memory goes to .ai-memory/, and a marked block is added to the rule files. During setup, init also writes the MCP configs (adding .mcp.json to .gitignore) and installs this skill and the memory-keeper agent into .claude/.

    Listed1 month ago
    Updated21 days ago

    What's inside

    Frequently Asked Questions

    A prompt is gone when the session ends. This skill writes what matters (gotchas, decisions and the reason behind them, dead ends) to plain-text files in your repo, and the agent reads them back at the start of the next session.

    Claude Code, Cursor and GitHub Copilot in VS Code, set up automatically through MCP. Any other agent that can run shell commands can use the infernoflow CLI. You need Node.js 18+ and the free infernoflow npm package.

    Locally. It's plain JSONL in the .ai-memory/ folder of your repo. Nothing leaves your machine unless you push it to git yourself, and that's also how your team gets it.

    Yes. Say "bookmark this" (or let the agent drop one at a stopping point) and it saves a named resume point with where you stopped and what's next. Next session, ask "where were we?" or run infernoflow resume.

    Yes, free and open source (MIT). The zip has the skill itself, setup steps, and MCP config templates for Claude Code, Cursor and VS Code. The memory engine is the infernoflow npm package, which the skill helps you install.

    New in Productivity