When the code finally ran without errors, the real work began. Part 1 of this series covered getting from a blank repository to a working plugin; publishing that plugin to the Anthropic marketplace turned out to be a different problem entirely -- a lot like moving a prototype from a sandbox into a public gallery. The sandbox lets you iterate quickly, but the gallery has a checklist, a review process, and a set of expectations that most developers only discover after their first successful build. This second part of the series covers the practical steps that saved weeks of back-and-forth with reviewers -- and how LoreConvo kept my notes, decisions, and dependencies organized throughout the publishing journey.
From Local Testing to Marketplace Submission
The first version of the plugin lived inside a single repository, driven by a handful of unit tests and a local Claude session. That environment is forgiving: you can reload the same session, tweak a prompt, and rerun the same code without worrying about external constraints. The Anthropic marketplace, however, runs the plugin in a clean container, validates the manifest, and checks that every declared dependency can be resolved from PyPI. The first surprise was the strictness of the manifest schema. Fields that seemed optional in the sandbox -- required_python_version, runtime_dependencies -- must be present and accurate. Missing a single dependency caused the automated validator to reject the entire upload, even though the code executed perfectly on my machine.
To avoid that trap, I started treating the manifest as the single source of truth. Every time I added a library, I updated the manifest immediately and ran the same validation script that the marketplace uses. The script catches mismatched version specifiers, missing optional fields, and warns when a dependency is listed but never imported. Running it locally before each submission turned a three-hour debugging session into a five-minute sanity check.
Another hidden requirement is the naming convention for the plugin entry point. The marketplace expects a callable named main in the module defined by entry_point. Renaming the function during a refactor broke the submission without any obvious error in the logs. Adding a small wrapper that re-exports main from the actual implementation insulated the public interface from internal refactors and kept the review process smooth.
Dependency Pinning and Reproducibility
One of the most common reasons for a review stall is a dependency that resolves to different builds across environments. In the sandbox I relied on the latest patch of a data-processing library, but the marketplace container pulled an older wheel that lacked a small bug fix. The result was a runtime error that only appeared after the plugin was accepted, forcing a second round of review.
The fix is to pin every dependency to a specific version that you have tested in the target environment. A requirements.txt file generated by pip freeze -- after installing the exact versions you want -- is the right artifact to commit alongside the manifest. Referencing it in runtime_dependencies gives the marketplace a reproducible environment and gives you a clear audit trail of which versions were part of each release. When you need to upgrade a library, bump one version at a time, run the full test suite, and submit a minimal change. Reviewers appreciate the incremental approach, and the risk of breaking unrelated code drops significantly.
Navigating the PyPI Release Cycle
Even after the manifest and dependencies are locked down, the PyPI release process has its own failure modes. The marketplace pulls packages directly from PyPI, so any gap in distribution metadata shows up as a missing file error during validation.
The metadata fundamentals matter more than they should: pyproject.toml needs a complete description, a valid license identifier, and classifiers that match the plugin's purpose. A missing classifier caused the automated scanner to flag the package as incomplete on my first attempt. The second lesson was process-shaped rather than technical. A two-step release approach -- upload a pre-release (alpha) first, let the marketplace validate against it, then publish the stable release once review passes -- acts as a safety net. If the marketplace reports a missing file on the pre-release, you can replace it without touching any version that downstream users might have pinned. Automating the upload with twine upload and storing the SHA-256 checksum of the wheel in the repository means that if a reviewer asks for verification, you have the exact hash ready.
Keeping the Development Memory Fresh
All of these steps generate a lot of context: decisions about dependency versions, notes from reviewer feedback, the exact commands that built the wheel. Keeping that information searchable and linked to the right project is what separates a smooth second release from a painful one.
LoreConvo fit naturally into this workflow. Every time I finished a debugging session or a review iteration, the auto-save hook captured a concise summary, the decisions made, and any tech-stack facts it could infer. The data landed in a local SQLite file -- no cloud account, no sync service. Because the memory is cross-surface, I could start a session in Claude Code and revisit the same context from a fresh Claude chat session later. The auto-load hook surfaced the most relevant prior context automatically, which meant that when I opened a new terminal to run the PyPI upload script, I could see the exact manifest version that was last validated without digging through git history.
Project tagging kept the plugin work separated from other experiments. Tagging every session with the plugin's project name filtered the inspection CLI to show only the relevant history. Session linking connected related sessions automatically, so the chain from initial prototype to final marketplace submission appeared as a single navigable narrative. When I needed to share a specific decision with a teammate, I exported the selected sessions to JSON and sent the file -- they imported it with one command, no server required.
The related session discovery feature in the Pro tier proved especially useful during reviews. After each round of feedback, the system surfaced earlier sessions that shared similar context, pulling up a discussion about dependency pinning from three weeks earlier that I had forgotten. Being able to ask "what did we decide about this library version?" and get the actual session back -- rather than a guess -- shortened the review feedback loop considerably.
Lessons from the Publishing Journey
The publishing journey made clear that the hardest part of building a Claude plugin is not the code itself but the surrounding ecosystem of manifests, dependencies, and documentation. Treating the manifest as the authoritative source and validating it locally before each upload removes most of the surprise from the review process. Pinning every dependency and using a two-step PyPI release turns a once-a-month headache into a repeatable, low-stress procedure.
And keeping a local session memory throughout -- one that captures decisions automatically, survives surface switches, and stays entirely under your control -- means the institutional knowledge of the build doesn't evaporate the moment you close the terminal.
Ready to try a memory-first workflow for your own AI projects? Explore the full set of tools at /tools or reach out for a consultation at /contact.