Navigating Ambiguity in Agentic Workflows: A Deep Dive into Matt Pocock’s /wayfinder Skill
In the evolving landscape of agentic workflows, a primary challenge for developers is not just executing tasks, but defining them. When working with Large Language Models (LLMs), we often encounter two distinct phases of development: the execution phase, where requirements are clear, and the discovery phase, where the project scope is nebulous. While tools like grill me excel at refining known plans, a new tool in Matt Pocock’s skill repository, /wayfinder, addresses the much harder problem of high-level architectural discovery and pathfinding.
The Taxonomy of Agentic Skills: Grilling vs. Wayfinding
To understand the utility of /wayfinder, one must first distinguish it from its predecessor skills, specifically grill me (and its variants like grill with dogs).
In a standard agentic loop, grill me serves as an interrogation layer. Its purpose is to interview the user about a pre-defined prompt or plan. The goal here is "filling in the blanks"—ensuring that the developer and the agent share a synchronized vocabulary and that no edge cases are missed during the implementation phase. It is a refinement tool used when you know what you are building but need to solidify the how.
/wayfinder, however, operates one level higher in the abstraction hierarchy. It is designed for the "pre-plan" stage—the period where a developer has an outcome or a problem in mind (e.g., "I need harder benchmarks for my LLM coding leaderboard") but lacks a defined technical trajectory. The project might be too large for a single agent session, and the fundamental architecture (CLI vs. Web App vs. Skill) remains undecided. Wayfinder acts as a brainstorming partner that navigates through various potential destinations by iteratively narrowing the search space.
Orchestration Architecture: How Wayfinder Operates
The technical sophistication of /wayfinder lies in its ability to orchestrate multiple specialized skills to reach a state of "shared understanding." It does not operate in isolation; rather, it acts as an orchestrator for other sub-skills within the repository, such as domain modeling and grilling.
The workflow follows a structured, iterative discovery process:
- Initial Input & Context Injection: The user provides a vague, high-level objective (often via voice-to-text tools like Whisper).
- Iterative Questioning (Round 1): Wayfinder executes an initial batch of questions (typically around six) to probe the boundaries of the idea. This stage is designed to surface latent requirements—for instance, suggesting a move toward Rust or Python if the user's current stack lacks them.
- Path Narrowing & Refinement (Round 2): Based on the responses from Round 1, Wayfinder narrows the "map." It identifies potential destinations and executes a second round of deeper, more specific questions to resolve remaining ambiguities in the tech stack or task type.
- Artifact Generation: Once the path is identified, Wayfinder does not merely provide text; it generates tangible engineering artifacts. This includes:
.scratchfiles for persistent state.- Markdown-based issue tracking (e.g.,
issues.md). - A "Map" of decisions and potential trajectories.
Case Study: Hardening LLM Coding Benchmarks
To demonstrate the efficacy of /wayfinder, consider a real-world engineering challenge: hardening an LLM coding leaderboard. As models like Claude 3.5 Sonnet reach near-perfect scores on existing benchmarks, developers must find increasingly difficult tasks to maintain the integrity of the evaluation.
Using Wayfinder, the process began with a vague desire for "more difficult challenges." Through its iterative questioning, Wayfarer suggested exploring Python-to-Rust ports—a high-complexity task involving cross-language compilation and logic translation.
The skill then transitioned from discovery to execution by launching background agents. These agents were tasked with technical research, specifically looking into SWE-bench and other industry-standard benchmarks to determine the feasibility of these new tasks. The result was a structured backlog: a set of "tickets" (not GitHub issues, but agentic instructions) that are explicitly blocked by previous research tasks. This creates a dependency graph that an agent can follow sequentially.
State Management and Agentic Continuity
One of the most critical technical advantages of Wayfinder is its approach to context management. In long-running development cycles, token limits and context window saturation are significant bottlenecks.
Wayfinder mitigates this by creating a "map" and saving work into persistent files. This allows a developer to stop an agent session once the discovery phase is complete and resume it in a new session using the generated artifacts as the new ground truth. The skill essentially provides a way to checkpoint the "brainstorming" state, ensuring that the transition from high-level ideation to low-level implementation is seamless and contextually aware.
Conclusion: The Shift Toward Conversational Agency
The emergence of skills like /wayfinder highlights a broader shift in AI interaction. As noted by industry leaders like Boris at Anthropic, we are moving away from highly structured prompt engineering toward a paradigm where the agent functions as a "co-worker." In this new era, the skill lies not in how you structure your initial instruction, but in how effectively you can use specialized agentic tools to navigate through ambiguity and arrive at a concrete, executable plan.
Whether you are using Wayfinder for architectural discovery or grill me for implementation refinement, the goal remains the same: reducing the entropy of human intent as it is translated into machine-executable code.