WorkOS Engineer Unplugs From Desk as Human Attention Limits AI Coding

Your Attention Is the Bottleneck, Not Your Agents — Zack Proser, WorkOS — AI Engineer

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)

Reading summary

WorkOS engineer Zack Proser argues that autonomous AI coding tools have removed mechanical limits on development velocity, making biological human attention and nervous systems the primary bottleneck in software engineering. The Attention Bottleneck and Closed-Loop Automation (0:00) Modern agentic systems can autonomously resolve software defects from end to end. Proser demonstrates this through an internal WorkOS Slack bot fix, where Claude Code used the Model Context Protocol (MCP) to ingest a Linear issue, patch sentence-casing logic, execute a test prompt via Slack, verify that acronyms like SCIM and SSO were preserved, and terminate the session without human intervention. While mechanically an engineer could theoretically trigger 150 automated bug fixes daily, human cognitive hardware cannot continuously evaluate that volume of output without severe exhaustion. Citing Simon Willison's observation that managing four parallel agent sessions causes midday fatigue, Proser asserts that infinite scalability belongs to machines, requiring engineers to husband their attention for architecture, taste, and problem validation. Architecting a Sustainable Developer Stack (5:13) To prevent cognitive exhaustion, Proser outlines a four-layer framework designed to insulate developer attention: signal layers, voice-first prompting, asynchronous remote control, and self-improving feedback loops. The signal layer deploys Claude Code on a loop via MCP across Slack and Linear, triaging notifications, filtering duplicates, and presenting only actionable tickets so developers avoid distracting chat inboxes. Voice-first flows bypass manual typing limits: Proser notes he sustained approximately 184 words per minute speaking prompts compared to a baseline typing speed of 90 words per minute, enabling rapid dispatch of instructions across multiple parallel Cursor, Codex, or Claude sessions. Remote Control and Tiered Verification Gates (8:15) Voice workflows facilitate stepping away from the desk to leverage diffuse-mode thinking, the relaxed mental state that generates novel architectural solutions. Using Claude Code's `--remote-control` flag, terminal sessions stay anchored to the local development environment while streaming state to mobile interfaces over cellular connections, allowing developers to review traces and steer tasks from trails or walks. To ensure code safety while untethered, Proser advocates three sequential verification tiers: Gate 1 enforces local git-hook linting, builds, and unit tests; Gate 2 uses headless browser automation via `--chrome` or computer-use primitives to validate live UI click-throughs; and Gate 3 deploys an independent Constitutional AI critic agent to evaluate implementations against quality rubrics. Compounding Workflows Through Log Mining and Physiological Guardrails (12:05) To prevent workflow decay, Proser mines local session logs rather than discarding interaction history. Because Claude Code automatically records sessions in JSONL files, scheduled meta-agents or session-end hooks triggered by merged pull requests can audit transcripts, identify friction points where token consumption spiked, and synthesize bespoke custom skills or MCP connections into flat files or Markdown vaults. Proser also extended closed-loop monitoring to developer biometrics by piping Oura Ring sleep and recovery data into Claude over MCP, creating a system that detects fatigue and actively pushes back against feature overscoping during late-night sessions. Preserving Core Competence and Scaling Complex Systems (17:35) During audience questions, Proser emphasized that junior engineers should avoid using AI for tasks they cannot already execute manually, warning that foundational skills, scar tissue, and mental models are necessary to catch model hallucinations and flawed architectures. For larger, multi-stack initiatives, he recommends isolating parallel agents with git worktrees to prevent filesystem corruption, assigning scoped prompts to specialized sub-teams, and running continuous CI verification. For off-hours execution, Proser describes an evolving 'night shift' pattern using Linear tickets labeled `agent-ready` polled by a 15-minute cron loop, with drafted pull requests triaged each morning. Proser concludes that unchecked generative capacity risks accelerating developer burnout rather than liberating teams. Achieving sustainable leverage requires deliberate friction boundaries, automated multi-gate verification, and consciously redirecting reclaimed time into physical movement and rest rather than additional busywork.

Source quotes

[3:36] Zack Proser: The tools are nuclear now, and our nervous system is still relatively ancient. [0:00] Zack Proser: The tools are insanely powerful and our skills are more in demand than ever before and yet we're exhausted by 11 a.m.

Original transcript

[0:00] Thank you. Hey, everyone. I'm Zach. I work at WorkOS. Thanks for coming. WorkOS provides drop-in APIs that allow you to take your software and go upmarket and sell larger deals to enterprises. But what I'm going to talk about now is sort of the way that I'm finding to try and maintain balance with all the insane new tools that we're getting every day. So show of hands, if anyone is AI coding with agents lately and feels a little bit like this and Yeah, despite getting more done than ever before, like you're completely fried at the end of the day, right? And like adrenaline dumping constantly. So this has been my experience and I've noticed that some of the worst of it is like, The context switching was always super expensive for me, and now it's worse than ever before, right? So I think a lot of us are feeling this way The tools are insanely powerful and our skills are more in demand than ever before and yet we're exhausted by 11 a.m. So I'll make this concrete with a recent story. I was working, I'm on the applied AI team at WorkOS. I was building a Slack bot that kind of democratized uniform blogging for everybody so that anybody that even if they've never written a blog post before can come into a Slack channel, make a simple request, and get a uniform blog post that does everything the correct way, right? And there was a bug that one of my colleagues reported that said, hey, we need to use sentence case, and the sentence case pass right now is mangling some of our acronyms like SCIM and SSO. So normally I'd be living in that kind of window hell that I just showed you. And instead, this time, I made a very minor change that ended up being super impactful. So I gave Claude Code, which is my current preferred aperture for working, the ability to read and write to Slack as well, and it already had my linear ticket access. And so I told it, you need to fix this. And then you also need to verify your own work and don't stop until you've done that. And so roughly this is what it looked like. If my terminal's on the left, you know, I ran Claude, and I said, "Fix the sentence case enforcer," it's mangling acronyms. And so it went and did that, and because it had an MCP connection to Slack, it fired it into this blog post channel. and then the blog bot that it's working on, you know, sitting in that code base in my working directory, picked it up and ran all the way through and got to the step that was relevant, And then Claude verified the outcome and then said, okay, now I have definitively fixed this bug. So when I came back to it, I came back to a completed loop that had been fixed and I didn't have to tell it "Hey, this part's still broken." So that felt incredible and I think that that's an important part of what we're going to all build into our toolkit and we already are. But it also scared me because I realized that there's like, there's nothing, there's no ceiling to this, right? So the tools are nuclear now, and our nervous system is still relatively ancient. And so... The thing that I'm thinking about recently is how do I find my own kind of developer balance in this world, right? So why not just stack that same process? Why not use that harness and just fix 150 bugs every day at work? Well, the agents can kind of do that, especially if you give them enough context, if you give them the right verification criteria, if you give them the tools to verify their own work, But at the end of the day, I can't actually sit on top of all of that and make sure that the quality is there. and also show up the next day for another eight hour work session and not be completely destroyed. So, what I think I'm finding and I think a lot of other folks have been talking to you recently are finding is that the agents are not the bottleneck now and I think that's going to increasingly be the case but we are. So agents can scale infinitely, especially now that they're made available as of last night via Cloud API. you can give them verification criteria and the tools that they need in order to match that criteria. But our attention is still in meat space, if you will, and it still degrades under load. It's still the hard constraint, essentially. And this is something that's not just me and not just you, everyone that just raised their hand at the beginning of this talk feeling it. As Simon Willison said recently, like last week, that he fires up four parallel agents, and he's wiped out by 11 a.m., And so he suggests that all of us finding our own individual balance and sort of our personal limits is now something that we all need to do on our own. I'm definitely seeing this also on the Applied AI team. Here's a couple of tips and tricks or things that I've used recently and found success with. So I'll share them and some of them I'm sure you've already seen. So we essentially need to bring the human developer into balance with this new way of working. Because now that we have these hypercharged tools, it's faster than ever to burn yourself out, especially if you just... scale linearly in terms of what you're taking on at work and what you're outputting. the way that I'm sort of breaking it down in my mind is that agents are going to do better in terms of infinitely scaling, looping infinitely until they have [5:00] reach the criteria you've given them. But we still have judgment, taste, knowing that something is actually solved, knowing that the criterion is actually met in terms of human needs and business needs. And so this is kind of an early breakdown of the stack that I'm seeing. The first I'm calling signal layers, for lack of a better word. I'll develop that a little bit in a second. The second is voice first flows. I've been doing voice first coding now for about a year and a half, and it's been life changing. and then remote control, which is becoming more and more recent, more applicable. And I think we're going to start seeing it everywhere. Right now, it's sort of a Claude code specific thing. and then the system improving itself. changing just minimal things about the way that you work and the way that you store your own message history even, can enable incredibly powerful passes now that you have agents that can rip through all that material in seconds and find patterns for you on a loop, without you even needing to remember to do it. So let's take a quick look at what each of these, what I mean by this. Calling back to the bug that I showed you that I fixed and had Claude do it, My problem is that if I were to go and go comb through Slack myself, it's like 80% guaranteed that I'm going to get... distracted by some other thread. I'm gonna find something else, or somebody's gonna have a new ask for me, and that's gonna pull me off task. Instead, I had Claude Code be able to read my Slack and do it on a loop so that it can Are there at mentions, are there DMs, are there actually like high priority asks that need to be actions? Meanwhile, it's always had access to my linear via MCP, and so it can deduplicate asks and find... the real tickets. this is just enough of a sort of facade for me to allow me to continue to focus and maintain my attention on the things that are the key for me to be able to do. as the human developer. And I think that there's a ton of tools that are coming out that we're all seeing here too that are going to make this kind of like just a bespoke experience wherever you want to work. but it's sort of about managing the now extra insane levels of traffic and pinging and noise that we're all going to deal with. The second is just voice first flows, like another nudge if you haven't tried this yet. I highly recommend it. I'm a person that loved to type. I've grown up typing since I was three years old. I think at my best I was hitting 90 words per minute in a weird, non-standard way with my... giant sausage fingers. But now with voice first tools, it's significantly faster. I regularly hit like 184 words per minute on a given day. And what that enables is not just speaking into one thing quickly and having it done faster, it enables kind of parallel workflows, right? At the top, I'm a developer who's speaking across three different cursor windows, or into Codex, and then also into Claude across multiple tabs. And because it's 184 words per minute, they're now off and running while a traditional developer is still typing in their first prompt. And I think that if you consider that small things grow quickly in terms of software, How does this compound over the course of a year or two, three years of working? And this has been really key for me because as I get more and more comfortable with voice flows, it also enables what I'm going to show next, which is spending less and less time at your actual desk while still getting work done. The next is remote control. Right now, this is a Claude code specific thing, but I expect that's going to rapidly change. Before we go look at exactly what that means in the cloud ecosystem, we'll just touch on the shower principle. I'm sure everyone has heard about this before. The basic idea is that there's two modes of thinking. If you're hardcore focused in your IDE and you're typing and you're searching for symbols, You're likely in focus mode. You likely have a very clear blueprint in your mind of what you're trying to build and how you want to do it. and that focus is excellent for getting something over the line and building something exactly the way you want. but it's also ideal for having blind spots and missing what you need, creative solutions to things and increasing your inhibitions. But paradoxically, when you get up and walk away and you start playing with your dog or walking your kids to the park or taking a shower, it's like there's a flash of insight and you get the full form solution. Yeah. And the thesis, the shower pencil, is that basically, your subconscious is always churning on these hard problems. And so as soon as you walk away and kind of open the aperture and lower your inhibitions, diffuse mode allows you to see, you know, more creative solutions quickly. And the key thing I wanna stress here is that we've always had this and there's been hundreds of books written about it, and we've all talked about it for decades. But it used to mean that diffuse mode and walking away from your desk meant stopping work. And that is no longer the case, especially with things like remote control. So what remote control means in the-- let's just take the cloud code ecosystem example. If I'm starting a Cloud Code session, I pass the remote control flag or I run remote control, or I have in my config enable remote control, then I can start at my desk, it's running on my dev machine, it has access to the file system, et cetera. But then as soon as I pull up Claude on my phone on a different network, CDMA, off the wifi from my house, [10:00] like, you know, miles away in the trail. I can still see that session and I can still talk to it and send messages and poke it. And that's incredibly powerful because I get my best ideas and all the solutions as soon as I've walked away from the desk. And so what this enables now is... And what I'm going to propose that enables is starting your day in focus mode, getting everything loaded up that you need to do that's super important, and then getting your agents churning, making sure work is proceeding the way that you want, and then leaving the desk. reducing your RSI and the number of physical injuries you're getting from sitting in the same position all day. and going and taking a walk, but still being super productive. And I have done a ton of experiments with this. And I even filmed a 32-minute film last year, like, proving that you can do this and review PRs from your phone in the woods. So I'm not just blowing sunshine. Like, it's possible. And the really nice thing about it is that when you talk to that session through your phone, that's the session on Cloud Code is still running on your machine, still has access to do whatever it needs. If you have some genius idea of this is the design that's going to nail it, then you just fire that back. You don't have to remember to do it when you get back to your desk. You're going to come back to it having already been applied. Of course, in order to do this, 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. The gate one is like the minimal lint and build and unit test, right? with hooks every single time verify their own work at the code level to make sure nothing's broken. You know, gate two is when you tell the cloud code that you must verify your own work with the browser, click through it, and ensure that you haven't broken login, for example. Three is closer to like constitutional AI in the way that Anthropic kind of conceives of it, where they're talking about. there's a constitution of what you must do, and another agent will kind of come and verify that you did that correctly. Otherwise, give you feedback that you need to action. Taking all this together, how does this actually change a working software developers day? So like I said before, I propose a deep focus session in the beginning of the day. You might go through all the backlog tasks in GitHub, the software development lifecycle chores that you need to queue up. fire those all into codecs. start working on the features you really care about in an IDE perhaps or in Cloud Code, And then essentially you walk away after getting them kind of going on their, the work tracks that you've identified for that day, because you have access to them on your phone. So even when you're out wandering around on the edge or on LTE, you can fire messages back to them, and you can start reviewing the PRs as they come through on your phone. And now, again, because agents are, we haven't quite found the LLM wall, like with Opus 4.6, it's quite reasonable to leave a natural language comment on a PR in GitHub Mobile and, at Claude or at Cursor Agent or at Vercelbot, and say, this needs to change. And most of the time, it's going to get it right. And so this kind of enables this complete loop where you're actually spending less and less time away from your desk and Less and less time at your desk, you're spending less and less time injuring yourself, your wrists, your hands. and you're getting oxygen when you're getting better ideas when you're out walking around, but you're still in the loop and you're still directing work forward and making progress. Thank you. So, I'll just quickly show that a key learning that I found in doing this kind of as an experiment, If you just use the tools on your own, like in the beginning of the week, Monday feels amazing. I can rip through a ton of work. Tuesday feels the same. Now I got a bunch of random ass in the middle of the week that kind of threw me off course. And then by Friday I'm completely wasted, and I don't remember what the hell I did. And I know that work shipped, but it's all disorganized. As my illustrious colleague who's with us here, Nick, reminded me, all of Cloud Code's conversations are saved locally in JSON-L files. And what that enables you to do is to start working smarter and have a scheduled pass where your agent goes back and reviews your own conversations with it. at the end of every week, at the end of every day, if you want, and say, look for the patterns where you had to do a significant amount of spending thinking tokens to get something right, or you and I had to go back and forth and eliminate ambiguity in order to get a task done correctly and figure out the skills that are missing. What's the delta for if you had these tools, this MCP server, or these skills? How could we tighten that loop so that doesn't happen next week? And then this is a way in which just by working regularly with your own tools, your entire system or your entire harness can start to get smarter. There is a built-in skill in Cloud Code now to not only build its own skills, but evaluate skills, improve skills, and take natural language prompt and just create bespoke skills that you need. So I highly recommend doing that, and then tightening that loop so that you can still get your work done, still deliver what you need to at work, but spend less and less time at your desk. [15:00] that starts to look like is you're working you're still paying attention to your main preferred aperture, whatever it is. Maybe it's Z, maybe it's cursor, maybe it's quad code. in the terminal. but the patterns are being built up because you're not trashing all of the context that you're building up while working. you're treating all of those sessions as gold, which they are, because A single pass with Opus 4.6 can reveal a ton of skills that if we had this next week, we I can do this way more efficiently, way more quickly, in a way more reliable manner. Last thing I'll just share for for giggles. I love my Uber ring, and one of the first things I did was connect it via MCP. There's a couple of GitHub projects that enable you to do that, and I gave it to Claude. And so when I'm arguing with Claude about a project, there are times he will literally come back and say, 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. and I sell them 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. And so this is kind of a fun thing too, but I do think there is something to this as well, where you start to actually look at your work holistically not just in terms of the conversations you're having with which colleagues, your tickets and everything. the skills that you have, but then also the condition of your body. What times are you able to focus the best? "How much sleep are you getting?" And I think this is super important because if we just kind of do this mindlessly, the default path is going to be burnout, but now burnout turbo, like super fast and easier than ever. enabled by LLMs, right? Whereas the intentional path is a little bit more like, how do I preserve myself, still do my best work and direct agents to do the minutia for me while I'm still responsible for the quality and the and actually shipping. So if you find any of this interesting, I would recommend try building one signal layer. It can be as simple as just plugging in Slack or linear or whatever you find to be the highest cost context switch for you into your preferred pane of glass that you're working with. add some verification gates you don't have. For Chrome, for Cloud Code, it's as simple as passing dash dash Chrome now and giving it access to its own browser. And then with the margin that you get back, use that to go to a picnic in the park alone, or go on a walk, or play with your dog, or whatever the case may be. So yeah, the tools are nuclear now. Our nervous systems are still ancient. And so what I'm thinking about these days is trying to find some developer balance. Hope that was helpful. Thank you so much. Any questions? Yes. Yeah, so I guess I'm... somewhat early in my career. And that means skill development also very important. doing deep work or at least like that. I learned to program by doing a lot of getting into issues. Thank you. Peace. overcoming those hurdles. Totally. sort of And I'm... also super on board with this new flow of working, but it sort of almost felt like a MR PALLADINO: Yeah. spin. a skill deficit for me. It's made it harder to learn. Have you found a balance for that work? Yeah, you can store... I'll just go ahead and... I don't know, but we're going to benefit. Yeah, excellent question. So to repeat in case it's not recorded, the question is basically if I'm early in my career and This is all like skill advancement, but then how do I actually do the hard skill development? And it's my fear is almost that this could kind of take it away from me. and how do I manage that or maintain it? The way I think about that is, 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. So, I'm shipping TypeScript systems and rag systems and doing AWS deployments because I used to do that the hard way for many, many years. And so, I have those battle scars in my scar tissue of doing it, and I can immediately catch Claude, for example, and say, "No, that's insane. We're not doing that." The second it says something that's a hallucination or is not a good idea because I've spent that time building that up. I think you should absolutely still do that. I think you should go deep on those things. And I think it's even possible with LLMs and AI to go deeper, faster, and to even say like, test me, where am I missing this? And like, my mental model here is still murky. So highly recommend doing that. Build some of those skills, still code some stuff by hand, figure out what's painful about it. But then once you start to develop those skills and you have confidence in them, then it's okay. If you've shipped a ton of Ruby apps, it might be okay to start shipping Ruby apps faster with LLMs and Claude. You're also the ONI delegate. your qualified trust. I would. If my focus is kind of like skilling up and making sure that I'm on a solid foundation, yeah, I would recommend that. I would also say don't get discouraged because... in the past when I was coming up and learning, I didn't know the names of the things that I didn't know, so I couldn't ask, you know? And now you can kind of ask and go faster and deeper on it. It's almost like, if you're more honest [20:00] - To yourself about, I don't know this, you can go faster. And I still think there's a super bright future for that. So yeah. Great question. So you talked about getting forward 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 jump in there. Do you just or do you have some kind of intermediary step where there's something that passes that into - Thank you. Yeah, that's a great question. I mean, I have just pointed at it before. The question is, how do you handle Claude going back and reviewing, doing aggregate kind of analysis on JSON-L files if they're super gross and not meant for AI consumption? Yeah. I have had success just pointing at it, but the other thing you can do is use hooks so that the end of every coding session, 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. So it could be Obsidian, could be a flat file of Markdown for that week. Could be just a simple archive, right? And then you run your analysis at the end of the week on that. Using AI or just-- Well, it would be-- for example, I would do it with Claude Hooks. And so it would be at the end of each one of these sessions, or when I say that this is done or we merge the PR, that would be the truth. You could just tell it in the prompt, basically. You could say, look specifically for things that-- Yeah, yeah, it would be an AI prompt. And say like you're specifically looking on the hunt for things that we could make more efficient in the future. or indications of struggle in turn. Be awesome, make yourself. Night time? Like a night shift for your agent? I do. The question is, do you make use of night shift for agent? I've been experimenting with OpenClaw, so I do that with cron jobs and I have some doing some content for me. 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. I'd like to get to the point where, with better systems and verification, that's churning through. 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. All right. Do you let your agent send them? speak back to you or do you read it? It's very . Yeah, great question. The question is, do you let your agents speak back to you in terms of voice, in terms of speed and everything? I actually do all of that. If I'm working most of the time with Cloud Code, I'm speaking to it, and then it's writing back to me, and I'm reading it. But I do a lot of work just in like OpenAI's advanced voice mode. 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. 4.1, right? This GPT-9. I think it's... I can talk to... Even that is quite... you know, intelligent enough to have like a... Yeah. conversations of arguable quality with it before. But there's also the voice space is moving so quickly that even last night I found one that's an open source ghost pepper that's basically whisper flow. It's local only and doesn't use an API. I think there's like a tremendous amount of ability. I have open claw on Twilio. So at night I can ask for the call as opposed to it reading to me. and then I can talk to it and say, this is what I want you to do tomorrow. um, Yeah, I find general voice is super efficient, yeah. Yes, sir? Do you do every kind of work with that? So I've had similar workflows, and I found it works really nicely when you're doing like small bugs or UI fixes and stuff like that. And I can do many things in parallel. But then when I have a more chunky feature, something that needs to touch the back end, it has front end, that changes like the way the application works or a factor. It feels like it grinds all of that to a halt, and I'm not able to parallelize anymore, because Are you able to work on that sort of like more chunky task yourself? Yeah, I think that's a great question. I think everyone's struggling with that. The question is, you know, these flows work really, really well for discrete bite-sized tasks, and I agree with that. And then how do you do bigger, chunkier ones that are like... It's gonna touch the entire stack. It's gonna be an entire new feature for a distributed cloud system. Where my mind goes for that is get work trees, first of all, so the agents can run truly in parallel without stepping on each other's work. And then agent teams with really clearly defined prompts. And then again, it makes the verification gates unit tests even more important. and then kind of continuous integration, getting to the point where I'm constantly testing the application. They're constantly building against a spec. I'm flowing back my insults and rage into the system, and then it's like fixing it as we go. Um, 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. Yeah. That's a great question. [25:00] All right. Thank you so much. Music.