The setup guide from my Watermarks Remover Reel: install the skill, connect it to its local service, and make text cleanup a repeatable part of your writing workflow.
Start with writing you own or have permission to edit. Keep the original, save a cleaned copy, and review what changed before publishing. This guide expands the workflow shown in the Original Instagram Reel using the project's current installation instructions. The prompts below are practical RickAI templates, not a verbatim transcript.
What it does, and what it cannot promise
Watermarks Remover by Guillaume Meyer separates several different jobs:
- Character cleanup: identifies and removes supported invisible Unicode characters and unusual spacing. Invisible characters can also have legitimate uses, especially in multilingual text, so inspect before changing them.
- Prose rewriting: changes wording and sentence structure while trying to preserve meaning. This is a best-effort transformation, not a verified universal watermark remover.
- File metadata cleanup: handles supported metadata and provenance fields. That is a different operation from rewriting text or removing a watermark embedded in an image.
No guarantee of undetectability. Cleaning text does not prove it was human-written, and rewriting can change meaning or introduce new artifacts. A generic AI detector score is not proof that a particular watermark was present or removed. Keep any disclosures your publisher, client, school, or applicable law requires.
The Reel's broad claim about EU rules and all ChatGPT output is not a prerequisite for this workflow and should not be treated as a verified universal product behavior. Whether a specific output is marked depends on the system and format. This guide focuses on what you can actually set up and inspect.
Choose the right skill
The repository ships two skills:
- remove-ai-marks: the full skill shown in the Reel. It calls a separate HTTP service. Installing the skill alone is not enough.
- clean-user-facing-text: a self-contained, text-only alternative with its own scripts. It does not need the HTTP service and is a simpler starting point for manuscript, documentation, and website-copy cleanup.
For the full workflow below, you need Git, Python 3.10 or newer, and an agent that can load skills and make local tool calls. The shell commands use macOS/Linux syntax. On Windows, use the Python launcher (py) instead of python3 and adapt paths to your shell. Do not paste terminal commands into an ordinary chatbot that cannot execute tools.
1. Get the project
Open a terminal in the folder where you keep tools. Clone the repository and enter it:
git clone https://github.com/guillaumemeyer/watermarks-remover.git
cd watermarks-remover
Review the README, installer, and skill instructions before installing third-party code. The commands below run from this checkout. If the directory already exists, enter your existing checkout instead of cloning over it. Updating is a separate decision; review upstream changes before applying them.
2. Install for your agent
Choose one command for the app you use. These are personal installs, so the skill becomes available across your projects. The installer preserves an existing installation unless replacement is explicitly requested.
Codex terminal or desktop
python3 install_skill.py --skill remove-ai-marks --target codex
This installs into your user-level .agents/skills directory. In Codex terminal, open the skill picker with /skills or type $ and select remove-ai-marks. In the desktop app, select or mention the skill in your prompt. Restart Codex if it does not appear.
Claude Code
python3 install_skill.py --skill remove-ai-marks --target claude-code
This installs into your user-level .claude/skills directory. Ask Claude Code to use remove-ai-marks, or invoke /remove-ai-marks. This is a local Claude Code install, not an upload into the ordinary Claude chat interface.
Cursor
python3 install_skill.py --skill remove-ai-marks --target cursor
This installs into your user-level .cursor/skills directory. Ask the agent to use remove-ai-marks and confirm it actually loads the skill. The Reel illustrates an @ selection, but the exact picker and mention syntax differ by host. Use your app's supported skill selector rather than assuming @ works everywhere.
3. Start the local service
Keep this command running in a separate terminal, from the repository folder:
python3 service/scripts/server.py --host 127.0.0.1 --port 8765
This binds the service to your own machine. Leave the terminal open while using the full skill; stop it with Ctrl+C when finished. The core service uses Python's standard library, so Docker is not required for this basic setup.
From another terminal, check that it responds:
curl --fail --silent --show-error http://127.0.0.1:8765/health
curl --fail --silent --show-error http://127.0.0.1:8765/capabilities
The health response should contain an ok value of true. Capabilities tells you which optional backends are actually available. A healthy service does not mean every rewriting model or file-processing tool is installed.
The default service URL is already correct for an agent on the same machine. If you change it, configure WATERMARKS_SERVICE_URL in the agent's environment. A cloud agent cannot reach your laptop through its own 127.0.0.1 address. Do not expose an unauthenticated service publicly to work around that: use an authenticated HTTPS deployment you control, or choose the self-contained text skill. Store any service key in your host's secret store, never in a prompt or a project instruction file.
Simpler alternative: text only, no service
If you mainly want to clean your own writing, install the self-contained skill instead. Here is the Codex variant:
python3 install_skill.py --skill clean-user-facing-text --target codex
For Claude Code or Cursor, use the corresponding target from step 2. Select clean-user-facing-text when using this alternative, and refer to that exact name in any saved writing instructions. It is not a substitute for the full service's file and metadata capabilities.
4. Try it on a copy of your text
Save a draft as draft.md and give the agent access to that file. Markdown is a useful first test: the service can clean its supported metadata and character layer without requiring a separately configured statistical rewriting backend.
Select remove-ai-marks, then send this request:
Use the installed remove-ai-marks skill on draft.md, which contains writing I own.
First check service health and capabilities. Inspect the draft before changing it and summarize the actual findings. Do not treat unusual characters or an AI detector score as proof of AI authorship.
Save the supported character and metadata cleanup to draft.cleaned.md. Keep draft.md unchanged. Then offer a separate prose-editing pass for clearer, more natural wording; do not run an external model or upload my text without asking me first.
Preserve all facts, numbers, names, links, citations, technical identifiers, and required disclosures. Show the changes and flag any uncertain meaning. Report only what the tools verified, and distinguish editing from verified watermark removal.
Important plain-text caveat: in the current full service, cleaning a .txt file also requests a Layer B rewrite strategy. If the required rewrite backend is not configured, that request can return HTTP 400. That is not fixed by reinstalling the skill. Configure the supported backend deliberately, use the self-contained text skill, or use Markdown for the narrower container/character-cleanup workflow described here. Renaming a file does not make statistical watermark removal happen.
If you choose a model-based rewrite, check the project's current backend documentation and privacy settings first. External inference can send the text to another provider and may cost money. No model choice or rewrite recipe can be promised to remove every watermark.
Make it reusable with AGENTS.md
Once the one-off workflow works, add a narrowly scoped instruction to the project instruction file your agent actually reads. Codex uses AGENTS.md; other hosts can require CLAUDE.md or their own rules system. Ask before creating or editing an existing instruction file, preserve its current rules, and avoid conflicting cleanup instructions.
Use this RickAI template for the full skill:
## Writing cleanup
For user-facing prose I own or am authorized to edit, use the installed remove-ai-marks skill after drafting when its service is available.
Inspect first. Apply supported character and metadata cleanup to a separate cleaned copy; keep the original. Offer a prose-editing pass separately and get approval before sending text to an external service.
Preserve meaning, facts, numbers, names, URLs, citations, code, technical identifiers, and required AI disclosures. Do not rewrite source code, legal quotations, or third-party documents under this rule.
If the skill, service, or required rewrite backend is unavailable, say so and do not claim cleanup ran. Summarize verified changes, flag uncertainty, and ask for review before replacing or publishing the original. Never describe the result as proven human-written or guaranteed undetectable.
A saved instruction makes the behavior easier to request consistently. It is not a deterministic filter that automatically intercepts every response. Confirm that the agent read the instruction file and invoked the skill. Start with manual review rather than installing write hooks or silently editing every file.
5. Review the result before publishing
Ask for a final comparison:
Compare draft.md with draft.cleaned.md without changing either file.
Check every factual claim, number, name, citation, URL, technical identifier, and required disclosure. Look for missing sentences, altered emphasis, damaged formatting, and language-specific characters that should have been preserved.
List substantive differences separately from formatting changes. State which cleanup operations have tool evidence and which edits were model suggestions. If meaning may have changed, quote the relevant before-and-after passages and ask me to choose. Do not infer human authorship or guaranteed watermark removal from this comparison.
Open the cleaned copy yourself. Review multilingual text, quotations, code blocks, names, and numbers especially carefully. If the rewrite loses your voice or changes a claim, keep the original wording. Publish only after the content still says exactly what you mean.
Troubleshooting
- Skill not listed: verify you chose the target for your actual app, refresh or restart the host, and check its loaded-skills view. A local install will not automatically appear in a cloud chat session.
- Connection refused: the local service is stopped, the port is wrong, or the agent runs on a different machine. Check health from the same environment as the agent.
- HTTP 400 about Layer B: the plain-text rewrite strategy needs optional model dependencies and configuration. Use the text-only skill or configure the backend before retrying. Do not report a failed request as a successful clean.
- Unexpected file changes: compare against the untouched original. Character normalization and metadata removal are not inherently lossless for every document.
- AI detector still flags it: that does not establish which watermark, if any, remains. Do not keep rewriting just to chase a detector score at the expense of accuracy.
Sources and scope
- Reel source and caption: the skill-selection and saved-instruction workflow, plus the setup-guide offer.
- Upstream project and installation documentation: installer targets, service setup, and limitations.
- Full skill instructions: service contract, required rewrite backends, and supported operations.
Prepared against upstream revision c5297e9e69fec0779c29127c7892427e673fafd9. Upstream behavior can change; check the current documentation before updating. This guide covers an owned-text workflow, not removal of third-party attribution or a promise to bypass disclosure requirements.