Create a Cowork Navigator Skill for Claude Sessions

By Yanni Papoutsis | 6 min read | 2026-06-11

A Cowork navigator skill is a session-bootstrap skill that runs on the first message of every Claude session: it loads your memory and context files, checks what prior sessions already produced, and auto-loads the companion skills the task will need. Without it, every session starts from zero; with it, Claude starts every session knowing your projects, your conventions, and what happened yesterday.

TL;DR: Claude sessions are stateless by default, so the first ten minutes of every session get wasted re-explaining context, and Claude occasionally redoes or contradicts prior work. The fix is a navigator skill whose description tells Claude to load it on effectively any first message. The skill body is a four-step bootstrap: read a memory index file, scan the working folders for prior outputs on the current topic, load the companion skills that match the task type (file organisation rules, token budget rules, claim verification rules), and confirm the plan in one short paraphrase before executing. You write it as one SKILL.md plus a references folder, install it as a .skill zip or inside a plugin, and maintain a small, curated memory index rather than a sprawling dump. Full template below.

What does a Cowork navigator skill actually do?

It turns session startup into a deterministic checklist instead of a vibe. On the first message of a session, the navigator does four things in order: load memory, check prior work, load companions, confirm the plan.

Each step kills a specific failure mode:

Bootstrap step Failure it prevents
Load memory index Re-explaining projects, stacks, and conventions every session
Check prior work Duplicate or contradictory outputs across sessions
Load companion skills Inconsistent file naming, token waste, unverified claims
Paraphrase and confirm Ten minutes of work in the wrong direction

Skills are the right mechanism for this because their frontmatter description controls when Claude loads them, as documented in the Claude documentation. A navigator simply uses an aggressively broad description so it loads first, then delegates to narrower skills.

How do you create the navigator skill step by step?

Create a skill folder, write a trigger-everything description, write the four-step bootstrap body, then add the memory and companion reference files. Here is the full build.

Step 1: Create the folder

mkdir -p cowork-navigator/references

cowork-navigator/
  SKILL.md
  references/
    companions.md     # which skills to load for which task types
    memory-format.md  # how memory entries are structured

Step 2: Write the SKILL.md

name: cowork-navigator
description: Session bootstrap. Load on the FIRST user message of every session, no exceptions. Loads memory, checks prior work, auto-loads companion skills. Trigger on: any task involving building, fixing, writing, researching, deploying, exporting, organising, or deciding.

# Cowork Navigator

Run these steps in order before starting the user's task.

1. Memory: read memory/index.md. Load only entries whose tags
   match the current task. Never load the whole memory folder.
2. Prior work: list the project output folder. If a file matches
   the current topic, read it and treat it as the starting state.
3. Companions: open references/companions.md and load every skill
   mapped to this task type.
4. Confirm: paraphrase the task and the plan in two sentences,
   then proceed unless corrected.

Rules:
- Total bootstrap reading budget: 300 lines. Summarise, never paste.
- If memory contradicts the user, the user wins; update memory.
- Log one line to memory/index.md at session end: date, task, outcome.

The description field does the heavy lifting. List concrete verbs because Claude matches descriptions against the user's actual phrasing; vague descriptions are the number one reason skills fail to load, a point I cover in the plugin pillar guide.

Step 3: Define the memory index format

Keep memory small, indexed, and tagged. The navigator reads the index, not the archive:

# memory/index.md

| date | tags | entry |
| --- | --- | --- |
| 2026-06-08 | blog, astro | Blog lives in src/content/blog, deploys via Cloudflare Pages |
| 2026-06-09 | naming | Files use ddmmyyhhmm_v### prefix, see file-organization skill |
| 2026-06-10 | pipeline | Product pipeline plugin at v1.2.0, gates in gates/ |

Step 4: Map companion skills

The companions file is a routing table from task type to skills:

# references/companions.md

| Task type | Load these skills |
| --- | --- |
| Any file output | file-organization |
| Long session, big files | token-budget |
| Factual or research content | anti-hallucination |
| Web pages or blog posts | seo-ai-checklist, website-checklist |

The point of routing is discipline in both directions: the right skills always load, and unneeded skills never do. The companions in my own setup are documented as separate guides: the file organization skill, the token budget skill, and the anti-hallucination skill.

Step 5: Package and install

zip -r cowork-navigator.skill cowork-navigator

Share the .skill file in Cowork and save it when prompted, or bundle it into a plugin alongside its companions so one install delivers the whole system. Then test it cold: open a brand new session, type a one-line task, and check that Claude's first action is reading the memory index, not answering.

How do you keep the bootstrap from eating your context window?

Budget it explicitly: the navigator should spend no more than a few hundred lines of reading before real work starts. The 300-line budget in the template is enforced by three habits: read indexes instead of archives, summarise instead of pasting, and load companion references on demand rather than at bootstrap.

If your memory index grows past one screen, prune it into dated archive files and keep only durable facts in the index. Stateless model behaviour and context limits are well covered in Anthropic's writing on agent design at anthropic.com; the practical translation is simple: everything the navigator loads is a tax on the session, so make every loaded line earn its place.

Frequently asked questions

How is this different from Claude's built-in memory?

Built-in memory is useful but opaque: you do not control exactly what loads or when. A navigator skill makes session bootstrap explicit, versioned, and portable across Cowork and Claude Code, and it routes to companion skills, which built-in memory does not do.

Will the navigator load on literally every message?

It loads once per session, on the first message that matches its description, which is deliberately almost everything. After bootstrap it stays out of the way; the per-message cost is zero because skills load once into context.

What belongs in memory versus in a skill?

Durable preferences and project facts belong in memory (stack choices, naming rules, deploy targets). Procedures belong in skills (how to name files, how to verify claims). If you find procedure text in your memory index, move it into a skill and leave a one-line pointer.

Can I use the navigator without any companion skills?

Yes, steps 1, 2, and 4 still pay for themselves immediately. Add companions as they prove necessary; the routing table makes them one line each to adopt.

About the author

Yanni Papoutsis builds AI products, automation pipelines, and technical documentation with Claude, and publishes free tooling and guides at yanni.uk.

Next step: Bundle your navigator with companions into one install using the plugin from scratch guide, and explore 1,000+ free AI tools at yanni.uk/ai-tools/.

Sources