AI Engineer
Autonomous coding tools scale without mechanical limits while biological attention degrades under load, requiring automated verification gates and decoupled mobile oversight to prevent engineer burnout.
AI-assisted summary of Your Attention Is the Bottleneck, Not Your Agents — Zack Proser, WorkOS — original source. Check the original for full context.
Source published:
Key ideas
- The primary bottleneck in modern software engineering has inverted from tooling capability to human biological attention, causing developers to burn out rapidly when attempting to supervise infinite parallel agents. (3:36)
- Adopting a voice-first input workflow can more than double prompt throughput from a typical typing speed of ~90 WPM to ~184 WPM, enabling rapid parallel dispatch across multiple IDE workspaces. (5:13)
- Remote control agent sessions via Claude Code decouple engineering progress from desk tethering, letting developers guide isolated background workers over mobile LTE while engaging diffuse-mode thinking. (8:15)
- Autonomous agent reliability requires strict multi-tier verification gates—ranging from local lint and build suites to headless browser click-throughs and constitutional critic agent reviews. (11:13)
Detailed notes
## Background Published on YouTube by AI Engineer on June 11, 2026, this presentation features Zack Proser, an engineer on the Applied AI team at WorkOS. According to the page description, Proser addresses developer burnout caused by parallel AI agents, proposing a sustainable workflow centered on voice prompting at 184 words per minute, mobile remote control away from the desk, automated verification gates, and continuous self-improvement over conversation logs.
## TL;DR Zack Proser argues that as autonomous coding agents scale infinitely, the core bottleneck in software engineering has shifted from tool capability to finite human biological attention. To counter mid-morning developer exhaustion, he introduces a four-pillar operational stack: signal agents to filter Slack and Linear noise, high-speed voice dictation across parallel workspaces, mobile remote control enabling diffuse-mode thinking away from the desk, and weekly meta-agents that audit local JSONL session logs to generate missing skills. He pairs this workflow with a three-tier verification hierarchy—spanning unit tests, headless browser click-throughs, and constitutional critic agents—while even wiring his Oura ring to Claude to enforce physical rest. In the Q&A, Proser addresses junior skill acquisition, session-end logging hooks, night-shift cron execution, and isolating multi-stack features with git worktrees.
## Atmosphere & style The session has a candid, empathetic, and refreshing tone, opening with a gut-check that immediately validates the audience's shared sense of agent-induced burnout. Proser's delivery is pragmatic and conversational, laced with self-effacing humor as he jokes about his 'giant sausage fingers' and recounts late-night arguments with Claude over his Oura ring sleep scores. Watching it feels like listening to a battle-tested peer delivering an honest field report from the bleeding edge of AI engineering, grounding dazzling technical leverage in the messy reality of human biology.
## Bulletin - [03:36](https://www.youtube.com/watch?v=so9l_MwS2yg&t=216s) The primary bottleneck in modern software engineering has inverted from tooling capability to human biological attention, causing developers to burn out rapidly when attempting to supervise infinite parallel agents. - [05:13](https://www.youtube.com/watch?v=so9l_MwS2yg&t=313s) Adopting a voice-first input workflow can more than double prompt throughput from a typical typing speed of ~90 WPM to ~184 WPM, enabling rapid parallel dispatch across multiple IDE workspaces. - [08:15](https://www.youtube.com/watch?v=so9l_MwS2yg&t=495s) Remote control agent sessions via Claude Code decouple engineering progress from desk tethering, letting developers guide isolated background workers over mobile LTE while engaging diffuse-mode thinking. - [11:13](https://www.youtube.com/watch?v=so9l_MwS2yg&t=673s) Autonomous agent reliability requires strict multi-tier verification gates—ranging from local lint and build suites to headless browser click-throughs and constitutional critic agent reviews.
## Key takeaways - [00:00](https://www.youtube.com/watch?v=so9l_MwS2yg&t=0s) Context switching combined with rapid AI agent velocity pushes developers into severe cognitive exhaustion early in the workday if human attention is treated as an infinite resource. - [01:08](https://www.youtube.com/watch?v=so9l_MwS2yg&t=68s) Closed-loop bug resolution is achievable by combining terminal agents like Claude Code with external integrations through the Model Context Protocol (MCP) to verify fixes directly in live services like Slack and Linear. - [03:36](https://www.youtube.com/watch?v=so9l_MwS2yg&t=216s) Tooling scalability is practically unbounded, but human attention remains grounded in biological limits, meaning engineers must reserve their energy strictly for taste, architectural judgment, and high-level verification. - [05:13](https://www.youtube.com/watch?v=so9l_MwS2yg&t=313s) Signal Layers act as an automated triage buffer for Slack and Linear, filtering urgent issues and deduplicating tickets so developers never directly face distracting notification firehoses. - [05:13](https://www.youtube.com/watch?v=so9l_MwS2yg&t=313s) Voice-driven coding achieves prompt throughputs of ~184 WPM, allowing developers to dispatch instructions across several parallel agents in the time it takes to type one prompt manually. - [08:15](https://www.youtube.com/watch?v=so9l_MwS2yg&t=495s) The Shower Principle demonstrates that stepping away from the keyboard enters diffuse mode, where unconscious cognitive problem-solving sparks architectural breakthroughs that rarely occur while staring at a screen. - [10:00](https://www.youtube.com/watch?v=so9l_MwS2yg&t=600s) Claude Code's remote control functionality syncs terminal sessions to mobile devices, enabling engineers to steer running agents and review pull requests from dirt trails over cellular data. - [11:13](https://www.youtube.com/watch?v=so9l_MwS2yg&t=673s) Safe agent execution depends on a three-tier verification hierarchy: code-level checks (lint, build, tests), browser-level click-throughs (headless Chrome), and constitutional critic passes. - [12:05](https://www.youtube.com/watch?v=so9l_MwS2yg&t=725s) Historical Claude Code interaction logs stored locally as JSONL files can be audited weekly by offline agents to detect high token consumption, pinpoint ambiguity, and synthesize custom MCP skills. - [15:31](https://www.youtube.com/watch?v=so9l_MwS2yg&t=931s) Connecting biometric data such as Oura ring telemetry via MCP lets agents monitor developer fatigue and enforce work boundaries, countering the urge toward 'burnout turbo.' - [17:35](https://www.youtube.com/watch?v=so9l_MwS2yg&t=1055s) Junior engineers should avoid using AI for tasks they cannot already execute manually, ensuring they develop foundational intuition and the scar tissue required to spot architectural hallucinations. - [20:00](https://www.youtube.com/watch?v=so9l_MwS2yg&t=1200s) Raw JSONL session logs contain operational noise; intermediate session-end hooks that distill learnings directly to Markdown vaults or Obsidian provide cleaner input for scheduled meta-audits. - [21:30](https://www.youtube.com/watch?v=so9l_MwS2yg&t=1290s) A sustainable off-hours 'night shift' relies on strict Linear issue hygiene with an 'agent-ready' tag and a persistent cron loop that executes tasks and runs verification suites while the developer sleeps. - [22:17](https://www.youtube.com/watch?v=so9l_MwS2yg&t=1337s) Developers can blend input and output modalities by pairing voice dictation with visual code inspection during programming, while using two-hour spoken walks via ChatGPT Advanced Voice Mode for high-level ideation. - [23:39](https://www.youtube.com/watch?v=so9l_MwS2yg&t=1419s) Managing complex, multi-stack features requires git worktree isolation to prevent concurrent agents from colliding, backed by tightly scoped prompts and automated CI verification gates.
## Detailed walkthrough ### [00:00](https://www.youtube.com/watch?v=so9l_MwS2yg&t=0s) The Burnout Paradox and the Closed-Loop Bug Fix
Zack Proser introduces himself as an engineer on the Applied AI team at WorkOS, a company providing drop-in APIs designed to help software products move upmarket and close enterprise deals. Rather than focusing on product capabilities, however, he opens with an immediate gut check for the audience: asking for a show of hands from anyone who has been AI coding with autonomous agents lately and feels completely drained. He observes a room full of nodding practitioners who find themselves continuously adrenaline-dumping, completely fried by midday despite achieving unprecedented productivity. Context switching has always been notoriously costly for software engineers, but the sheer velocity of modern AI tools has intensified that mental tax to a crisis point. As Zack puts it, “The tools are insanely powerful and our skills are more in demand than ever before and yet we're exhausted by 11 a.m.”
To ground this dynamic in day-to-day engineering, Zack details a recent experience building an internal Slack bot at WorkOS. The project's goal was to democratize uniform blogging across the company: enabling any employee, even someone who has never written an article before, to drop a simple request into a Slack channel and receive a properly formatted, compliant blog post. A colleague quickly flagged a defect: the bot's sentence-casing pipeline was inadvertently mangling enterprise acronyms like SCIM and SSO.
In a traditional setup, fixing this would mean plunging into "window hell"—juggling editors, Slack windows, test scripts, and tickets manually. Instead, Zack tried a high-leverage adjustment using Claude Code, his primary aperture for terminal-based agent work. He granted Claude Code direct access to Linear issues and wired it to Slack using the Model Context Protocol (MCP). Rather than issuing micro-instructions, he gave the agent an end-to-end mission: diagnose the issue, fix the sentence-casing logic, execute and verify the fix through the live Slack bot channel, and do not exit until the verification passes autonomously.
```mermaid flowchart LR accTitle: Closed-loop bug resolution via Claude Code accDescr: Claude Code receives a terminal instruction, edits local code, triggers a verification request via Slack MCP, and confirms resolution. subgraph Local["Developer Workspace"] A["Claude Code CLI"] -->|"edits code"| B["Sentence Case Module"] end subgraph Integration["External Services via MCP"] A -->|"sends test prompt"| C["Slack Blog Channel"] C -->|"triggers execution"| D["WorkOS Blog Bot"] D -->|"returns formatted post"| A end ```
The agent executed the entire cycle independently: it patched the code in the local working directory, pushed a test prompt through the MCP connection into the designated Slack channel, waited for the blog bot to process the request up to the sentence-casing stage, inspected the output, verified that acronyms like SCIM and SSO remained intact, and confirmed the bug was resolved before returning control. Zack returned to his desk to find a closed loop, without having to intervene once to point out lingering breakages.
- WorkOS core value proposition: Drop-in APIs enabling apps to land enterprise deals (e.g., enterprise single sign-on, directory sync). - Specific bug resolved: Sentence-casing enforcer mangling uppercase enterprise abbreviations (SSO, SCIM). - Operational stack used: Claude Code CLI integrated with Linear tickets and Slack channels through Model Context Protocol (MCP) servers.
---
[03:36](https://www.youtube.com/watch?v=so9l_MwS2yg&t=216s) The Bottleneck: Human Attention vs. Infinite Agent Scalability
While the fully automated bug fix was a triumph, it left Zack feeling unsettled rather than triumphant. The realization was immediate: the tooling no longer has a mechanical ceiling. When agents can autonomously edit code, trigger third-party interfaces, and evaluate their own verification criteria, an engineer could theoretically attempt to resolve 150 bugs a day using that exact harness. However, human cognitive hardware has not evolved alongside the software. As Zack warns, “The tools are nuclear now, and our nervous system is still relatively ancient.”
A human engineer cannot sit atop a massive pipeline of 150 daily agent runs, rigorously assess the output quality, make high-stakes business judgments, and then return the next morning for another eight-hour shift without severe burnout. The tooling bottleneck has officially inverted: it is no longer the agentic framework holding back delivery speed, but the developer's raw biological attention.
Zack references Simon Willison, who recently reported that spinning up just four parallel agent sessions leaves him completely wiped out by 11:00 a.m. This confirms that finding personal limits and defining a sustainable workflow is no longer an edge-case optimization—it is an existential survival skill for AI engineers. Infinite loops belong to machines; human developers must reserve their finite energy for taste, architecture, and true problem validation.
> “Agents can scale infinitely, especially now that they're made available as of last night via Claude API... But our attention is still in meat space, if you will, and it still degrades under load. It's still the hard constraint, essentially.” — Zack Proser
---
[05:13](https://www.youtube.com/watch?v=so9l_MwS2yg&t=313s) The Sustainable Stack: Signal Layers and Voice-First Coding
To avoid burning out while maximizing leverage, Zack outlines an emerging operational stack tailored for developer sustainability. The architecture divides labor strictly: agents handle parallel iteration and automated loop closure, while humans provide high-level taste, business alignment, and system design. This approach rests on four core pillars: 1. Signal Layers (notification filtering and deduplication) 2. Voice-First Flows (rapid, low-friction prompting) 3. Remote Control (asynchronous, decoupled oversight) 4. Self-Improving Systems (agentic audits over conversation logs)
```mermaid flowchart TD accTitle: The Four-Layer Sustainable Developer Stack accDescr: Four layers designed to protect developer attention: Signal Layers, Voice-First Flows, Remote Control, and Self-Improving Systems. L1["1. Signal Layers: Agent triage for Slack and Linear"] L2["2. Voice-First Flows: 184 WPM parallel prompting"] L3["3. Remote Control: Mobile oversight & diffuse-mode thinking"] L4["4. Self-Improving Systems: Automated JSONL pattern mining"] L1 --> L2 --> L3 --> L4 ```
Under the **Signal Layer**, the goal is shielding the human mind from distraction. Opening Slack to track an alert carries an 80% probability of getting derailed by an unrelated channel, an incoming DM, or an urgent non-sequitur. To prevent this, Zack delegates inbox scanning to Claude Code on a loop. With MCP access to both Slack and Linear, the agent checks mentions, identifies real emergencies, cross-references requests against Linear backlogs to eliminate duplicates, and presents only actionable tickets. The human never opens the firehose directly.
The second component is **Voice-First Flows**. Despite having typed since age three and topping out around 90 words per minute using what he calls his "giant sausage fingers," Zack switched to voice-driven coding roughly 18 months ago. Speaking prompts allows him to consistently hit 184 words per minute.
This throughput difference transforms how tasks are delegated. Instead of slowly typing a prompt for one IDE window, Zack speaks instructions across three parallel Cursor workspaces, Codex sessions, or multiple Claude tabs in rapid succession. By the time a traditional developer finishes typing their initial prompt into a single box, Zack’s agents are already deep into execution across multiple work streams.
- Personal typing baseline: ~90 WPM (self-described non-standard method). - Voice-first baseline: ~184 WPM sustained during daily workflows. - Operational leverage: Dispersing three complex prompts in the time required to manually type one.
---
[08:15](https://www.youtube.com/watch?v=so9l_MwS2yg&t=495s) The Shower Principle and Asynchronous Remote Control
Transitioning to high-speed voice input unlocks a broader physical shift: spending substantially less time tethered to a desk. Zack connects this to the well-known "shower principle." In classic psychology and productivity literature, cognitive problem-solving toggles between two primary states: - **Focused mode:** High-intensity symbol hunting, typing, and local code manipulation within an IDE. While crucial for executing concrete tasks, it creates cognitive tunnel vision, heightens inhibitions, and obscures novel architectural solutions. - **Diffuse mode:** The relaxed mental state triggered by stepping away—taking a shower, walking the dog, or taking your children to the park. The subconscious continues churning through the problem in the background, frequently sparking a sudden flash of insight with the complete solution.
Historically, entering diffuse mode meant halting active work entirely. Stepping away from the keyboard severed the feedback loop with the codebase. Zack emphasizes that modern tooling breaks this long-standing trade-off: “Diffuse mode and walking away from your desk meant stopping work. And that is no longer the case, especially with things like remote control.”
Focusing specifically on Claude Code's implementation, Zack explains how **Remote Control** operationalizes this concept. A developer starts a session directly from their primary development machine by passing a `--remote-control` flag (or specifying `enable remote control` in the configuration). The terminal process retains full access to the local file system, shell environment, and project tools. However, the session syncs state outward to Anthropic's web and mobile interfaces.
The developer can close their laptop, step away from their desk, and head outside. Miles away from their local home Wi-Fi network, operating entirely over a cellular connection (such as CDMA or LTE) on their smartphone, they can review progress, inspect agent execution traces, issue high-bandwidth voice steering commands, and let the agent continue running in an isolated environment while their mind wanders freely in diffuse mode.
[10:00](https://www.youtube.com/watch?v=so9l_MwS2yg&t=600s) Remote Control, Trail Coding, and the Three Verification Gates
Being able to step away from the desk without halting work completely reframes a developer's relationship with their machine. Zack Proser describes being miles away out on a dirt trail, opening his phone, and checking in directly on an active Claude Code session that is still churning away on his local computer. Because he can talk to the agent, send messages, and poke at running tasks over LTE, he no longer feels glued to an office chair. In his experience, a developer's best design breakthroughs and bug fixes almost never strike while staring blankly at a screen—they occur the minute they step away from the desk. By getting core tasks lined up in a morning focus block, dispatching agents to work on isolated tasks, and physically walking out the door, engineers can slash repetitive strain injuries (RSI) and hand fatigue while maintaining high velocity. Zack notes that this is not hypothetical theorycrafting: he actually published a 32-minute film demonstrating how to review pull requests and guide coding agents from a mobile phone deep in the woods. When a sudden architecture insight strikes on a trail hike, you do not have to write a mental note to implement it hours later; you simply shoot a prompt back to the local session, and by the time you return to your desk, the changes have already been written and verified.
Operating agents at this level of detachment requires robust safety boundaries so developers do not return to broken repositories. As Zack puts it: “I often say that speed requires safety and so there's levels of doing this and having verification, and now with new tools coming online, not only Chrome use but also computer use for agents, this is going to get more sophisticated.” To prevent agents from running amok while untethered, Zack outlines a tiered hierarchy of verification gates:
```mermaid flowchart LR accTitle: Three-Tier Agent Verification Gates accDescr: A progression of verification gates starting from code checks, moving to browser automation, and ending with critic agents. subgraph G1["Gate 1: Code Level"] A["Lint, Build & Unit Tests"] end subgraph G2["Gate 2: Browser Level"] B["Headless Chrome / Click-Through"] end subgraph G3["Gate 3: Critic Level"] C["Constitutional AI Review"] end G1 --> G2 --> G3 ```
- **Gate 1 (Code-Level Verification):** The foundational gate runs automated linting, compilation builds, and unit test suites on git hooks, forcing agents to verify their own code before claiming completion. - **Gate 2 (Browser Click-Through):** Leveraging agent browser automation (such as Claude Code’s `--chrome` flag or computer-use primitives), the agent opens an isolated browser session, navigates the UI, and clicks through actual user journeys—verifying, for instance, that a code refactor did not silently break the login authentication flow. - **Gate 3 (Constitutional Critic Agent):** Drawing on Anthropic's concept of Constitutional AI, an independent critic agent inspects the primary agent’s output against a pre-established rubric or constitution, providing concrete feedback and demanding revisions if project standards are breached.
[12:05](https://www.youtube.com/watch?v=so9l_MwS2yg&t=725s) The New Developer Day and Mining JSONL for Missing Skills
Synthesizing these pieces yields an entirely different cadence for everyday software engineering. Zack proposes beginning each morning with a high-intensity, distraction-free focus block: triage the GitHub backlog, package routine software development lifecycle chores into background workers, and spin up Claude Code or Cursor on the core feature sets. Once those work tracks are established, the developer can shut their laptop and leave. As long as mobile connectivity exists, the engineer can triage pull requests on GitHub Mobile, drop natural language review comments, and tag assistants—such as `@claude`, `@cursor-agent`, or `@vercel-bot`—to adjust code directly from PR review comments. Zack observes that modern frontier models (referencing future jumps like Claude Opus) reliably interpret review comments and apply the requested changes on the first try. The end result is a workday that demands dramatically less physical desk time, spares hands and wrists from chronic pain, and infuses physical movement and oxygen back into the problem-solving loop while keeping software delivery moving forward.
```mermaid flowchart TD accTitle: JSONL Agent Self-Improvement Loop accDescr: The cycle of logging agent sessions, running a weekly audit, identifying missing skills, and generating bespoke tools. subgraph Work["Weekly Execution"] D["Daily Dev Sessions"] -->|"Save interactions"| E["Local JSONL Logs"] end subgraph Analysis["Weekly Retrospective"] E --> F["Auditor Agent Pass"] F --> G["Identify Token Spikes & Ambiguity"] end subgraph Evolution["Harness Evolution"] G --> H["Generate Bespoke Skills & MCPs"] H -->|"Load into"| D end ```
The sustainability of this approach hinges on closing the feedback loop so workflows improve over time. Zack reflects on his own failure modes when testing parallel agent workflows without structure: Monday feels triumphant as tasks fly off the board, Tuesday maintains momentum, but mid-week unexpected interruptions derail everything, leaving Friday feeling wasted, chaotic, and foggy. A solution came via his colleague Nick, who pointed out that every single interaction in Claude Code is automatically persisted locally as a JSONL file. These logs represent an untapped goldmine:
- **Automated Weekly Audits:** An offline agent can be scheduled at the end of every week or day to crawl all historical JSONL session transcripts. - **Isolating Friction Points:** The auditor flags exchanges where the system consumed an unusually high number of thinking tokens or where the human had to repeatedly clarify requirements due to ambiguity. - **Delta & Skill Generation:** The agent evaluates what specific tooling, Model Context Protocol (MCP) servers, or custom domain knowledge would have eliminated that back-and-forth friction. - **Bespoke Skill Synthesis:** Claude Code includes built-in skills designed to create, test, evaluate, and refine new custom skills from plain-text prompts, allowing a developer's personalized tooling harness to iteratively evolve and eliminate future friction.
[15:31](https://www.youtube.com/watch?v=so9l_MwS2yg&t=931s) Holistic Well-Being: Oura Ring MCP Integration and Avoiding "Burnout Turbo"
Rather than discarding context after every completed session, treating historical conversation logs as gold allows developers to steadily compound their agent harness's intelligence across IDEs like Zed, Cursor, or terminal-based Claude Code. Zack takes this philosophy of closed-loop observation a step further into developer physiology. An avid user of the Oura smart ring, he used open-source GitHub adapters to expose his personal sleep and recovery biometric data to Claude over an MCP server. The integration led to humorous, uncanny interventions during late-night coding sessions.
When arguing with Claude about feature scope after a bad night's rest, the assistant would inspect his biometric telemetry and push back: “you didn't sleep last night, and so we're going to tackle the first part of this, and we're not going to do the rest of it, and we're going to do it tomorrow.” Zack admits his visceral reaction was indignant: “and I tell him the hell with you, you're a machine, do what I want, and I just do it anyway. But at least I thought about taking a break.”
Beyond the humor, Zack argues that engineering efficiency cannot be divorced from physical well-being. Unchecked, the infinite generative capacity of modern language models will not liberate developers by default—it will simply trigger “burnout turbo,” burning humans out faster than ever before because human nervous systems remain fragile, ancient bottlenecks. To build a sustainable, balanced engineering practice, he recommends three immediate starting actions:
- **Build one signal layer:** Route a high-friction notification source (such as Slack or Linear) directly into your primary coding interface so you never have to break focus by opening those apps. - **Add verification gates:** Give Claude Code an automated sanity-check boundary, starting with a simple `--chrome` browser verification flag. - **Reclaim margin intentionally:** Use the time gained back from agent automation to take a walk, enjoy a picnic in the park, or play with your dog instead of filling every reclaimed second with more busywork. - “The tools are nuclear now. Our nervous systems are still ancient.”
[17:35](https://www.youtube.com/watch?v=so9l_MwS2yg&t=1055s) Q&A: Preserving Deep Skill Development Early in Your Career
An audience member opens the question-and-answer session by raising an anxiety common among junior engineers: if modern development workflows rely on dispatching high-level prompts to autonomous agents, how does an early-career engineer acquire hard foundational skills? The engineer notes that they learned to program by repeatedly slamming into technical hurdles, wrestling through painful bugs, and fixing issues manually. Adopting agent abstraction too early feels like it introduces a severe “skill deficit” and stunts long-term professional growth.
Zack validates the question immediately, affirming that delegating everything blindly is dangerous when you lack foundational instincts. He points to the core operational rule he follows: “The best piece of advice I saw for that was basically, don't use AI to do something that you don't know how to do already.” He explains that his current speed shipping TypeScript architectures, retrieval-augmented generation (RAG) pipelines, and complex AWS infrastructure is only possible because he spent years doing them “the hard way.” Having earned those battle scars and scar tissue allows him to instantly catch an agent hallucinating bad architecture and say, *“No, that's insane. We're not doing that.”*
For engineers building their foundations, Zack recommends:
- **Code by hand first:** Tackle new languages, frameworks, and deployment mechanics manually to understand where the hidden landmines, edge cases, and design trade-offs live. - **Use AI as an active examiner:** Instead of using LLMs to bypass effort, instruct the model to inspect your mental models: prompt it to test you, find gaps in your architectural understanding, and expose blind spots. - **Delegate only with qualified trust:** Once you have shipped dozens of systems (such as standard web applications) and possess verified confidence in the underlying machinery, it becomes safe to hand routine execution to agents. - **Leverage modern discoverability:** Take advantage of the fact that unlike junior developers in previous eras—who did not know the correct terminology to even search for their unknown unknowns—engineers can now ask frontier models plain-language questions to explore concepts deeper and faster than ever before.
[20:00](https://www.youtube.com/watch?v=so9l_MwS2yg&t=1200s) Q&A: Managing JSONL Logs and Conversation History
An audience member asks about the logistics of parsing long conversation logs: "So you talked about getting Claude to look at your own chat history with all those JSONL files. I've tried stuff like that and like a problem I found is like those JSON files are not really meant for AI consumption. They get really long. A lot of junk in there. Do you just, or do you have some kind of intermediary step where there's something that parses that into..." Zack Proser acknowledges the challenge, noting that while he has occasionally pointed models directly at raw JSONL files, a much cleaner pattern is using session hooks.
Instead of running an LLM across massive, noisy dumps of entire conversation trees at the end of the week, developers can set up automated hooks triggered when a task wraps up or a PR merges. These hooks instruct the agent to extract the key takeaways immediately while the context is fresh. Zack Proser explains: “You could say save the key bits that we talked about and especially highlight where we struggled or where we spent a lot of extra time and put them in a separate data store.” This secondary store can be an Obsidian vault, a weekly flat Markdown file, or a lightweight archive. Once that streamlined data store is populated, an AI prompt reviews it on a schedule: “You're specifically looking on the hunt for things that we could make more efficient in the future, or indications of struggle in turn.”
- Direct ingestion of raw JSONL files often wastes context and contains excessive operational noise. - Session-end hooks (e.g., triggered on PR merge or task completion) filter sessions into distilled learnings. - Intermediate targets can include Markdown vaults (such as Obsidian) or simple flat text files. - Weekly meta-agents run analysis passes on the distilled summaries to discover workflow optimizations or generate missing system skills.
[21:30](https://www.youtube.com/watch?v=so9l_MwS2yg&t=1290s) Q&A: Running an Overnight "Night Shift" for Agents
An audience member asks whether Zack Proser employs a "night shift" pattern to let agents churn on problems while he sleeps. Proser confirms he does, experimenting with OpenClaw driven by cron jobs to run background content workflows. The experience, however, is not without friction: “Then I wake up in the morning, kind of review it and freak out and scream at it and then eventually merge like the a small percentage of them.”
Despite the initial hit rate, Proser sees autonomous off-hours execution as the inevitable end-state once safety and verification harnesses mature. His target setup centers on strict ticketing hygiene: every bug or feature request gets an issue and subtasks in Linear. He marks specific tickets with an `agent-ready` label, backed by a persistent cron loop running every 15 minutes around the clock. Zack Proser describes the intended vision: “I think the thing I'm gonna end up settling on is gonna be Linear tickets for everything, subtasks for bugs, and for feature requests, and then marking tickets with a tag that says agent ready, and then having a loop that's literally going every 15 minutes all day long and all night long churning through personal and earmuffs company work too.”
```mermaid flowchart TD accTitle: Autonomous Night Shift Execution Loop accDescr: Visualizing the background processing pipeline from Linear issue labeling to nightly cron execution and human review.
subgraph LinearSetup ["Ticket Queue"] A["Feature Requests & Bug Reports"] --> B["Create Linear Subtasks"] B --> C["Apply 'agent-ready' Tag"] end
subgraph WorkerLoop ["Night Shift Background Loop"] C --> D["Cron Loop Checks Every 15 Min"] D --> E["Autonomous Agent Worker"] E --> F["Lint, Build & Test Verification"] end
subgraph MorningReview ["Morning Triage"] F --> G["Draft Pull Requests"] G --> H["Human Review & Selective Merging"] end ```
[22:17](https://www.youtube.com/watch?v=so9l_MwS2yg&t=1337s) Q&A: Voice-First Interfaces and Audio Feedback
The next question explores whether Zack Proser lets his agents speak aloud back to him or if he sticks to reading on-screen responses. Proser reveals that his workflow spans both modalities depending on the context. When writing code with Claude Code, he dictates his prompts via voice but prefers reading the agent's textual output on screen. However, for ideation and system design, he switches entirely to spoken audio.
Zack Proser highlights OpenAI's Advanced Voice Mode as an indispensable creative tool: “That's one of my favorite things about that ChatGPT is one of the only reasons I would use ChatGPT over Claude. And I'll go for a walk for two hours, and I'll brain dump and talk back and forth and sharpen an idea and then say, at the end of that, okay, now make this a succinct transcript or architecture that I can paste.” The voice landscape is evolving rapidly: he mentions testing open-source local-first alternatives (like Ghost Pepper running local Whisper workflows without external APIs) and wiring OpenClaw to Twilio. With Twilio, his agent calls his phone at night so he can verbally debrief it on what to execute the following morning without having to sit down at a monitor.
- **Coding flow**: Voice dictation input paired with visual reading of agent code outputs. - **Brainstorming flow**: Two-hour conversational walks with ChatGPT Advanced Voice Mode, concluding with a request to synthesize the dialog into a structured architecture spec. - **Local audio**: Adoption of zero-API, local-only audio pipelines (such as Ghost Pepper / whisper.cpp-based stacks). - **Telephony integration**: Using OpenClaw over Twilio phone calls for hands-free evening briefings.
[23:39](https://www.youtube.com/watch?v=so9l_MwS2yg&t=1419s) Q&A: Tackling Complex, Multi-Stack Features
An audience member raises the core friction point of multi-agent development: while small bug fixes and UI adjustments are easy to parallelize, chunky features that cut across frontends, backends, database schemas, and architectural refactors frequently cause parallelized workflows to grind to a halt. The questioner asks how to prevent agents from falling apart on these full-stack initiatives.
Zack Proser agrees that the entire industry is wrestling with this exact limitation. To make chunky features tractable, he emphasizes three foundational pillars: git worktrees, specialized agent teams, and stringent verification gates. Git worktrees isolate the filesystem so concurrent workers cannot corrupt one another's working directories. Within those sandboxes, specialized agent teams operate against precise, scoped prompts, continually running unit tests and CI suites to validate progress against the feature specification. Proser notes with humor that the loop still involves “flowing back my insults and rage into the system, and then it's like fixing it as we go.” Zack Proser concludes that while current toolchains require aggressive discipline, structural improvements are imminent: “I think that's gonna keep evolving though, and I imagine that as models get better, there's gonna be more and more complete harnesses to make that more reliable.”
- Git worktrees guarantee directory and branch isolation so parallel agents never step on each other's work during multi-file refactors. - Breaking large features into discrete sub-prompts executed by specialized agent teams prevents context degradation. - Verification gates and CI suites run continuously against specs, catching regressions as soon as an agent touches dependent layers across the stack.
## Notable quotes > [03:36](https://www.youtube.com/watch?v=so9l_MwS2yg&t=216s) The tools are nuclear now, and our nervous system is still relatively ancient. — Zack Proser
> [00:00](https://www.youtube.com/watch?v=so9l_MwS2yg&t=0s) The tools are insanely powerful and our skills are more in demand than ever before and yet we're exhausted by 11 a.m. — Zack Proser
## Mentioned Zack Proser, Simon Willison, Nick, WorkOS, Anthropic, OpenAI, Claude, Claude Code, Claude Opus, Cursor, Linear, Slack, Model Context Protocol (MCP), Oura, Ghost Pepper, Twilio, OpenClaw, Obsidian, Zed, GitHub, GitHub Mobile
## Video description Simon Willison fires up four parallel agents and is wiped out by 11am. That is the problem Zack Proser is solving: not that the tools are too slow but that human attention is still the hard constraint. His loop: voice brief at 184 words per minute, agent dispatched to an isolated git worktree, laptop closed, progress checked from a phone on LTE miles away via remote control.
The talk covers four layers that make this sustainable: signal agents that read Slack and Linear on a loop so you never open them yourself, verification gates from lint and build up to browser click through and critic passes, a weekly agent run over your JSONL conversation history to surface inefficiencies and generate missing skills, and an Oura ring connected via MCP so Claude can tell you that you did not sleep last night. You can ignore it. But at least you thought about it.
Speaker info: - https://linkedin.com/in/zackproser - https://github.com/zackproser
Timestamps: 0:00 Introduction and the problem of AI developer burnout 1:08 A concrete example of using AI agents for bug fixing 3:36 The bottleneck: human attention vs. infinite agent scalability 5:13 The proposed stack for sustainable AI development 6:03 The Signal Layer: Managing notifications and context switching 7:04 Voice-first flows for coding efficiency 8:15 The Shower Principle and Remote Control for agents 11:13 Safety, verification, and testing gates 12:05 The new, balanced developer workflow 13:22 System self-improvement using conversation history 15:31 Holistic well-being (Oura ring integration) 17:35 Q&A: Addressing skill development early in a career 20:07 Q&A: Managing JSONL history and long-term conversation logs 21:30 Q&A: Night shift/background agent execution 22:17 Q&A: Voice interaction and audio feedback 23:39 Q&A: Handling complex, multi-stack features
---
Watch along with the corrected transcript, summary, timestamps and resources on this talk's official AIE page: https://ai.engineer/talks/so9l_MwS2yg-your-attention-is-the-bottleneck-not-your-agents-zack-proser-workos
Join our upcoming AI Engineer conferences (see https://ai.engineer landing page):
- AIEi Shanghai, November 5–6 — the first for meeting top Chinese labs and engineers - AIE CODE in SF, November 10–12 — the top AI Coding conference returns - AIEi Sydney, December 7–8 — the first AIEi run alongside NeurIPS 2026 in Sydney
---
[Source](https://www.youtube.com/watch?v=so9l_MwS2yg)