Side project
AI plugin marketplace
Four Claude Code plugins I use on every project, in one marketplace: a project foundation that each coding session starts from, a reviewer that finds the decisions a ticket or plan leaves to the reader, a writing editor that keeps my voice, and tools for session hand-offs and interview prep.

01
Overview
The brief and the goal.
I used to start every AI coding session with a blank prompt. I was slow to get going, and I used a different skill for each step: one to write the spec, another to write tickets, and so on. Every project began by rebuilding the same context.
It was worse for anything I worked on part-time. With a long gap between one session and the next, I struggled to get back to where I'd left off, and sometimes I forgot to log the end of a session because I was still in the middle of something. This workflow aims to make every session seamless and progress easy to track. Everything lives in the repo, so I can pick the work up from any computer.
The marketplace puts all of that in one place. The project foundation is a set of blank templates, not an application: an entry point for the agent, seven context documents, a Makefile with a single check command, and a private folder for my own notes. Nothing in it runs. A skill copies the templates into a project and fills them in with me, and from then on the agent reads them at the start of every session. The other plugins came out of the same habit of writing things down before the agent, or a reader, has to guess.
The context files aren't generated for me. The setup skill walks me through them and asks for each piece of information, so I stay in control of what the agent is told and how the project is set up. Anything I find myself repeating on every project can be automated, but for the details that belong to one project, investing time in the setup is worth it.
I've written about how I use it in Structure Before Prompts and about why context has to stay small in Smart Zone, Dumb Zone.
02
My role
What I owned and who I worked with.
- 01Designed the templates and all seven skills, and built them with Claude Code. The repo is the only copy of them.
- 02Set the repo up as a Claude Code plugin marketplace, paula-tools, so each plugin installs into any project with one command.
- 03Wrote the rules for maintaining it: any change to a template updates the overview, the README and every other affected file in the same change, and the plugin version is bumped so installed copies update.
03
How it’s built
The stack and how the pieces fit.
Add the marketplace once, then install the plugins you want:
/plugin marketplace add paufar/paula-tools-marketplace
project-foundation
/project-foundation:init-project copies the templates into a new or existing project and fills them in with me, one question at a time, starting with the private goal file. It keeps a tracker in the project root, so an interrupted run can resume where it stopped. For an existing project it reads the markdown files already there and shows me what could fill each template, labelled with where it came from. /project-foundation:test-me closes the loop: it interviews me on the goals in my private goal file and judges whether each was reached.
/plugin install project-foundation@paula-tools
nitpicker
/nitpicker:nitpicker reads a ticket, plan or article as a smart newcomer would and lists every decision the reader would have to guess, ranked blocking or non-blocking. Each review ends with rules for next time, about kinds of sentences rather than subjects, and they're saved only if I say yes. /nitpicker:no-loose-ends writes the next ticket or doc with those rules applied, looks up every name in the repo before writing it down, and lists open questions instead of guessing.
/plugin install nitpicker@paula-tools
thoughtful-writing
/thoughtful-writing:thoughtful-writing-editor turns notes or a draft into an article in my own voice. It confirms what the piece is for, reviews and plans it, discusses the plan with me, and only then writes. It's an editor, not a ghostwriter: it doesn't add claims, examples or conclusions I haven't agreed to.
/plugin install thoughtful-writing@paula-tools
learning-tools
/learning-tools:interview-prep reads a repo's docs, dependencies, code and history, briefs me on its decisions and tools, marking any reason that isn't recorded, then mock-interviews me one question at a time, weighted towards the vacancy if I give it one. /learning-tools:close-session writes a hand-off summary for any session, separate from the project's own progress file, so the next session can pick up cold.
/plugin install learning-tools@paula-tools
04
Why it’s built this way
The decisions that shaped it.
- 01Pointers instead of pushing contentEvery instruction is sent with every request, so it costs tokens and attention each time. AGENTS.md is mostly one-line pointers to the documents in context/, and the agent opens a document only when a task needs it.
- 02A work-in-progress limit of one instead of several tasks in flightPROGRESS.md holds at most one item under In Progress, each task has a “Done when”, and a new idea that appears halfway through goes to Next Steps or Open Questions, never into the current task. Small steps are easier to check.
- 03A make check that fails until it’s configured instead of one that passes by defaultThe agent runs make check at the start and end of every session. The stub in the template fails on purpose, so a session can’t pass on a check that tests nothing. The setup skill swaps it for the project’s own lint, type-check, test and build commands.
- 04Files of 100 to 150 lines instead of one long instruction fileWhen a document grows, the detail moves into a linked document. Published advice on instruction files ranges from about 60 lines to 300, and this range sits in the middle.
- 05A marketplace instead of skills copied into ~/.claude/skillsThe repo is the only copy of every skill and template. Installed as plugins, they update when the version is bumped, and nothing shows up twice.
- 06A private goal file instead of personal notes in committed docslocal-docs/goal.md holds what I want to get out of a project for myself. It’s gitignored, and only the wording I clear reaches a committed file.
- 07Writing rules learned from reviews instead of a fixed checklistEvery gap nitpicker finds becomes a rule for the next piece of writing. Personal rules live on my machine; a rule seen three or more times can be promoted to the team file by pull request.
05
Outcome
What I delivered.
I don't start with the prompt any more. I start with the structure. When I stop and start a task over several days, the agent finds what it needs and continues where we left off, however big the gap between sessions.
Everything is logged, so I don't have to repeat anything to the agent, and I don't waste context doing it. Each project has its own memory, which makes switching between projects easier.