Background & Architecture ↑ top

By default, Claude has no memory between sessions. Each conversation starts from zero. The approach described here replaces a static markdown memory file with a full self-hosted wiki — giving you a human-browsable, human-editable knowledge base that Claude can also read from and write to programmatically via an MCP connector.

The system is built on three open-source components, all free to self-host:

Component	Role	Version Tested
PostgreSQL	Relational database backend for Wiki.js	18.x
Wiki.js	Web-based wiki platform (human UI + GraphQL API)	2.5.312
wikijs-mcp by jaalbin24	MCP connector — exposes wiki tools to Claude	1.1.0

Architecture Overview

The recommended topology has one machine acting as the wiki server (running PostgreSQL + Wiki.js + the MCP connector), with any number of additional machines connecting to it as MCP clients only — they run no wiki software, just point their Cowork config at the server's LAN IP.

  [ Wiki Server Machine ]
  ┌─────────────────────────────────────┐
  │  PostgreSQL 18 (port 5432)          │
  │  Wiki.js 2.5.x  (port 3000)         │
  │  wikijs-mcp     (local connector)   │
  │  Claude Cowork  (desktop app)       │
  └─────────────────────────────────────┘
            │  LAN  (port 3000)
            ▼
  [ Any Other Cowork PC on the LAN ]
  ┌─────────────────────────────────────┐
  │  wikijs-mcp  (MCP client only)      │
  │  Claude Cowork  (desktop app)       │
  │  WIKIJS_URL = http://<server-ip>:3000│
  └─────────────────────────────────────┘

Prerequisites ↑ top

Verify the following on your wiki server machine before starting. Run this block in PowerShell to check all at once:

node --version        # Need 18+
npm --version
python --version      # Need 3.10+
pip --version
git --version

# Check ports are free
netstat -ano | findstr ":3000"
netstat -ano | findstr ":5432"

# Check no existing PostgreSQL service
Get-Service | Where-Object { $_.Name -like "*postgres*" }

Requirement	Minimum	Notes
Windows	Windows 10 / Server 2019	Guide written for Windows; Linux paths differ slightly
Node.js	18 LTS	Required by Wiki.js. Download from nodejs.org
Python	3.10+	Required by wikijs-mcp. Download from python.org — check "Add to PATH" during install
Port 3000	Free	Wiki.js HTTP port
Port 5432	Free	PostgreSQL default port
Claude Cowork	Any recent version	Must be installed before MCP registration
pipx	Any	Installed in Part 4 if missing

Part 1 — Install PostgreSQL ↑ top

Download & Install

Step 1 Download the Windows installer from postgresql.org/download/windows/. Use the EDB Interactive Installer — this is the officially recommended Windows distribution. Select PostgreSQL 16 or later (Wiki.js supports 11+; 16/17/18 all work).

Step 2 Run the installer. Accept defaults with these specific choices:

• Installation directory: default (C:\Program Files\PostgreSQL\<version>)
• Components: PostgreSQL Server + Command Line Tools (pgAdmin optional)
• Data directory: default
• Password: set a strong password for the postgres superuser — record it somewhere safe
• Port: 5432 (default)
• Locale: default

Step 3 After install, verify PostgreSQL is running as a Windows service:

Get-Service | Where-Object { $_.Name -like "*postgres*" } | Select-Object Name, Status, StartType

You should see a service like postgresql-x64-18 with Status: Running and StartType: Automatic.

Step 4 Add the PostgreSQL bin directory to your system PATH so psql is available in PowerShell:

# Replace "18" with your installed major version
$pgBin = "C:\Program Files\PostgreSQL\18\bin"
[System.Environment]::SetEnvironmentVariable("Path", $env:Path + ";$pgBin", [System.EnvironmentVariableTarget]::Machine)
# Close and reopen PowerShell after running this

Create the Wiki Database & User

Step 5 Open a new PowerShell window (so the updated PATH is active) and create the database and a dedicated user for Wiki.js:

# Connect as postgres superuser — enter the password you set during install
psql -U postgres

-- Inside the psql prompt, run these SQL commands:
CREATE USER wikijs WITH PASSWORD 'your-wikijs-db-password';
CREATE DATABASE wiki OWNER wikijs;
GRANT ALL PRIVILEGES ON DATABASE wiki TO wikijs;
\q

Part 2 — Install Wiki.js ↑ top

Download & Extract

Step 6 Download the latest Wiki.js 2.x Windows release from github.com/requarks/wiki/releases. Look for wiki-js.tar.gz under the most recent 2.x release (do not use a 3.x beta — it is a full rewrite with a different setup process).

Step 7 Create an install directory and extract the archive:

New-Item -ItemType Directory -Path "C:\wikijs"
# Extract the downloaded tar.gz — use 7-Zip or tar (available in Windows 10+)
tar -xzf wiki-js.tar.gz -C C:\wikijs

Configure Database Connection

Step 8 In C:\wikijs you will find a file named config.sample.yml. Copy it to config.yml:

Copy-Item "C:\wikijs\config.sample.yml" "C:\wikijs\config.yml"

Step 9 Open C:\wikijs\config.yml in a text editor and update the database section. Find the db: block and set it as follows:

db:
  type: postgres
  host: localhost
  port: 5432
  user: wikijs
  pass: your-wikijs-db-password    # password you set in Step 5
  db: wiki
  ssl: false

Also confirm the HTTP port is set to 3000 (default):

port: 3000
bindIP: 0.0.0.0    # listens on all interfaces — needed for LAN client access

Step 10 Do a quick first-run test to confirm Wiki.js starts without errors:

cd C:\wikijs
node server

Watch the console output. After 15–20 seconds you should see a line like HTTP Server: RUNNING on port 3000. If you see database connection errors, recheck your config.yml credentials. Press Ctrl+C to stop once confirmed working.

Run as a Windows Scheduled Task

Rather than running Wiki.js as a foreground process, register it as a Windows Scheduled Task so it starts automatically at boot.

Step 11 Run the following PowerShell block to register the task. It runs as SYSTEM with a 30-second startup delay (to give PostgreSQL time to fully initialize first):

$action = New-ScheduledTaskAction `
    -Execute "node.exe" `
    -Argument "server" `
    -WorkingDirectory "C:\wikijs"

$trigger = New-ScheduledTaskTrigger -AtStartup

$settings = New-ScheduledTaskSettingsSet `
    -ExecutionTimeLimit (New-TimeSpan -Hours 0) `
    -RestartCount 3 `
    -RestartInterval (New-TimeSpan -Minutes 1)

$principal = New-ScheduledTaskPrincipal `
    -UserId "SYSTEM" `
    -RunLevel Highest

$task = New-ScheduledTask `
    -Action $action `
    -Trigger $trigger `
    -Settings $settings `
    -Principal $principal

Register-ScheduledTask -TaskName "WikiJS" -InputObject $task

# Add the 30-second boot delay
$t = Get-ScheduledTask -TaskName "WikiJS"
$t.Triggers[0].Delay = "PT30S"
Set-ScheduledTask -InputObject $t

Step 12 Start the task immediately to confirm it works:

Start-ScheduledTask -TaskName "WikiJS"
Start-Sleep -Seconds 20
(Get-ScheduledTask -TaskName "WikiJS").State    # Should show: Running

First-Run Web Setup

Step 13 Open a browser and navigate to http://localhost:3000 (or http://<server-ip>:3000 from another machine). Wiki.js will present a first-run setup wizard.

Complete the wizard with these settings:

• Administrator email: your email address
• Administrator password: set a strong password (separate from your database password)
• Site URL: http://<server-ip>:3000 — use the machine's LAN IP, not localhost, so remote clients work correctly
• Site title: whatever you like (e.g., "My Claude Memory Wiki")

Step 14 After completing the wizard, log in and go to Administration → Navigation. Set Navigation Mode to Tree — this gives you the hierarchical sidebar that makes the wiki easy to browse.

Step 15 Create a Home page at path home to replace the default splash screen. Go to any page, click the + New Page button, set the path to home, and give it a title like "Welcome to My Wiki". This is the page that will load when you navigate to the root URL.

Part 3 — Generate a Wiki.js API Key ↑ top

The wikijs-mcp connector authenticates to Wiki.js using a JWT API key. You generate this from the Wiki.js admin panel.

Step 16 In the Wiki.js admin panel, go to Administration → API Access.

Step 17 Click Generate New API Key and set:

• Name: something descriptive like Claude Memory Wiki
• Expiration: set a long expiry — 1–3 years recommended. The key must be regenerated when it expires, and you will need to update all MCP configs at that time.
• Access: Full Access

Step 18 Copy the generated key immediately — it is only shown once. Store it somewhere secure (your memory file, a password manager, etc.). It is a long JWT string beginning with eyJ....

Part 4 — Install wikijs-mcp on the Server Machine ↑ top

The wikijs-mcp package by jaalbin24 is a Python-based MCP server that exposes your Wiki.js instance as a set of Claude tools. It is published on PyPI and installed via pipx.

Install Python & pipx

Step 19 If Python 3.10+ is not already installed, download it from python.org. During installation, check "Add Python to PATH".

Verify:

python --version    # Should show 3.10 or higher
pip --version

Step 20 Install pipx:

pip install --user pipx
python -m pipx ensurepath
# Close and reopen PowerShell after running ensurepath

Verify:

pipx --version

Install wikijs-mcp

Step 21 Install the package via pipx:

pipx install wikijs-mcp

This installs the wikijs-mcp.exe binary into your user's local bin directory (typically C:\Users\<username>\.local\bin\). Verify the install location:

pipx list

Note the full path to wikijs-mcp.exe — you will need it in the next step.

Register with Cowork

Step 22 Locate your Cowork configuration file. On Windows it is at:

C:\Users\<username>\AppData\Local\Packages\Claude_pzs8sxrjxfjjc\LocalCache\Roaming\Claude\claude_desktop_config.json

You can find the exact package folder name with:

Get-ChildItem "$env:LOCALAPPDATA\Packages" | Where-Object { $_.Name -like "*Claude*" } | Select-Object Name

Step 23 Open claude_desktop_config.json in a text editor. Add or merge the wikijs entry into the mcpServers object:

{
  "mcpServers": {
    "wikijs": {
      "command": "C:\\Users\\<username>\\.local\\bin\\wikijs-mcp.exe",
      "env": {
        "WIKIJS_URL": "http://localhost:3000",
        "WIKIJS_API_KEY": "eyJ..."
      }
    }
  }
}

Step 24 Fully quit and relaunch the Cowork desktop app so the new MCP configuration is loaded. In a new Cowork session, you should now see the wikijs tools available (wiki_get_page, wiki_search, wiki_create_page, etc.).

Part 5 — Connect Additional Cowork Clients (LAN) ↑ top

Any other machine on your LAN that has Cowork installed can connect to the same Wiki.js instance. These machines do not need PostgreSQL or Wiki.js installed — only wikijs-mcp and a Cowork config update.

On each additional client machine:

Step 1 Ensure Python 3.10+ and pipx are installed (same as Steps 19–20 above).

Step 2 Install wikijs-mcp via pipx:

pipx install wikijs-mcp

Step 3 Edit the client machine's claude_desktop_config.json (same path pattern as Step 22), setting WIKIJS_URL to the server's LAN IP:

{
  "mcpServers": {
    "wikijs": {
      "command": "C:\\Users\\<username>\\.local\\bin\\wikijs-mcp.exe",
      "env": {
        "WIKIJS_URL": "http://<server-lan-ip>:3000",
        "WIKIJS_API_KEY": "eyJ..."
      }
    }
  }
}

Use the same API key as the server — there is one key per wiki installation, shared across all clients.

Step 4 Confirm the server machine's firewall allows inbound TCP on port 3000 from the local network:

# Run on the SERVER machine, in an elevated PowerShell
New-NetFirewallRule `
  -DisplayName "Wiki.js LAN Access" `
  -Direction Inbound `
  -Protocol TCP `
  -LocalPort 3000 `
  -Action Allow `
  -Profile Private

Step 5 Restart Cowork on the client machine and verify connectivity by asking Claude to run a wiki search.

Part 6 — Recommended Wiki Structure for Claude Memory ↑ top

The wiki works best as Claude memory when its page hierarchy is organized consistently. The following structure is what this system uses in production and what Claude's session-startup instructions reference by default:

Path	Purpose
home	Root landing page — wiki title and overview
session-startup	Instructions Claude reads at the start of every session (see Part 7)
memory/	Persistent facts about you, your preferences, and your environment
personal/	Personal context, goals, background
handoffs/	Session-to-session handoff documents for complex ongoing projects
skills/	Skill definition pages consumed by Claude's skill system

Page paths follow a lowercase-hyphenated convention throughout (e.g., memory/engineering-goals, not Memory/EngineeringGoals). This ensures consistent behavior when Claude constructs paths programmatically.

Part 7 — Session Startup Integration ↑ top

The most important piece of the memory system is a session-startup page that Claude reads at the beginning of every session. This page contains instructions that tell Claude how to behave, what to load, and what actions to take on startup.

Step 1 Create a page at path session-startup in your wiki. This page should contain:

• Your preferences for how Claude should interact with you
• Instructions to load key memory pages at session start
• Any standing tasks or context Claude should always be aware of
• Links or references to other important wiki pages

Step 2 In your Cowork user preferences (the system prompt or preferences file that Cowork injects at session start), add an instruction that tells Claude to fetch and act on this page. The pattern looks like this:

At the start of every session, call wiki_get_page with path="session-startup"
and take any follow-up actions dictated by that page's content.

This creates a self-contained, wiki-managed startup sequence. To change Claude's startup behavior in the future, you only need to edit the wiki page — no changes to Cowork configuration required.

Part 8 — End-to-End Verification ↑ top

After completing all parts above, run through this verification checklist in a Cowork session:

1. Ask Claude: "Can you list the pages in my wiki?" — Claude should call wiki_list_pages and return a list including your home page.
2. Ask Claude: "Search the wiki for 'home'" — Claude should call wiki_search and return results.
3. Ask Claude: "Create a test page at path 'test/verify' with the content 'Verification test'" — Claude should call wiki_create_page and report success. Confirm the page appears in the Wiki.js web UI.
4. Ask Claude: "Read the page at path 'test/verify'" — Claude should call wiki_get_page and return the content you just created.
5. Ask Claude: "Delete the test page at path 'test/verify'" — Claude should call wiki_delete_page and confirm deletion.

If all five steps work, your installation is fully functional.

Troubleshooting ↑ top

Wiki.js won't start — database connection error

Check that PostgreSQL is running (Get-Service | Where-Object { $_.Name -like "*postgres*" }) and that the credentials in C:\wikijs\config.yml exactly match what you set in Step 5. The most common cause is a typo in the password or database name.

Wiki.js starts but shows a blank/splash page at the root URL

This happens when no page exists at path home. Create a page with path home through the Wiki.js UI and the splash screen will be replaced.

Claude says "wikijs tools not available" or can't find the MCP

Fully quit and relaunch Cowork after editing claude_desktop_config.json — changes are not picked up by a running instance. Also verify the path to wikijs-mcp.exe in the config is correct (run pipx list to confirm the exact path).

Remote client can't reach the wiki (connection refused)

Check two things: (1) bindIP in config.yml on the server must be 0.0.0.0, not 127.0.0.1; (2) the Windows Firewall rule for port 3000 must be present on the server (see Part 5, Step 4). Restart the WikiJS scheduled task after changing config.yml.

API key stopped working

API keys have an expiry date set at generation time. If the key has expired, generate a new one in the Wiki.js admin panel (Administration → API Access) and update the WIKIJS_API_KEY value in claude_desktop_config.json on every machine. Restart Cowork on each machine after updating.

WikiJS scheduled task shows "Ready" instead of "Running" after reboot

This usually means the 30-second boot delay hasn't elapsed yet, or Node.js exited with an error. Check the task's last run result: Get-ScheduledTaskInfo -TaskName "WikiJS" | Select-Object LastRunTime, LastTaskResult. A LastTaskResult of 0 means success. Any other value means Wiki.js crashed — run node server manually from C:\wikijs to see the error output.

Quick Reference ↑ top

Key File & Path Reference

Item	Path
Wiki.js install directory	C:\wikijs\
Wiki.js config file	C:\wikijs\config.yml
Cowork config file	C:\Users\<user>\AppData\Local\Packages\Claude_pzs8sxrjxfjjc\LocalCache\Roaming\Claude\claude_desktop_config.json
wikijs-mcp binary	C:\Users\<user>\.local\bin\wikijs-mcp.exe
Wiki web UI (server)	http://localhost:3000
Wiki web UI (LAN client)	http://<server-ip>:3000
Wiki.js admin panel	http://<server-ip>:3000/a/

Available MCP Tools (wikijs-mcp 1.1.0)

Tool	What it does
wiki_search	Full-text search across all pages
wiki_get_page	Retrieve a page by path or ID
wiki_list_pages	List pages, optionally filtered by tag
wiki_get_tree	Get the full hierarchical page tree
wiki_create_page	Create a new page
wiki_update_page	Update an existing page's content
wiki_move_page	Move/rename a page to a new path
wiki_delete_page	Delete a page
wiki_list_tags	List all tags in the wiki
wiki_get_site_info	Get wiki title, host, and metadata
wiki_get_history	Get edit history for a page
wiki_get_version	Retrieve a specific historical version of a page

Useful PowerShell Commands

# Check service status
Get-Service | Where-Object { $_.Name -like "*postgres*" }
Get-ScheduledTask -TaskName "WikiJS" | Select-Object TaskName, State

# Start/stop WikiJS task
Start-ScheduledTask -TaskName "WikiJS"
Stop-ScheduledTask  -TaskName "WikiJS"

# Restart WikiJS (e.g. after config change)
Stop-ScheduledTask -TaskName "WikiJS"; Start-Sleep 3; Start-ScheduledTask -TaskName "WikiJS"

# Check what's on port 3000
netstat -ano | findstr ":3000"

# Verify MCP binary exists
pipx list

Prompt & Skill Examples ↑ top

One of the most powerful aspects of this system is that it allows you to move the entirety of Claude's persistent memory and standing instructions into the wiki — making the wiki the single source of truth for everything Claude knows about you and how it should behave. Rather than maintaining a static local file that must be manually synced across machines, every instruction, preference, skill definition, and memory item lives in one central, human-editable place. Any change you make in the wiki browser is immediately available to every Claude instance on your network at the next session start.

The three patterns below are the core building blocks of that system: a startup directive that bootstraps Claude from the wiki each session, a skill stub format that lets Claude route to wiki-hosted skill instructions, and two example skills that make reading/writing the wiki and creating new skills trivially easy.

---

1. Session Startup Directive (CLAUDE.md / User Preferences)

This is the instruction you place in Claude's persistent user preferences or your CLAUDE.md file. It tells Claude to fetch a designated wiki page at the start of every session and treat its contents as the authoritative source of standing instructions. Because the instructions themselves live in the wiki, you can update them from any browser without touching any config file.

# Session Startup

Wiki URL: http://<your-server-ip>:3000
Wiki Auth: the `wikijs` MCP is already authenticated; no key handling needed from you.
Wiki paths follow lowercase-hyphenated conventions with folder prefixes:
  `memory/`, `personal/`, `handoffs/` and so on.

At the start of every session, fetch and act on session-startup data:
call `wiki_get_page` with path="session-startup" and take any
follow-up actions dictated by that page's content.

The session-startup wiki page itself then contains everything Claude needs: standing behavioral rules, daily workflow triggers, reminders carried forward from prior sessions, machine identification steps, and any other per-session setup logic. Updating that one wiki page is all it takes to change Claude's behavior globally across all machines.

---

2. Wiki-Backed Skill Stub Format

Skills in Cowork are normally defined as local files imported via the desktop app. In this system, the local file is replaced by a thin "stub" that simply tells Claude to fetch the real skill instructions from the wiki. This means skill content is editable in the browser, versioned by wiki history, and shared across all machines automatically — no re-import needed after edits.

Each stub file follows this template:

---
name: your-skill-name
description: >
  Clear description of what this skill does and when to invoke it.
  Be specific — this description is what Claude uses to decide
  whether to route to this skill. This skill will run the
  instructions provided in the file indicated in the instructions.
---

When this skill is invoked, fetch and follow the instructions on
the wiki page at path `skills/your-skill-name` via the `wikijs` MCP.
Specifically:

1. Call `wiki_get_page` with `path="skills/your-skill-name"`.
2. Use the returned page content as the authoritative skill
   instructions and execute them.

If the wiki call fails or returns no content, print this exact
message to chat and stop:

> Skill "your-skill-name" — wiki page at
> `skills/your-skill-name` could not be retrieved.
> Expected location: http://<your-server-ip>:3000/en/skills/your-skill-name

The corresponding wiki page at skills/your-skill-name opens with a frontmatter block containing the skill's name, description, and optional tags, followed by the full Markdown skill instructions. The stub is imported once via the Cowork desktop app's Customize menu; after that, all future edits happen in the wiki with no re-import required.

---

3. The memory-wiki Skill

This skill gives Claude a clear, consistent interface for interacting with the wiki during a session — reading pages, creating new ones, updating existing ones, and searching. Without it, Claude must reason about which MCP tools to use and how to use them from scratch each time. The skill provides authoritative conventions (path naming, field usage, what to treat as the source of truth) that ensure consistent, reliable behavior across all wiki operations.

Local stub file (imported once via the Cowork desktop app Customize menu):

---
name: memory-wiki
description: "Read, write, search, update, or otherwise interact with your personal Wiki.js memory wiki. Use whenever you need to retrieve, save, or update information in the wiki. This skill will run the instructions provided in the file indicated in the instructions."
---
When this skill is invoked, fetch and follow the instructions on the wiki page at path `skills/memory-wiki` via the `wikijs` MCP. Specifically:

1. Call `wiki_get_page` with `path="skills/memory-wiki"`.
2. Use the returned page content as the authoritative skill instructions and execute them.

If the wiki call fails or returns no content, print this exact message to chat and stop:

> Skill "memory-wiki" — wiki page at `skills/memory-wiki` could not be retrieved. Expected location: http://<your-server-ip>:3000/en/skills/memory-wiki

Wiki page at path skills/memory-wiki:

---
name: memory-wiki
description: "Read, write, search, update, or otherwise interact with your personal Wiki.js memory wiki. Use whenever you need to retrieve, save, or update information in the wiki."
tags: [skill, memory-wiki, wikijs, knowledge-base]
---

# Memory Wiki Skill

This skill uses the `wikijs` MCP connector to interact with your
personal Wiki.js knowledge base.

## Important: the page body is the single source of truth

Everything Claude needs from a wiki page lives **inside the page
body** (the Markdown content). For pages that act as Claude skills
or carry structured metadata, put that metadata in a
`---`-delimited frontmatter block at the top of the body.

Wiki.js has its own separate `description` and `tags` metadata
fields used by the wiki UI (search results, page listings). Claude
does not use those fields for content — they exist only for wiki
navigation hygiene.

## If invoked with no specific request

Ask the user what they would like to do:
- **Read** a page by path or search for content
- **Create** a new page to save notes, research, or reference material
- **Update** an existing page
- **Search** across all wiki content
- **Browse** the page tree or list pages by tag

## Common Operations

### Reading a page
Use `wiki_get_page` with the page path (e.g. `memory/goals`).
Paths do not include a leading slash. Treat the page body as
authoritative.

### Searching
Use `wiki_search` with a query string. Present results as a list
with title, path, and a brief excerpt.

### Creating a page
Use `wiki_create_page`. Required fields:
- `path` — lowercase, hyphens for spaces (e.g. `memory/my-topic`)
- `title` — human-readable title
- `content` — the Markdown body (single source of truth)
- `editor` — always `markdown`
- `locale` — always `en`
- `isPublished` — always `true`

Before creating, confirm no page exists at that path.

### Updating a page
Use `wiki_get_page` first to get the current content and page ID,
then `wiki_update_page` with the ID. Always preserve existing
content unless explicitly asked to replace it.

## Page Organization Conventions
- Lowercase, hyphenated paths with logical folder prefixes
- `memory/` for persistent facts and preferences
- `handoffs/` for session-to-session project continuity docs
- `skills/` for skill definition pages
- Always set `isPublished: true`

---

4. The my-skill-creator Skill

This meta-skill automates the entire process of creating new wiki-backed skills. Rather than manually writing a wiki page and a stub file and getting the format right, you describe what you want the skill to do and Claude handles the interview, drafting, preview, confirmation, and both writes (wiki page + stub file). It enforces all naming conventions and the stub format described above, and it will not overwrite an existing skill without explicit instruction.

Local stub file (imported once via the Cowork desktop app Customize menu):

---
name: my-skill-creator
description: "Create new wiki-backed Claude skills. Use whenever you want to make a new skill — phrases like 'let's make a skill for X', 'turn this into a skill', 'I need a skill that...', or 'create a new skill'. Gathers requirements via interview, writes the wiki page and stub file after your confirmation. This skill will run the instructions provided in the file indicated in the instructions."
---
When this skill is invoked, fetch and follow the instructions on the wiki page at path `skills/my-skill-creator` via the `wikijs` MCP. Specifically:

1. Call `wiki_get_page` with `path="skills/my-skill-creator"`.
2. Use the returned page content as the authoritative skill instructions and execute them.

If the wiki call fails or returns no content, print this exact message to chat and stop:

> Skill "my-skill-creator" — wiki page at `skills/my-skill-creator` could not be retrieved. Expected location: http://<your-server-ip>:3000/en/skills/my-skill-creator

Wiki page at path skills/my-skill-creator:

---
name: my-skill-creator
description: "Create new wiki-backed Claude skills. Use whenever you want to make a new skill — phrases like 'let's make a skill for X', 'turn this into a skill', 'I need a skill that...', or 'create a new skill'. Gathers requirements via interview, writes the wiki page and stub file after your confirmation."
tags: [skill, skill-creator, meta, wiki-backed]
---

# My Skill Creator

A meta-skill for creating new wiki-backed Claude skills. The
authoritative instructions for each skill live in the wiki; a
thin stub file is imported on the desktop side so Claude can
find the skill in its manifest.

## What this skill produces

For every new skill, two artifacts are created:

1. **A wiki page at `skills/[skill-name]`** — the authoritative
   skill content. Opens with a frontmatter block (`name`,
   `description`, optional `tags`), followed by full Markdown
   instructions.

2. **A local stub file** (at a designated import folder) — a thin
   pointer that fetches the wiki page and executes its
   instructions when invoked. Import this stub once via the
   Cowork desktop app Customize menu.

## Process

**Step 1 — Interview.** Ask the user:
- What should this skill do?
- When should it trigger (what phrases would invoke it)?
- What is the expected output?
- Any edge cases or dependencies?

Gather enough detail to write complete, unambiguous skill
instructions.

**Step 2 — Pre-flight checks.**
- Verify no wiki page exists at `skills/[skill-name]`
- Verify no stub file already exists at the target path
- Abort and notify on any conflict — never overwrite silently

**Step 3 — Preview and confirm.**
Print the full proposed wiki page body and stub file contents
to chat. Ask: "Confirm and I will create the wiki page and
write the stub file." Wait for explicit confirmation before
writing anything.

**Step 4 — Execute both writes.**
- Create the wiki page via `wiki_create_page`
- Write the stub file to the designated import folder

**Step 5 — Remind the user to import the stub.**
Output the wiki page URL and stub file path, then remind the
user to import the stub via the Cowork desktop app
Customize menu.

## Conventions
- Skill names: lowercase, hyphenated, no spaces
- Wiki path: always `skills/[skill-name]`
- The description in the frontmatter block is the routing signal —
  make it specific and trigger-oriented
- One confirmation covers both writes
- On any conflict, abort and notify — do not overwrite

---

---