LIVE: The /wayfinder Demo

Tech/Product Focus: Wayfinder (“grill-me on steroids” for spec-first agent workflows)

The speaker introduces Wayfinder as an “evolution of Grill Me,” positioned as an orchestrator that:

• Takes a broad requirement and creates a “map” (a decision graph).
• Resolves open decisions via smaller “grilling sessions” (agent sub-workflows), rather than directly implementing code.
• Produces a spec (“to spec” step) that can be handed to implementation agents, instead of building immediately.

Wayfinder also:

• Creates GitHub issues (subtasks/sub-issues).
• Uses blocking relationships to manage dependencies.
• Can degrade to normal grilling if the scope doesn’t require a full map.

Demo Goal: Add “TikTok creator / TikTok shorts” Capabilities to an Existing Video System

The demo project extends the speaker’s course video manager (CVM) to support:

• TikTok creator output as vertical portrait clips (TikTok-style shorts).
• Reuse of existing “normal videos” logic, but with a new/alternative video player/rendering/editor view.

Core design preference:

• Low-friction creation of TikTok concepts: no required “pitch” link (pitches are for longer-form; TikTok should be “idea → go”).
• TikToks should likely be modeled as an attribute of existing video records (via the existing videos table), with careful thought about UI/table implications.

Key Data Model / Schema Discussions

There is already a videos table concept (e.g., fields like ID, lesson ID, picture ID).

The demo explores adding a TikTok-specific attribute such as:

• Format/intent rather than a simple boolean (“short” vs “landscape”).

Engineering rationale:

• Prefer enums over booleans for extensibility, since booleans would “explode” into unmanageable combinations as new categories appear.

“To Spec” Workflow and Ticket Lifecycle

The overall flow described:

1. Wayfinder map (decision exploration)
2. To spec (renamed from what sounds like earlier “2 PRD” terminology)
3. To tickets (implementation task breakdown)
4. Implements → code review → human review

The speaker emphasizes:

• Decision tickets: resolved only by making the actual design decision.
• Implementation tickets: about reifying those decisions in code.

Parallel Research + Progressive Disclosure

Wayfinder spawns multiple agent-driven sessions in parallel:

• Research tasks run as separate sub-agents.
• Results feed into decision tickets.
• Research findings are saved and referenced via links (e.g., docs pages created/used during research).

A key demo theme is “fog reduction”:

Research updates the map and unblocks subsequent decisions.

Prototyping Phase: “Prototype Skill” to Raise UI Fidelity Quickly

A major part of the demo uses Wayfinder’s prototyping capability to:

• Create higher-fidelity UI variants (e.g., Studio/editor views) before committing to the spec.
• Use a Remotion-like pipeline and demonstrate interactive editing.

The speaker uses variants (A/B) to select editor UX concepts, such as:

• Editor layout changes (e.g., right-side player vs tabs/panel).
• Caption editing: deciding between explicit caption editing vs relying on the rendering pipeline’s own captions.
• “Render vs posted” UI concerns (not fully representable in schema yet, likely requiring additional decision work).

Rendering + Captioning Pipeline (Remotion Prior Art)

The speaker references TypeScript monorepo prior art for:

• A vertical render pipeline
• Burned-in captions via Remotion

They discuss whether to:

• Keep Remotion in a separate repo vs
• Pull parts into CVM

Concerns and suggestion:

• Monorepo complexity and old dependencies are a problem.
• Prefer keeping it “arm’s length” and invoking it rather than merging immediately.

Platform Posting: TikTok + YouTube Shorts

The spec target includes:

• Posting to TikTok and YouTube Shorts
• Lifecycle tracking: where posted content state is stored
• Moving beyond booleans: storing platform identifiers/URLs per post

The demo notes the system must support:

• Different export statuses (export/render vs posted/audited)
• A local workflow where render runs locally (not remote lambda, per the speaker)

Real Blocker Discovered: TikTok “Public Posting Audit Gate”

A concrete integration constraint arises:

• TikTok treats posts as “un-audited” until audit/review.
• There are mandated content sharing guidelines UX/requirements before TikTok will review.

Proposed workaround:

• Use a queue/relay approach (previously used Buffer workflow), e.g.:
  • upload via an intermediary (Dropbox → Zapier → Buffer)
  • then post from there

This likely requires a new decision ticket to assess feasibility and costs.

Operational / Tooling Insights From the Demo

The speaker uses Claude Code / Claude agents and describes an agent architecture conceptually:

• Model + harness (different tools/LLM integrations)
• plus environment (filesystem/codebase/etc.)

Other operational notes:

• They prefer Opus 4.8 “medium” as a cost/latency/quality tradeoff.
• They mention using worktrees locally and call out the operational pain of managing:
  • state
  • dependencies
  • per worktree

They suggest that cloud/sandboxes would help.

Closing: How Wayfinder Output Becomes Shipped Work

The speaker outlines what they would do next:

• Finish Wayfinder map
• Convert to spec (to spec) → close map
• Convert spec to implementation breakdown (to tickets)
• Implement each subtask in separate context windows
• Do code review over the combined diff, then human review

The demo emphasizes traceability:

Wayfinder map decisions link out to research and tickets, enabling end-to-end accountability.

Main Speakers / Sources

• Primary speaker: Demo presenter (creator/author of the skills repo and CVM tooling; using Opus 4.8 and Claude Code/agents)
• Systems/tools used as workflow sources:
  • Wayfinder, To spec, To tickets
  • Claude Code / Claude agents
  • Remotion prior art
  • TikTok API / posting workflow constraints
  • Buffer/Zapier (proposed workaround)
  • GitHub issues/PRs