MemStack: a licensed skill loader bolted onto Claude Code

The setup problem MemStack actually addresses

Claude Code has no built-in notion of a procedure library. If you want the agent to follow your database migration checklist, you paste the checklist. If you want it to know your Railway deployment sequence, you paste that too. MemStack's answer is to package those procedures as skill files and let the agent load the right one when a request matches it. The README gives the example directly: say "deploy this to Railway" and the skill loads on demand. The catalog spans deployment, security, databases, content and marketing, which is a wide net rather than a deep one in any single area. The intended user is someone already running Claude Code on a server or workstation who wants repeatable procedure without maintaining a private prompt library. It is not a code generator and it is not a model. It is a distribution mechanism for instructions.

Two install halves and the interpreter that must match

The install is split in a way that causes most of the reported failures. The skills come from the Claude Code plugin marketplace, and the loader comes from PyPI. The README states that you need both, because the loader reads skill files from the installed marketplace plugin. Step 1 runs inside Claude Code: /plugin marketplace add cwinvestments/memstack followed by /plugin install memstack@cwinvestments-memstack. Step 2 runs in a terminal and installs memstack-skill-loader. Step 3 registers the MCP server, and this is where the design gets sharp. The README insists you register against the same interpreter you installed onto, and it gives the Linux and Mac form explicitly: claude mcp add --scope user memstack-skills -- /usr/bin/python3 -m memstack_skill_loader. The README is blunt about the consequence of a mismatch: the server will not launch, you get a failed to reconnect error, and activate_license will be missing. The diagnostic it supplies is /usr/bin/python3 -c "import memstack_skill_loader; print('ok')". Whatever interpreter prints ok is the path that has to appear in the claude mcp add command. That is a real constraint, not a stylistic preference, and it exists because the loader is a Python module launched by Claude Code rather than a service you start yourself.

What happens when a Pro key is activated

The tier table is the part worth reading twice. Free is 87 skills. Pro is 131 total, meaning 87 free plus 44 Pro-exclusive. According to the README, Pro skills are license-gated and the loader downloads them from the vendor server to ~/.memstack/pro-skills when a valid key is activated. Free users see free skills only. The stated rationale is a single source codebase with no separate repositories or branches for Pro content, which is a coherent engineering choice and also means the Pro catalog is not present on your disk until you authenticate. Activation happens inside Claude Code via activate_license(key="your-key", email="you@example.com"), and the README notes there is no separate marketplace step for Pro. As an alternative, MEMSTACK_PRO_LICENSE_KEY can be set as an environment variable, using setx on Windows or an entry in ~/.bashrc on Mac and Linux, followed by a terminal and Claude Code restart. The README also documents a skill lifecycle rule: new skills default to Pro-exclusive and drop to free after 90 days unless marked permanent-Pro. That means the free tier is a moving target by design, and the 87 number should be read as a snapshot rather than a fixed contract.

The failure modes the README documents, and the one it cannot fix

The troubleshooting section is unusually specific, which suggests these are the failures people actually hit. On newer externally-managed Python, pip refuses the install and you need --break-system-packages, as in /usr/bin/python3 -m pip install memstack-skill-loader --break-system-packages. On minimal Debian or Ubuntu images the interpreter may ship without pip at all, in which case sudo apt install python3-pip comes first. On a fresh server that has never spoken to GitHub over SSH, the plugin clone fails with Host key verification failed, and the README's default fix is to rewrite GitHub to HTTPS with git config --global url."https://github.com/".insteadOf "git@github.com:", with ssh-keyscan github.com >> ~/.ssh/known_hosts as the backup. The limitation that no troubleshooting entry can resolve is the license gate itself. If you need to read every instruction the agent will follow before it follows it, the Pro skills are not on your machine until activation pulls them down, and the loader reaches a vendor server to do that. For a regulated environment where prompt content is part of the audit surface, that is a genuine reason to stay on the free tier or to skip the project. A second, quieter cost: the README's own framing is that running a command in the wrong place is the most common setup mistake, so the four-step sequence assumes a user who can tell Claude Code from a shell.

How this differs from assembling your own skill directory

The obvious alternative is not a competing product but the manual approach: keep a directory of markdown procedure files in your repository and reference them from CLAUDE.md or paste them when needed. The difference is in the loading path. A manual directory is inert. Nothing selects the right file when you type a request, and nothing tells you which procedures exist. MemStack's loader is an MCP server, so skill selection becomes a tool call the agent can make, and list skills becomes a way to enumerate what is installed. The trade is control for convenience. With a repository directory you own the update cadence, the review process and the diff history, and nothing phones home. With MemStack you get automatic activation and a vendor-maintained catalog, but the Pro half updates on the vendor's schedule and lives outside your version control. Neither approach is strictly better. The manual route is the right call when the procedures are few, sensitive, or tightly coupled to your own infrastructure. MemStack is the right call when you want breadth across deployment, security and database tasks without writing all of it yourself.

Licence, maintenance and what the MIT tag covers

The repository is MIT licensed, and that is worth parsing carefully rather than reading as blanket permission. MIT covers the code in the repository, which per the README is a single source codebase that includes the loader and the free skill content. It does not, on the face of the documentation, grant you the 44 Pro skills, which are gated behind a key and delivered from a separate server under whatever terms memstack.pro sets. The README does not state those terms, so if the Pro catalog matters to your decision, that is a question for the vendor and not something the repository answers. On maintenance, the release history shows active iteration: v4.0.1 in May 2026 with 127 skills, v4.0.5 two days later adding dashboard streaming and MCP tools selection, and v4.1.0 adding a plugin manager, git workflow, branch selector and agent execution mode. The README badge still reads version 3.9.12 while the latest release is v4.1.0, so the badge is stale and the changelog is the better source. Upgrading the engine is a pip reinstall against the same interpreter, which means the interpreter-matching constraint from Step 3 applies to every upgrade, not just the first install.

Who should install this, and what to check first

MemStack fits a Claude Code user who wants procedure breadth and is comfortable with a Python module sitting between the agent and a catalog of instructions. It fits less well if your procedures are few and proprietary, if your environment forbids outbound calls from the loader, or if you cannot guarantee a stable interpreter path across machines. The verification order is fixed by the README and worth following literally. Install the marketplace plugin first, then the engine, then confirm the import with /usr/bin/python3 -c "import memstack_skill_loader; print('ok')", then register that exact path with claude mcp add, then fully restart Claude Code before running activate_license. If you are on the free tier, skip activation and run list skills to see which 87 loaded. If activate_license is missing, the interpreter is wrong, and no amount of restarting will fix it. The project is a distribution layer, and its ceiling is the quality of the instructions it distributes, which the repository does not let you inspect for the Pro half until you have already paid.

Editorial conclusion

Adopt MemStack if your team already lives in Claude Code and wants deployment, database and security procedures to load on demand instead of being pasted into a prompt each time. Do not adopt it if you need every skill to be auditable offline, since the 44 Pro skills arrive from a vendor server at activation time and the free tier deliberately holds them back. Before committing, verify that the interpreter you install memstack-skill-loader onto is the exact path in your claude mcp add command, then run list skills to confirm which tier actually loaded.

Official sources

1. cwinvestments/memstack on GitHub
2. License: MIT
3. Project website
4. README
5. Releases