Ralph Wiggum Marketer: a Claude Code plugin that drafts SaaS content in a loop

The gap between agreeing on a launch post and shipping one

Ralph Wiggum Marketer is a Claude Code plugin described as an autonomous AI copywriter for SaaS content marketing. The gap it targets is narrow and familiar. A content team can agree that a product launch needs a blog post, a thought leadership piece, a case study, a round of social posts and a newsletter, and still have all five of those items sitting in someone's task list waiting for a free afternoon. Each step waits on a human decision, and each step burns a context window.

The plugin moves that sequence into a product requirements document and lets a loop execute it. The tasks are written as records with an id, a title, acceptance criteria, a priority and a passes flag, and the copywriter works through them one at a time. The intended user is a small team or a solo founder who knows the content plan already and wants the drafting, reviewing and reformatting carried out inside a terminal session rather than in a document tool. The project also assumes a different kind of comfort, because the working record of the run lives in files and git commits that you are expected to read later.

How the loop keeps its memory across fresh context windows

The mechanism is deliberately simple, and the plugin's own summary of it is worth quoting: Ralph is a Bash loop, and each iteration is a fresh context window, so memory persists only through git history and text files. The loop reads the PRD at scripts/ralph/prd.json to see which tasks exist, reads scripts/ralph/progress.txt to recover what was learned in earlier passes, then selects the highest priority story whose passes value is still false.

From there it executes the task against the written acceptance criteria, verifies the result, commits the work to git, marks the task as done and logs the new learning back into the progress file before looping again. Git is not decoration here. The commit step is the write-ahead record, and the progress file is the cross-iteration memory, because the model itself starts each pass with no recollection of the last one.

That design has a practical consequence for reviewers. The quality of a draft is bounded by the acceptance criteria the person wrote, and the audit trail for a run is a diff and a log, not a report. The verification step also leans on the repository's own test script rather than on an external judge, so the check that matters is whatever the PRD makes checkable.

Three ways into Claude Code, and the first command to run

Claude Code is the host application and the plugin does nothing without it. Three entry points are documented, and the marketplace route is the one marked as recommended. From a Claude Code session you add the repository as a marketplace and then install the plugin under its scoped name:

/plugin marketplace add muratcankoylan/ralph-wiggum-marketer
/plugin install ralph-wiggum-marketer@muratcankoylan-ralph-wiggum-marketer

For local development you can clone the repository and point Claude Code at the plugin directory with the --plugin-dir flag:

git clone https://github.com/muratcankoylan/ralph-wiggum-marketer.git
claude --plugin-dir ./ralph-wiggum-marketer

The third option is the interactive plugin manager, opened with the /plugin command, where you browse and search for plugins instead of typing the install line yourself.

Once the plugin is loaded, the first real step is project initialization in the directory where the content should live:

/ralph-init

That command initializes a new content project in the current directory, which is where the PRD, the progress log and the database are created. The plugin exposes four commands in total: /ralph-init, /ralph-marketer to start the loop, /ralph-status to inspect the content pipeline, and /ralph-cancel to stop an active run. If a run goes wrong, /ralph-cancel is the way out, and /ralph-status is how you check what the pipeline holds before deciding.

SQLite tables that separate outside signals from Ralph's own workspace

The plugin is primarily JavaScript, and its single runtime dependency is better-sqlite3 at version 11 or later. The database splits cleanly into two halves. Three input tables hold material arriving from other agents: trends from a TrendScout agent, research from a research agent, and communications such as product updates from a product or marketing agent. Each carries a status column, so a pipeline can show what has been consumed and what has not.

The other four tables belong to the copywriter itself. The schema is laid out as a flat set of column lists:

trends (topic, description, source, relevance_score, status)
research (title, summary, key_findings, data_points, category, status)
communications (type, title, details, key_messages, target_audience, priority, status)
content_plan (content_type, title, brief, target_keywords, status)
drafts (plan_id, version, content, word_count, feedback)
published (plan_id, final_content, meta_description)
agent_log (action, details, created_at)

A content plan holds the type, title, brief and target keywords. Drafts are versioned rows with a word count and a feedback field, which is where a review pass lands, and published rows keep the final text with a meta description. agent_log is a plain activity trail with a timestamp. The package manifest also wires up housekeeping scripts for the database, so a reset is one npm script rather than a manual file deletion.

The stop hook is the part that makes the loop continue

A plugin that only provided four markdown commands would be a prompt collection. The structural piece that turns those commands into an unattended run sits in the hooks directory, where hooks.json configures a stop-hook.sh script whose stated role is loop continuation. Without that hook, the loop would stop at the end of every turn, because each iteration begins in a fresh context window and has to be re-entered deliberately. The hook is what re-enters it.

The rest of the layout is small and legible. A .claude-plugin directory holds plugin.json, the manifest that describes the package. The commands directory holds one markdown file per slash command, including ralph-marketer.md, which is where the main loop is defined, and ralph-init.md, ralph-status.md and ralph-cancel.md. A skills directory contains a copywriter skill, so the writing behaviour is expressed as a reusable skill definition rather than as text pasted into a single command.

Templates supply the starting files for a project: a prd.json task template, a progress.txt log template, a prompt.md file of agent instructions and a package.json template. A scripts directory holds the database and utility code, and the top level of the repository also carries an AGENTS.md file and a .gitignore, which fits a project that expects the generated content project to sit inside a git working tree.

Twelve seeded stories, and the two files you edit to change them

The default PRD ships with twelve stories, numbered and named in a way that shows the intended order of work: SETUP-001 initializes the database, PLAN-001 and WRITE-001 handle a product launch blog, PLAN-002 and WRITE-002 a data-driven blog, REVIEW-001 reviews and improves a draft, PUBLISH-001 publishes the launch blog, then PLAN-003 and WRITE-003 cover a case study, SOCIAL-001 creates social posts, NEWSLETTER-001 drafts a newsletter and METRICS-001 logs final metrics. Nothing in that list is a throwaway placeholder, which means the plugin has a strong default shape and a weak default fit for anyone whose content plan is different.

Adding your own story means editing scripts/ralph/prd.json and appending a record of the same shape:

{
  "id": "WRITE-004",
  "title": "Write your custom blog",
  "priority": 5,
  "passes": false
}

Feeding the plugin your own signals goes through the seed script, src/db/seed.js, where a trend is inserted with a relevance score and a communication with a priority:

insertTrend.run(
  'Your Trend Topic',
  'Description of the trend',
  'Source',
  85  // relevance score
);

These two files are the real configuration surface of the project. Everything else is the machinery around them.

Where this setup stops short of a content pipeline

Several things a buyer of a content tool would ask about are not answered in the project. The publish step is the largest gap. The architecture shows Ralph reading inputs, planning, drafting, reviewing and publishing into blogs, case studies, social posts and newsletters, and the published table stores the final text, but no CMS, no API endpoint and no destination format is named anywhere in the documentation. The word publish here means the content is finished and stored, and anything past that point is up to the operator.

Model configuration is the second gap. There is no documented environment variable, model name, API key or rate limit setting, and no mention of which model the plugin expects Claude Code to use or what a long run costs in tokens. The quality of an autonomous writer is a direct function of that choice, and the project leaves it entirely to the host application.

A few smaller signals are worth reading carefully. The package manifest declares version 1.0.0 and an MIT license in its own fields, while the repository listing shows no license tag. The typecheck script is defined as echo 'Typecheck passed', so it asserts nothing about the JavaScript. Verification in the loop therefore rests on the acceptance criteria you wrote and on the test script run by npm test. The repository has no GitHub releases, and the last push was on 2026-04-09, so the plugin format itself may have drifted with the Claude Code releases since then.

Editorial conclusion

Adopt this plugin if your team already knows which stories to publish and wants drafts produced inside Claude Code with a visible task trail, and stay away if you need a defined publishing destination, a documented model configuration or a release cadence you can plan around. Before running it, verify that the SQLite tables you rely on are seeded for your product, that the acceptance criteria in prd.json are strict enough to reject a weak draft, and that the last push on 2026-04-09 still matches the Claude Code plugin format you are running.

Frequently asked questions

Official sources

1. Issues
2. muratcankoylan/ralph-wiggum-marketer on GitHub
3. Project website
4. README