Overview of Syntax Episode 1051: Mourning the Death of Code
This potluck episode covers a wide range of practical AI-development questions, mostly centered on how developers should work with coding agents without losing control of context, quality, or their own technical judgment. Wes and Scott discuss handoffs between agents, whether AI-generated “skills” are useful, how to preserve design fidelity from Figma to code, what technical skills still matter in the AI era, how to think about AG UI/WebMCP, and how Scott approaches his Pi/Pi Durable setup. The underlying theme: AI is changing how developers work, but human taste, verification, and system design still matter.
Key Topics Discussed
Passing context between coding agents
- Best practice for handoffs: write important findings to a markdown file, code comments, or some other durable project artifact.
- If something must survive beyond a chat session, it should live in the repo or a project-level file.
- Scott prefers lightweight task tracking tools like Dex or even GitHub issues for durable, transferable context.
- For short handoffs, Wes often just asks the agent to generate a handoff prompt he can manually copy into the next session.
Are AI-generated skills good?
- They’re useful, but often overbuilt or noisy when created from scratch by an agent.
- Wes and Scott suggest that many “skills” could be better expressed as:
- scripts,
- repo-level instructions,
- or project-specific workflows.
- Their advice: distill a skill only after you’ve figured out the workflow through actual use.
- They also caution that too many global skills can conflict or cause agents to make bad assumptions.
High-fidelity design implementation from Figma
- For converting Figma designs into working sites, Scott recommends leaning on Anthropic models for visual work.
- The Figma MCP is valuable because it can pull actual design values and system tokens directly from Figma rather than guessing them.
- Strong results come from combining:
- Figma data access,
- browser-based visual verification,
- accessibility checks,
- and lower-level project instructions about how UI should be built.
- Their broader point: AI can get you close, but human review is still essential for UX/UI interaction quality.
What technical skills still matter in the AI era?
- They push back on the idea that the answer is simply “learn more algorithms.”
- Instead, the best path is to ask:
- How can this new tech solve new problems?
- What industry or workflow could I apply it to?
- Their advice is to be curious, experimental, and opportunistic:
- identify problems in your current field,
- explore adjacent industries,
- and build workflows around what AI enables rather than just doing old tasks faster.
- They use examples like fashion pattern drafting and hardware tinkering to show that nontraditional backgrounds can still succeed by finding new use cases.
Mourning the death of manual coding
- A major thread in the episode is the emotional side of AI-assisted development.
- Scott and Wes acknowledge that some developers are grieving the loss of the craft they spent years mastering.
- Their message:
- it’s normal to feel that loss,
- but skills in programming, architecture, UX, and product thinking still matter,
- and the future favors people who can direct systems well, not just type code manually.
- Wes notes that many old “hard-earned” web skills have already become obsolete over time, so this is part of a longer pattern.
AG UI vs WebMCP
- They give a broad explanation of the space:
- Computer use: agent interacts through a browser
- MCP: tool/data access layer
- WebMCP: exposes website functionality to agents
- AG UI: an event-driven layer for agent-to-app interaction and generative UI
- AG UI’s big differentiator, as described here, is its event-based model, which can react when something changes in the app.
- They see this as a fast-moving space with multiple overlapping approaches, but they’re excited about anything that makes applications more agent-friendly.
Scott’s Pi / Pi Durable workflow
- Scott recommends starting minimal and only adding extensions/tools as needed.
- He likes Pi because it can be extended, but warns against over-customization.
- For Pi Durable, he’s built a workflow where he can highlight part of the UI and trigger an agent to fix it, sending along the DOM/component/route context.
- His summary: keep the harness lean, add tools only when they solve a real problem.
Notable Takeaways
- Durable context beats chat memory. If it matters later, store it in files or issues.
- Too many global skills can hurt more than help.
- AI can reproduce visual fidelity surprisingly well, but UX and interaction design still need a human in the loop.
- The next valuable technical skill is not just coding faster, but knowing how to direct AI toward useful outcomes.
- Mourning old workflows is valid, but the industry keeps moving.
Practical Recommendations
- Save important agent context in:
- markdown files,
- comments,
- GitHub issues,
- or structured project-management files.
- Use AI-generated skills sparingly; prefer:
- scripts for deterministic behavior,
- skills only for repeatable, high-level workflows.
- For design-heavy work:
- use models with strong visual understanding,
- validate against Figma values,
- verify with browser screenshots and accessibility checks.
- If you’re setting up an agent workspace like Pi:
- start with the minimum,
- add tools only when needed,
- avoid loading unnecessary global context.
Sick Picks
- Wall-mounted light/camera brackets: a practical office upgrade that saves floor space and makes lighting setups safer and cleaner.
- Monoprice ultra-thin Ethernet cables: recommended for clean, aesthetically pleasing rack and desk cable management.
Final Thought
The episode’s central message is that AI isn’t eliminating the need for developers so much as shifting the value toward taste, system design, verification, and workflow orchestration. The “death of code” is really the death of code as the only valuable part of the job.