997: Rating and Roasting Your Projects

Summary of 997: Rating and Roasting Your Projects

by Wes Bos & Scott Tolinski - Full Stack JavaScript Web Developers

53m•April 20, 2026
Listen to Episode

Overview of 997: Rating and Roasting Your Projects

Hosts Wes Bos and Scott Tolinski run a highlight episode where they read, review, and “roast” projects submitted by listeners and things they’ve found. The conversation is a rapid-fire tour of small utilities, AI-agent tooling, dev UX improvements, and fun side projects — with recurring themes around AI agent determinism, sandboxing, tooling bloat, and developer ergonomics.

Key projects covered (what they are + why they matter)

Developer utilities & extensions

  • JSON Alexander — Wes’s Chrome extension for viewing JSON (collapse/expand, console access). Built to avoid tracking/ad injection in other extensions.
  • FFF — Very fast file-search toolkit intended for AI agents or local code search (live-grep like performance; plugins and Node integrations exist).
  • View Transitions Toolkit (by Bramis / Chrome team) — helper library for view transitions and scroll-driven animations, includes playback controls, measuring tools, and automatic from/to injection.
  • AeroJS (Arrow.js mentioned) — sandboxed UI rendering via WebAssembly workers so agents can generate UI safely while streaming interactions between host and sandbox. Good for agent-generated interfaces without iframe limitations.
  • Agentation & Svelte-agentation — browser-based UI for leaving annotated feedback tied to components (can create structured feedback that agents can act on); original React-first but Svelte ports exist.
  • Motion/Design tool (by Matthew Perry) — a paid visual dev-tool that hooks into agents and allows in-browser property edits + motion/keyframe controls (an IDE-like experiment for visual editing).
  • OpenCode Sentry monitor plugin — integrates Sentry’s agent monitoring (traces, tool calls, token usage) into OpenCode to inspect agent performance and costs.
  • DEX / decks (dex.rip) — lightweight JSON-based task/epic system intended to persist AI-generated tasks in a repo (committable, deterministic task lists for agents).
  • Fallow (docs.fallow.tools) — Rust-native code analyzer for dead code, circular deps, duplication, complexity hotspots; integrates with CI/quality gates.
  • Drift (Fiberplane) — bind specs to code and detect documentation/spec drift.

Content & media tooling

  • Comark — streaming-ready Markdown parser that supports components across Vue/React/Svelte/HTML/ANSI; MDX-like but framework-agnostic and streaming-friendly.
  • EditMind — local video knowledge base: transcribe, frame-analyze, embed/process video for searchable/video-aware content (useful for searching large video archives).
  • Remotion (discussed) — context about generating video from components and the need to scrub frames for rendering.

Quick utilities & UX

  • Peakdown.app — Quick Look plugin to render Markdown files in macOS quick preview.
  • Sugar High — ultra-lightweight (~1 KB) syntax highlighter with simple CSS configuration and remark plugin.
  • ProxyBox — hardware tool to proxy devices and make offline devices accessible (PCB / hardware prototyping mention).
  • Silly Software Club — collection of small “fun” projects for creative burnout relief.

Fun / novelty

  • PeonPing (peonping.com) — give your AI agent a voice (Warcraft/RTS character lines) for amusing agent audio feedback.

Main themes & takeaways

  • Determinism matters: Tools that produce deterministic, committable artifacts (e.g., JSON task files, DEX epics) are more reliable than ephemeral agent “ideas.”
  • Agent workflows need human-in-the-loop review: Scott recommends a mode where agents stop after each task and wait for manual review to prevent accumulating low-quality code.
  • Sandboxing is essential for agent-generated UI: WASM-based sandboxes (AeroJS) are promising for safely rendering agent-created HTML/CSS/JS without full iframes.
  • Monitor agent cost/behavior: Sentry-style tracing of LLM calls, tools, token usage, and duration is crucial to optimize agents and reduce waste.
  • Trim cruft & drift: Agents often create unnecessary duplicate artifacts and drift documentation — run tools like Fallow and Drift to catch problems early.
  • Lightweight, focused tools win for ergonomics: Tiny utilities like Sugar High or Peakdown can fix specific pain points faster than heavy all-in-one solutions.
  • Playful projects matter: Silly projects are great for learning, keeping energy up, and discovering unexpected ideas.

Notable quotes & practical heuristics

  • “Make it red / make it pop” — recurring joke illustrating typical non-specific feedback; motivated building feedback tooling that captures context.
  • “Scott in the loop” — practical rule: enforce a pause-and-review step in agent-driven work to maintain code quality.
  • “The future of code search is not regex” — rationale behind FFF and vectorized search for agent workflows.

Actionable recommendations (if you want to apply these ideas)

  • If you use AI agents:
    • Add monitoring (token counts, model/duration, tool calls) via Sentry or similar.
    • Persist plans/tasks in a repo-friendly format (DEX or JSON) so agents have deterministic work items you can audit.
    • Use a “stop after task” policy until the agent’s outputs consistently meet standards.
  • If you build or evaluate agent UI:
    • Prefer sandboxed rendering (WASM/iframe with strict limits) rather than injecting raw HTML/CSS/JS.
    • Provide a framework-agnostic component syntax or docs so agent-generated UI is portable (Comark, AeroJS approach).
  • For everyday dev ergonomics:
    • Try a faster local file search (FFF) and a focused linter/analyzer (Fallow) to reduce time hunting files and rot.
    • Use small tools for specific problems (Quick Look Markdown, tiny syntax highlighters) to reduce dependency bloat.
  • For teams worried about documentation drift:
    • Bind specs to code and run automated drift checks (e.g., Drift).
    • Keep key plans/specs committable in the repo (not only in ephemeral agent UIs).

Resources mentioned (projects to explore)

  • JSON Alexander (Wes’s Chrome extension)
  • FFF (fast file search)
  • View Transitions Toolkit (Bramis / Chrome team)
  • AeroJS / Arrow.js (WASM sandboxed rendering)
  • Agentation / Svelte-agentation
  • Motion (design tool by Matthew Perry)
  • PeonPing (peonping.com)
  • Peakdown.app
  • Dex / decks (dex.rip)
  • OpenCode Sentry monitor plugin
  • Comark
  • SillySoftware.club
  • Sugar High (tiny syntax highlighter)
  • Drift (Fiberplane)
  • Fallow (docs.fallow.tools)
  • EditMind (local video knowledge base)
  • ProxyBox / PCB tooling
  • Remotion, Canvid HQ, Open Screen (video editor tools)

Final note

The episode is a rapid showcase — many lightweight, practical projects and one-off experiments were presented. The recurring practical value: favor deterministic, auditable workflows for agents; use monitoring and sandboxing; and don’t forget to build silly things for fun and learning.