You have a project idea. Maybe it’s a personal website rebuild. Maybe it’s a SaaS prototype. Maybe it’s learning a new framework by building something real.
You open Claude. You start chatting. Two hours later you have fifty messages, a fragmented spec, and no idea what to build next. The context window is full. The agent is hallucinating. You’ve planned nothing. You’ve built nothing.
This is planning paralysis. It’s the fog of war — you can’t see the whole map because you’re standing in it.
Matt Pocock built a way out. He calls it Wayfinder. It’s an AI planning tool wayfinder that acts like a GPS for your project: it manages the planning sessions, splits work into parallel tracks, runs research and prototypes, and hands you a detailed spec you can actually execute.
Here’s how it works and how to use it.
The Problem: Planning Paralysis with AI Agents
AI agents are great at execution. Give them a clear spec, they’ll crank out code, docs, tests. But the spec? That’s on you.
And planning with an agent is weirdly hard. You’re trying to hold the entire project architecture in your head while also managing the agent’s context window, token budget, session depth, and handoff logic. You become a project manager for a single AI that forgets what you told it three prompts ago.
Matt Pocock noticed this. He’s the guy behind “AI Skills for Real Engineers” (220k GitHub stars, 347k YouTube subs). He builds skills — prompt-and-tool packages that give agents new capabilities. He was using agents to do overnight work: plan a bunch of stuff, create specs, spin up AFK (Away From Keyboard) agents to execute while he slept.
But the planning stage was eating his evenings. He’d have to constantly think: how many tokens am I at? How deep is this session? When do I need to spawn a fresh context?
He didn’t want to manage the planning. He wanted an orchestrator that managed the planning for him.
Meet Wayfinder: Your GPS for AI Projects
Wayfinder is a skill — a structured prompt system that gives an agent a new capability. In this case: project planning orchestration.
You invoke it with /wayfinder in your agent chat. It becomes your planning partner. You tell it the high-level goal. It:
- Creates a Map — a living document of all decisions, constraints, and context
- Breaks work into Tickets — discrete, well-scoped tasks
- Spawns Sessions — isolated agent contexts for each ticket (grilling, prototype, research, task)
- Pulls results back into the Map
- Hands you a complete spec ready for AFK execution
The metaphor is deliberate. Fog of war. Map. Tickets. Sessions. You’re the commander. Wayfinder is your operations officer. The agents are your scouts.
Core Concepts: Map, Tickets, and Sessions
The Map is the single source of truth. Every decision, every constraint, every piece of research lives here. It’s not a spec — it’s the context for the spec. When a child session needs to know “what database did we choose?” it reads the Map. When you need to remember “why did we pick Postgres?” you read the Map.
Tickets are the atomic units of work. Four types:
– Grilling tickets: Standard agent sessions for implementation work
– Prototype tickets: Quick proofs of concept, spike solutions
– Research tickets: Information gathering, API docs, comparisons
– Task tickets: Human work — things the agent can’t do (buy a domain, approve a design, write a check)
Sessions are the isolated execution contexts. Each ticket gets its own session. The session inherits the Map + its specific Ticket. It does the work. It reports back. The Map updates. No context pollution. No token bloat.
Leading Words — this is the secret sauce. Pocock insists on precise terminology. Not “task,” not “job,” not “work item.” Ticket. Not “plan,” not “doc,” not “context.” Map. Not “run,” not “execution,” not “agent.” Session. The agent learns these words. When you say “create a research ticket,” it knows exactly what structure to produce. Fuzzy language creates fuzzy behavior.
What You Need to Get Started
- Claude Desktop (or any agent that supports skills/MCP)
- Git (to clone the skill)
- Basic comfort with command line
- A project idea that feels too big to plan in one sitting
That’s it. No API keys. No cloud services. The AI planning tool wayfinder runs locally in your agent.
Step 1: Install the Wayfinder Skill
The skill lives in Matt Pocock’s GitHub organization. Clone it:
git clone https://github.com/mattpocock/wayfinder-skill.git
cd wayfinder-skill
The repo contains the skill definition (a structured prompt), example Maps, and documentation. Installation depends on your agent:
For Claude Desktop with MCP:
Add to your claude_desktop_config.json:
{
"mcpServers": {
"wayfinder": {
"command": "node",
"args": ["/path/to/wayfinder-skill/dist/index.js"]
}
}
}
For other agents: Copy the skill prompt from skill/prompt.md into your agent’s system prompt or skill registry.
Restart your agent. Type /wayfinder — you should see the skill activate.
Step 2: Understand the Three Ticket Types
Before your first project, internalize the ticket types. This is where most people go wrong — they make everything a grilling ticket.
Grilling tickets = “Build this feature.” The agent writes code, creates files, runs tests. Use when the approach is clear.
Prototype tickets = “Figure out if this approach works.” The agent builds a minimal spike, throws it away, reports findings. Use for technical unknowns: “Can we stream PDF parsing with this library?” “Does this auth pattern scale?”
Research tickets = “Find the answer to this question.” The agent reads docs, compares options, summarizes tradeoffs. Use for decisions: “Which ORM for this stack?” “What’s the rate limit on this API?”
Task tickets = “You do this.” Human actions. “Register the domain.” “Review the Figma file.” “Deploy to staging.” The agent tracks them but can’t execute them.
Every ticket in your Map should have a type. If you can’t decide, it’s probably a research ticket.
Step 3: Plan Your First Project in the Fog of War
Let’s walk through a real example: rebuilding a personal website with a blog, portfolio, and contact form.
You: /wayfinder I want to rebuild my personal site. Next.js, TypeScript, Tailwind, MDX for blog, deployed on Vercel. I have a Figma design. I don't know which CMS to use for the blog — maybe local MDX files, maybe a headless CMS. I also want to add a tiny game as an easter egg.
Wayfinder creates the Map:
– Project: Personal site rebuild
– Stack: Next.js 14, TS, Tailwind, MDX, Vercel
– Design: Figma (link in Map)
– Open decisions: CMS choice, easter egg game concept
– Constraints: Must be fast, accessible, SEO-friendly
Wayfinder creates tickets:
1. Research ticket: Compare MDX file-based vs headless CMS for blog
2. Prototype ticket: Test MDX + next-mdx-remote performance
3. Prototype ticket: Test Contentful free tier for blog
4. Grilling ticket: Set up Next.js project with Tailwind + TypeScript
5. Grilling ticket: Implement design system from Figma (colors, spacing, components)
6. Grilling ticket: Build blog layout with MDX rendering
7. Research ticket: Find simple canvas/WebGL game tutorial for easter egg
8. Prototype ticket: Build minimal game prototype
9. Grilling ticket: Integrate game as hidden route
10. Task ticket: Buy/configure domain
11. Task ticket: Deploy to Vercel, configure DNS
Each ticket gets a priority, estimated effort, and dependencies. The Map shows the full picture.
Step 4: Run AFK Agents with Generated Specs
Here’s the payoff. Once the Map is complete and tickets are defined, the AI planning tool wayfinder can generate execution specs for each grilling ticket.
Each spec includes:
– Exact file structure to create
– Components to build with prop interfaces
– API routes to implement
– Tests to write
– Dependencies to install
– Acceptance criteria
You copy a spec. Paste it into a fresh agent context. Say “Execute this spec.” The agent builds it. No planning needed. No context management. Just execution.
Run three agents in parallel overnight. Wake up to a working codebase.
Pro Tips: Leading Words and Context Management
Use the vocabulary. Say “create a research ticket” not “look into this.” Say “update the Map” not “note this down.” The skill responds to its own language.
Keep the Map current. After every session, Wayfinder updates the Map. But you should review it. Add context the agent missed. “We decided against Contentful because of pricing” — put it in the Map. Future sessions will see it.
Scope tickets small. A grilling ticket should be completable in one agent session (20-50 messages). If it’s bigger, split it. “Build the entire blog” is too big. “Build the blog post list component” is right.
Use prototype tickets aggressively. Uncertainty kills velocity. A 20-minute prototype ticket saves a 3-hour grilling session on the wrong approach.
Task tickets are reminders. They don’t execute. But they prevent “oh right, I needed to configure DNS” moments at launch time.
The Map is your handoff document. When you come back to the project in two weeks, you don’t re-read fifty chat messages. You read the Map. You know exactly where you are.
Takeaway: Stop Planning, Start Building
Wayfinder doesn’t eliminate planning. It makes planning parallelizable and trackable. You’re not staring at a blank screen wondering where to start. You’re directing an operation: research here, prototype there, build this, decide that.
The fog of war clears one ticket at a time.
Install the skill. Pick a project you’ve been putting off because “the planning is overwhelming.” Invoke /wayfinder. Watch the Map appear.
Your agents are waiting for orders. Give them a Map. They’ll handle the rest.
