The argument in one line.
A vague feature idea becomes a build-ready spec faster when an orchestrator breaks the fog into many small, parallel question-and-answer sessions and tracks every unresolved decision as its own ticket.
Read if. Skip if.
- You already code with an AI agent and keep hitting the wall where a big feature is too fuzzy to hand off in a single planning session.
- You want a repeatable planning workflow that ends in a written spec, not a pile of half-remembered decisions in a chat log.
- You are comfortable driving an agent hard during planning and want to see what running four question sessions in parallel actually looks like.
- You are weighing enum-versus-boolean, where-does-it-live, and other schema decisions on a brownfield app and want to watch someone resolve them out loud.
- You want a copy-paste tutorial with exact commands; this is a live demo of a personal workflow, not a step-by-step guide.
- You are looking for autonomous end-to-end code generation; this stream deliberately stops at the spec and never ships the feature.
- You do not use an agentic coding tool and are not planning to adopt one.
The full version, fast.
Wayfinder is a planning orchestrator that sits above single AI grilling sessions. You dump a fuzzy feature idea, it explores the codebase, then charts a map of the open decisions and opens each one as a GitHub issue. You resolve those decisions by running several grilling sessions in parallel, spawning prototype and research sub-tickets as questions get sharper, and adding new tickets to the map whenever you spot fresh work. The output is not code; it is a dense spec that links back to every decision and its evidence, which you then hand to a separate to-spec session and, later, to an AFK implementation agent. In the demo the target is a TikTok/Shorts creator inside an existing course-video app, and eight of nine decisions land before time runs out, including a real blocker: TikTok's posting API requires an audit, so the plan pivots to posting through Buffer instead.
Chat with this breakdown — free.
Sign in and you get 23 free chat messages on us — ask for the hook, quote a framework, find the exact transcript moment, generate a markdown action plan. Bring your own key when you want unlimited.
Create a free account →Where the time goes.

01 · Cold open
Intro to the stream and the plan: use Wayfinder for the next hour to spec a feature he has wanted to build.

02 · First dictation
Braindumps the idea by voice: a TikTok creator inside his course-video app that reuses existing videos with a new player and upload paths.

03 · Grilling begins
Wayfinder explores the codebase then grills the destination, what a 'TikTok video' actually is, and whether it relates to pitches.

04 · The workflow chain
Shows the new skill flow: grill-with-docs or wayfinder, then to-spec, to-tickets, implement, code-review.

05 · Model, harness, environment
Whiteboards the mental model: the model is a small core; the harness and environment around it are free levers most people ignore.

06 · The map and nine tickets
Wayfinder writes a terse map and opens nine decision sub-issues as real GitHub issues, then starts spawning research agents.

07 · Four parallel grillings
Opens several grilling sessions at once in one Claude Code window and manages them as they come back ready.

08 · Enum over boolean
Resolves the video 'format' attribute as an enum with standard and short, arguing against a boolean because categories tend to grow.

09 · First prototypes
Raises fidelity with a clickable press-to-talk TikTok creation UI and picks between variant A and B.

10 · Research returns; where it lives
Upload-API research for each platform resolves and closes; decides TikToks get a dedicated top-level sidebar item.

11 · Studio editor prototype
A portrait-player editor prototype that reuses the existing video-editing reducer and UI, with an action menu copied from the current editor.

12 · Render and caption pipeline
Keeps the exact Remotion caption look, extracts the renderer into its own standalone repo, and shells out to it from the app.

13 · Posting lifecycle and the TikTok blocker
Designs a per-platform post record, then hits TikTok's audit gate and pivots the plan to posting through Buffer instead.

14 · Wrap: map to spec
Eight of nine decisions resolved; explains handing the map to to-spec, then to-tickets, then AFK implementation and a final code review.

15 · Sign-off and CTA
Shows a finished spec that produced a roughly 5000-line PR, points to the ask-Matt skill, and invites viewers to subscribe to the skills.
Lines worth screenshotting.
- Planning fails most often because the agent never asks what you value; surfacing your priorities is the point of a grilling session, not a side effect.
- Break one big feature into many small question sessions and run them in parallel, and you resolve the decision frontier faster than one long session ever could.
- The output of good planning is a written spec that links back to every decision, not a chat log you have to reconstruct later.
- During planning you are the lead and the agent is the junior; passive operators get drift, and drift is your fault, not the model's.
- Prefer an enum over a boolean for any category that could grow a third value, because three booleans encode six impossible states while one enum encodes exactly three.
- Swapping the model is only one lever; improving the harness and the environment the agent works inside is free and often buys more.
- Raising fidelity with a throwaway prototype resolves 'what should it look like' questions that no amount of talking in text ever will.
- Prototyping always burns context because the agent reads and writes many files, so expect sessions to climb toward 200k tokens.
- A decision ticket can only be closed by making the decision; an implementation ticket is closed when that decision is written into code.
- Medium reasoning effort trades a little quality for much lower latency and token cost, and is smart enough for almost every step of a planning workflow.
- Brownfield versus greenfield is overstated; a good planning workflow handles an existing codebase about as well as a blank one.
Turn fog into a spec before you write code.
The gap between a vague idea and shippable code is a set of unresolved decisions, and the fastest way across is to name each one, resolve it out loud, and write down the answer.
- Treat planning as decision-clearing, not code-writing; the deliverable is a spec that records every choice and links back to its evidence.
- Break a large feature into many small question sessions and run several at once, so the decision frontier collapses in parallel instead of one slow line.
- Drive the agent during planning instead of watching it; the quality of a plan tracks how hard you push back on vague or wrong suggestions.
- When a question is really 'what should it look like', build a throwaway prototype and react to it, because you cannot resolve visual decisions in text.
- Reach for an enum over a boolean whenever a category might gain a third value later; booleans multiply into impossible states, enums stay finite.
- Separate the decision from its implementation; a decision is done when you have chosen, and only later is it done when the code reflects the choice.
- Remember the model is one lever among three; the harness and the environment the agent runs in are free to improve and often matter more.
- Surface your own priorities early, because most AI misalignment is the agent never learning what you actually value.
- Expect real-world blockers to reshape the plan; here a platform's posting rules killed direct integration and pushed the design toward a third-party queue.
Terms worth knowing.
- Wayfinder
- A planning skill that orchestrates multiple AI question-and-answer sessions to chart a path from a vague idea to a finished spec, tracking each open decision as its own ticket. It degrades to a single grilling session when the work is small enough not to need a map.
- Grilling session
- An AI session whose job is to interrogate you about a decision until it is fully specified, rather than to write code. Wayfinder is described as this pattern scaled up across many sessions at once.
- Decision ticket vs implementation ticket
- A decision ticket is resolved only by making a choice, such as which schema attribute to use. An implementation ticket is resolved when that choice is actually written into the code. Wayfinder produces the first kind; a later tickets step produces the second.
- Spec
- A detailed written specification of what to build and why, assembled from resolved decisions before any implementation begins. Here it is the deliverable that gets handed to a separate implementation agent.
- Prototype (raising fidelity)
- A throwaway, often clickable UI generated mid-planning so you can react to something visual instead of debating in text. Used to answer 'what should it look like' questions quickly.
- Harness
- The software wrapped around a model that turns it into an agent, such as the coding tool that manages context, tools, and turns. Distinguished from the model itself and from the environment the agent acts in.
- Worktree
- A separate working copy of a git repository, letting you run several parallel branches of work at once. In the stream it is the source of most friction because each copy needs its own dependencies and environment set up.
- Audit gate (TikTok content posting)
- A platform requirement that every post from an unaudited app is forced private and locked behind mandated sharing-guidelines UI until the platform reviews and approves the app. It turns direct posting into a heavy compliance task.
Things they pointed at.
Lines you could clip.
“So many people are really passive with the agents when they're in this phase. You need to be on top of them. You're the lead. They're the junior.”
“Everyone talks about swapping out the model. It's just a small part of the picture. You can also make the harness better, or the environment the agent acts in, and that's free.”
“It would be very easy for a junior to just say let's use a boolean here. But what happens when you add a third type? Three booleans is six possible states. An enum is three.”
“So much of the misalignment from AI is the AI not asking these questions, not understanding what you value, what you prioritize.”
Word for word.
Don't just watch it. Burn it in.
See every word as it's spoken — crank it to 2× and still catch all of it. The same dual-channel trick behind Amazon's Kindle + Audible.
The bait, then the rug-pull.
The pitch is small and the promise is large: one hour, one vague idea, and a tool the host calls an absolute banger. What follows is not code but a method for turning fog into a spec, narrated live while four AI sessions grill him in parallel.
How they asked for the click.
“If you want to keep up to date with this stuff, go to AI Hero and subscribe to my skills. And if you have questions, use my ask Matt skill.”
Soft and late; the demo delivers value for over an hour before any ask, and the CTA points to the open-source skills that the whole stream implicitly promotes.

































































