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

Zack Proser, WorkOS

AI Engineer Europe 2026

[Talk page](https://ai.engineer/talks/so9l_MwS2yg-your-attention-is-bottleneck-not-your-agents) · [Video](https://www.youtube.com/watch?v=so9l_MwS2yg)

## Your Attention Is the Bottleneck, Not Your Agents

Closing an agent’s verification loop can save a developer a round trip. Making that gain sustainable requires filtering interruptions, preserving judgment, and spending some of the recovered time away from the desk.

Familiarity with coding agents, Git pull requests, and automated tests will help; MCP is the connection that gives an agent access to external tools such as Slack and Linear.

### Why does getting more done leave you exhausted?

[0:16](https://www.youtube.com/watch?v=so9l_MwS2yg&t=16s)

How can you produce more software than ever and still feel completely fried before lunch? Zack Proser, who works at WorkOS, describes agent-assisted coding as a mix of increased output, repeated adrenaline spikes, and increasingly expensive context switches. WorkOS supplies APIs that help software companies sell to enterprises; inside that environment, more powerful development tools have not automatically made the working day easier to sustain.

![Slide titled “THE DAILY REALITY” shows overlapping Slack and code windows, an exploding-head emoji labeled “GONE,” and an empty attention gauge.](https://ai.engineer/api/talk-essay-media/ad2cb4e4e3d72dec0e578da7fbae5a56ddd37c9dc853a4ac038dbe574e996bc5)

The daily reality: overlapping work windows and depleted attention.

A bug in his Applied AI team’s Slack BlogBot makes the problem concrete. The bot lets colleagues request consistently formatted blog posts without needing to know the publishing process. But its sentence-case pass was damaging acronyms such as `SCIM` and `SSO`. Fixing that normally meant moving among the code, the reported issue, and Slack to check whether the actual workflow now behaved correctly.

Proser changed the agent’s access instead. Claude Code already had access to his Linear tickets; he added Slack read and write access through MCP, then instructed it to fix the bug, verify its own work, and continue until verification was complete. The resulting loop crossed the same application boundary that a human tester would have crossed:

1. Claude Code changed the sentence-case enforcer in the working codebase.
2. It submitted a request to the blog channel through Slack MCP.
3. BlogBot picked up that request and ran through the relevant processing step.
4. Claude checked the resulting output before reporting completion.

Proser reports returning to a completed fix rather than another request for him to discover what was still broken. **Access to the real verification surface removed a human round trip.**

### Execution scales faster than judgment

[2:42](https://www.youtube.com/watch?v=so9l_MwS2yg&t=162s)

The successful fix was both exciting and unsettling. If an agent can complete that loop, why not keep stacking copies of it? Proser imagines fixing 150 bugs per day, conditional on supplying enough context, explicit verification criteria, and tools that can check those criteria. That is a hypothetical workload, not reported throughput. His constraint is overseeing the quality of all that work and still being able to return for another full working day.

His description of agents scaling infinitely expresses the asymmetry: execution capacity can expand much faster than a person’s attention, which degrades under load. He also points to newly available Claude API capabilities as another expansion of access, without identifying a specific service. Proser attributes to [Simon Willison](https://www.lennysnewsletter.com/p/an-ai-state-of-the-union) exhaustion by 11 a.m. after running four parallel agents, using the example to argue for discovering individual limits.

**The developer still supplies judgment and taste:** whether the result actually solves a problem, and whether the stated criteria satisfy human and business needs. Increasing task intake in proportion to agent capacity can consume that judgment faster than it replenishes. Proser organizes his response into four capabilities: signal layers that filter incoming work, voice-first flows, remote control, and a system that improves itself by reviewing its own history. He had already been coding primarily through voice for roughly a year and a half; the other pieces extend that practice into a more sustainable workflow.

![“THE ENABLING STACK” slide displays four cards: Signal Layers, Voice-First Flows, Remote Control, and The System Improves Itself.](https://ai.engineer/api/talk-essay-media/066b127c823f87d0cfa4a86e5d460036f7bdbcea4096461a6a93608c955c2b3c)

Four capabilities in the enabling stack.

### Filter incoming work, then lower the cost of directing it

[5:59](https://www.youtube.com/watch?v=so9l_MwS2yg&t=359s)

Opening Slack to investigate one problem also exposes every other thread and request. Proser estimates his own chance of distraction when combing through Slack at 80%. His signal layer lets Claude Code do that inspection repeatedly instead: look for `@mentions`, direct messages, and high-priority requests, then use Linear MCP access to deduplicate asks and locate the actual tickets. The developer sees actionable work through the environment already in use, rather than entering a feed that can redirect the day.

Voice addresses the other direction of traffic: getting intent into the tools. Proser reports a personal typing best of 90 words per minute and regular voice input around 184 words per minute. These are his input-speed observations, without an accuracy or correction-overhead comparison; they do not establish a coding-productivity multiplier.

The useful consequence is quicker task dispatch. His illustration has a developer speaking across three Cursor windows, Codex, and multiple Claude tabs, getting agents started while a typist is still entering an initial prompt. He expects small savings to compound over years of work. More immediately, becoming comfortable with spoken instructions makes it possible to keep directing work without remaining at a keyboard.

### Leave the desk without moving the execution

[8:15](https://www.youtube.com/watch?v=so9l_MwS2yg&t=495s)

Before discussing remote access, Proser introduces the shower principle. In his framing, focused IDE work is good for executing a clear blueprint: finding symbols, making precise changes, and getting an implementation over the line. The same concentration can narrow the alternatives you consider. Playing with a dog, walking children to the park, or taking a shower can loosen that focus and make a previously elusive solution apparent. He describes this as diffuse thinking, with background problem solving becoming accessible after stepping away.

The new possibility is that stepping away need not stop the implementation. With [Claude Code Remote Control](https://code.claude.com/docs/en/remote-control), Proser enables access through a startup option, a command, or configuration. The session continues running on the development machine with its local filesystem and tools; Claude on his phone can reach that same session from another network, including cellular service out on a trail. The phone is another interface to the existing work, not a replacement execution environment.

The sequence matters: first establish the important work in a focused session, start the agents, and confirm that they are proceeding in the intended direction. Then walk. Proser cites his [film about working with AI in the woods](https://zackproser.com/videos), which he describes as a 32-minute demonstration including phone-based PR review. Less time in a fixed desk posture, and less exposure to repetitive strain, are motivations for the arrangement. When an idea arrives, he can send it straight back to the session that still has access to his machine, instead of trying to remember it until he returns.

### Make independence depend on verification

[11:09](https://www.youtube.com/watch?v=so9l_MwS2yg&t=669s)

“Speed requires safety” is Proser’s condition for letting this work proceed away from the desk. Browser and computer-use tools expand what agents can inspect, but they need explicit obligations to use them. He separates verification into three gates:

| Gate | Check | What it catches |
| --- | --- | --- |
| Code | Run lint, build, and unit tests through hooks | Failures visible to automated code checks |
| Behavior | Use the browser and click through the application | Broken user flows, such as login |
| Requirements | Have another agent review a written set of requirements | Missing obligations and deviations from the intended result |

The first gate uses [Claude Code hooks](https://code.claude.com/docs/en/hooks) to make checking routine. The second requires the agent to exercise behavior rather than infer success from the code alone. For the third, a reviewing agent returns feedback that the implementing agent must address. Proser compares that arrangement to [Constitutional AI](https://www.anthropic.com/research/constitutional-ai-harmlessness-from-ai-feedback); it is an analogy to checking against written principles, not an implementation of the research’s training method.

### A working day with mobile feedback

[12:03](https://www.youtube.com/watch?v=so9l_MwS2yg&t=723s)

Putting the pieces together changes the shape of the day:

1. **Begin with focused setup.** Review GitHub backlog items and software-development lifecycle chores, queue suitable work in Codex, and start the priority features in an IDE or Claude Code.
2. **Confirm the work tracks.** Establish what each agent should be doing before leaving the desk.
3. **Review as results arrive.** Use the phone to inspect PRs and send instructions while away, including over EDGE or LTE.
4. **Send corrections into the existing loop.** Leave natural-language feedback in GitHub Mobile for integrations such as Cursor Agent.

Proser cites **Opus 4.6** as making this sort of correction practical and says it gets the requested change right most of the time in his experience. The human remains in the loop, directing progress and reviewing results, while spending less time physically at the desk.

### Use the week’s friction to improve next week’s tools

[13:22](https://www.youtube.com/watch?v=so9l_MwS2yg&t=802s)

Fast execution alone can still produce a disorganized week. Monday and Tuesday feel productive; interruptions accumulate midweek; by Friday, work has shipped but the developer is exhausted and cannot easily reconstruct what happened. Proser’s colleague Nick pointed out that Claude Code saves its conversations locally as `JSONL`. Those sessions provide a record of both the output and the effort required to obtain it.

A scheduled daily or weekly pass can inspect that record for expensive reasoning, repeated clarification, and missing capabilities. The useful question is specific: which tool, MCP server, or skill would have prevented this particular struggle? Instead of only summarizing completed tasks, the scan produces candidates for improving the next interaction.

Proser describes using a skill that can create, evaluate, and improve other skills from natural-language requests; Anthropic publishes a [skill-creator](https://github.com/anthropics/skills/blob/main/skills/skill-creator/SKILL.md) for this purpose. The mechanism depends on preserving working context, whether the main interface is Zed, Cursor, or a terminal. He reports that a single Opus 4.6 pass can reveal useful missing skills. Conversation history becomes material for improving reliability, rather than something discarded when a task ends.

![Slide titled “WORKING SMARTER The Architecture” shows Local Logs → Scheduled Scan → Output, with a speaker inset below.](https://ai.engineer/api/talk-essay-media/3489734aff607e52acb9c2b8bbb6bf9ec38417ca65e9f76c3448e81b23745c7a)

Working smarter: local conversation logs flow through a scheduled scan into suggested skills, tasks, and patterns.

### Include the person in the system

[15:30](https://www.youtube.com/watch?v=so9l_MwS2yg&t=930s)

Proser extends that context to his own physical condition by connecting Oura Ring data to Claude through MCP. In one recurring interaction, Claude sees poor sleep and proposes doing only the first part of a project, leaving the rest until tomorrow. Proser jokes that he overrides the suggestion—but at least it makes him consider taking a break.

Sleep and the times when he can focus best belong alongside tickets, colleagues’ requests, and available skills. **Delegation should preserve the person who remains responsible for quality, review, and shipping.** Without that intention, more powerful tools can simply make burnout arrive faster.

His prepared close proposes a small adoption sequence: connect the highest-cost context switch, such as Slack or Linear, to the working interface; add a verification gate that is currently missing; then spend the recovered margin on a walk, a picnic, or time with the dog. For browser access, he names [Claude Code’s Chrome integration](https://code.claude.com/docs/en/chrome):

```bash
claude --chrome
```

The command gives the agent a verification tool; the task still needs an instruction to use it. Product setup is version-dependent: current documentation supplies the requirements for Chrome and Remote Control, and remote execution requires the development machine to remain awake and connected. The goal is to recover usable time, not immediately fill it with another queue of tasks.

### Build the judgment you need to delegate

[17:36](https://www.youtube.com/watch?v=so9l_MwS2yg&t=1056s)

The first audience question exposes a dependency in this workflow: where does the developer’s judgment come from? An early-career programmer describes learning through deep work, difficult bugs, and overcoming obstacles. If agents remove those experiences, faster delivery can coincide with a growing skill deficit.

Proser’s advice is to avoid delegating work you do not yet know how to do yourself. He uses agents for TypeScript systems, RAG systems, and AWS deployments because years of doing that work directly help him catch hallucinations and reject bad proposals. He still recommends going deep, writing code by hand, and discovering what makes the task difficult. AI can support that learning by testing understanding and exposing gaps in a murky mental model.

Once that foundation exists, acceleration becomes easier to evaluate: someone who has shipped many Ruby applications can use an LLM to ship the next one faster. The questioner condenses this into delegating only code one is qualified to review, which Proser endorses when the priority is skill growth and a solid foundation. He also sees an advantage for learners: AI can help name concepts they do not yet know how to ask about. Admitting a gap can become the start of deeper learning rather than a reason to conceal it.

### Extract the useful parts of noisy session logs

[20:08](https://www.youtube.com/watch?v=so9l_MwS2yg&t=1208s)

Another question challenges the practicality of reviewing raw `JSONL`: the files can be long and full of material poorly suited to model consumption. Proser reports success pointing Claude directly at them, but also proposes a smaller intermediate record. At the end of a coding session, a hook can ask the agent to save key discussion points, especially places where the work became difficult or consumed unusual effort.

The destination can be Obsidian, a weekly Markdown file, or a simple archive. A weekly analysis then reads those extracted records. Possible triggers include session completion, an explicit declaration that the work is done, or a merged PR. Asked whether the selection is deterministic, Proser clarifies that it is an AI prompt: look for struggle, churn, and opportunities to make future work more efficient. The hook determines when extraction runs; the model decides which parts are worth retaining.

### An overnight queue still creates morning review

[21:31](https://www.youtube.com/watch?v=so9l_MwS2yg&t=1291s)

Proser’s overnight experiments use OpenClaw with cron jobs to produce content. The next morning, he reviews the results and merges only a small, unspecified fraction. That experience places the review bottleneck back in view: generating work while asleep does not guarantee that the output is worth shipping.

The more systematic arrangement he wants would put all work in Linear, use subtasks for bugs and feature requests, and mark suitable tickets `agent ready`. He proposes polling those tickets every fifteen minutes, day and night, for personal and company work. This is a desired workflow dependent on better systems and verification, not an already demonstrated reliable queue.

### Speak instructions, read results—or stay in conversation

[22:16](https://www.youtube.com/watch?v=so9l_MwS2yg&t=1336s)

Voice input does not require voice output. Asked how he handles verbose responses, Proser says his usual Claude Code arrangement is to speak requests and read the written replies. For exploring an idea, he instead uses ChatGPT’s advanced voice mode: walk, talk back and forth, sharpen the architecture, then ask for a succinct transcript or architecture description to paste into the next tool.

An audience member asks whether that voice mode is limited to **GPT-4.1**, but the exchange does not settle the model version. Proser’s emphasis is on the usefulness of the conversation. He also points to [Ghost Pepper](https://github.com/matthartman/ghost-pepper/blob/main/README.md), which he describes as an open-source alternative to Wispr Flow that runs locally without an API. His OpenClaw setup connects to Twilio, letting him request a call at night and discuss what he wants done the following day. These are different uses of voice: dictation for directing code, conversation for developing an idea, and a call for planning future work.

### Whole-stack changes still demand concentrated attention

[23:39](https://www.youtube.com/watch?v=so9l_MwS2yg&t=1419s)

The final question draws a boundary around easy parallelism. Small bugs and UI fixes can be dispatched independently. A feature that changes the backend, database, and frontend—or a refactor that alters how the application works—can require enough coordinated attention to bring that parallel workflow to a halt. Proser agrees that discrete tasks fit these arrangements better and that larger changes remain a shared difficulty.

His starting point is Git worktrees, so agents can make changes in separate working directories, followed by agent teams with clearly defined prompts. For example, two worktrees can isolate implementation tracks:

```bash
git worktree add -b feature/backend ../app-backend
git worktree add -b feature/frontend ../app-frontend
```

That separates file edits; it does not define the contract between the backend and frontend. The agents still need explicit responsibilities and a shared specification.

For these larger tasks, verification gates, unit tests, continuous integration, and repeated application testing become more important. Agents build against a specification, and human feedback drives corrections as integration exposes problems. Proser expects more complete execution and verification systems to make this more reliable as models improve, but does not present whole-stack parallel development as solved. The unresolved work is coordinating a coherent change and determining that the application, as a whole, is correct.

## Resources

- [Claude Code Remote Control](https://code.claude.com/docs/en/remote-control) — Connect a phone or browser to a Claude Code session running on your development machine, with current setup instructions and requirements.
- [Simon Willison on agentic engineering and exhaustion](https://www.lennysnewsletter.com/p/an-ai-state-of-the-union) — An interview covering coding-agent workflows, cognitive load, verification patterns, and security. The public introduction discusses exhaustion by 11 a.m.
- [Zack Proser's video catalog](https://zackproser.com/videos) — Includes the 32:14 talk Walking and Talking in the Woods with AI, listed under October 2025.
- [Claude Code hooks reference](https://code.claude.com/docs/en/hooks) — Reference for configuring lifecycle hooks that trigger checks and other workflow actions.
- [Claude Code browser integration](https://code.claude.com/docs/en/chrome) — Setup and usage documentation for connecting Claude Code to Chrome for browser interaction.
- [Constitutional AI: Harmlessness from AI feedback](https://www.anthropic.com/research/constitutional-ai-harmlessness-from-ai-feedback) — Anthropic's research on using written principles and AI feedback to train more harmless assistants.
- [Anthropic skill-creator](https://github.com/anthropics/skills/blob/main/skills/skill-creator/SKILL.md) — Anthropic's public skill for creating, evaluating, and improving agent skills.
- [Ghost Pepper](https://github.com/matthartman/ghost-pepper/blob/main/README.md) — An open-source macOS application for dictation and meeting transcription using on-device models.

## Slides

### Untethered Productivity

Zack Proser introduces his search for balance amid a flood of new AI coding tools, while staying healthy, creative, and shipping.

[0:27](https://www.youtube.com/watch?v=so9l_MwS2yg&t=27s) [Zack Proser's title slide on staying healthy, creative, and productive in the AI coding era.](https://assets.ai.engineer/sites/aiecode2025/sha256/e25200e24fd23987be030bf38bf398d1a1e34002578ceca193d5ae41ca75149a.webp)

UNTETHERED
PRODUCTIVITY

Staying Healthy, Creative, and Shipping in the AI Coding Era

Zack Proser
Applied AI · WorkOS · @zackproser

AIE

RUN MCP

Google DeepMind

Interface text:
Untethered Productivity - Sli[illegible]
localhost:3031/1
Ask Gemini
Work

### The Daily Reality: Distracted

Overlapping Slack and coding windows compete for attention as Proser describes the exhaustion of switching between AI agent tasks.

[0:39](https://www.youtube.com/watch?v=so9l_MwS2yg&t=39s) [Overlapping coding and messaging windows illustrate distraction and reduced attention.](https://assets.ai.engineer/sites/aiecode2025/sha256/a1b118ee763f44ad92b604c029b0ec4b77b22533ff1ddc2377dc176c26ac78d5.webp)

THE DAILY REALITY

Slack  #eng-requests  #incidents  #product-asks  9
“Following up on auth — any ETA? Customer demo [illegible]”

Slack – DMs  Sarah Chen  Mike R.  10
“Mike R: Can you review my PR? It’s been [illegible]”

VS Code  api-client.ts  retry.ts
// Agent output — did this break the
// existing retry tests?
const delay = backoff * Math.pow(2, attempt)
// TODO: verify this is correct

[illegible]
22 files [illegible]
CI fail[illegible]

Terminal
$ git status
  modified: src/[illegible]
  modified: src/[illegible]
  modified: src/[illegible]
3 agents touched these files

DISTRACTED
ATTENTION

AIE
RUN MCP
Engineering the future of AI

Interface text:
Untethered Productivity - Sli[illegible]
localhost:3031/2
Ask Gemini
Work

### The Daily Reality

Overlapping agent work and Slack incidents compete for attention until the gauge reads “GONE.” Proser says context switching has become more exhausting as he works with agents.

[0:51](https://www.youtube.com/watch?v=so9l_MwS2yg&t=51s) [An incident message and nearly empty attention gauge illustrate escalating overload.](https://assets.ai.engineer/sites/aiecode2025/sha256/8c4c612f36e34a1c1008d948a1e68ce8fa29830b3290a8daae89e517fb4cafa1.webp)

THE DAILY REALITY

Slack  #eng-requests  #incidents  #product-asks  15
“@channel Auth fix deployed. But now SSO is broken for enterprise accounts.”

Slack – DMs  Sarah Chen  Mike R.
“Sarah: The customer escalated. Legal [illegible] by EOD.”

$ claude status
  Agent A: feature/auth — waiting for review
  Agent B: fix/timeout — conflicts detected
  Agent C: dashboard — 78% complete

GONE
ATTENTION

AIE
Engineering the future of AI

Interface text:
Untethered Productivity - Sli…
localhost:3031/2
Ask Gemini
Work
RUN MCP

[0:55](https://www.youtube.com/watch?v=so9l_MwS2yg&t=55s) [Overlapping work windows illustrate the strain of switching between agent tasks.](https://assets.ai.engineer/sites/aiecode2025/sha256/1498f3ddc24f92f334370e81caa9f483fffa3bd4221705c27307a7b9e6535310.webp)

THE DAILY REALITY

Slack  #eng-requests  #incidents  #product-asks  16
“@channel Auth fix deployed. But now SSO is broken for enterprise accounts.”

Slack – DMs  Sarah Chen  Mike R.
“Sarah: The customer escalated. Legal [illegible] by EOD.”

VS Code  [illegible]
// [illegible] condition when two
// [illegible] middleware
[illegible] '@upstash/redis'
// Wait, why is there a Redis import?
// [illegible] added this?

GitHub  PR #312 auth refactor  16
6 files changed
Merge conflicts with main
Last updated: 4 hours ago

Terminal  ~/project
$ claude status
  Agent A: feature/auth — waiting for review
  Agent B: fix/timeout — conflicts detected
  Agent C: dashboard — 78% complete

Slack  #incidents  19
“Rollback complete but 3 customers saw errors. Postmortem needed.”

GONE
ATTENTION

This is how most of us manage agent work right now.
Alt-tab. Read. Switch. Forget. Repeat. The tools got faster — we didn't.

AIE
Braintrust  WorkOS  OpenAI

Interface text:
Untethered Productivity - Sli…
localhost:3031/2
Ask Gemini
Work
RUN MCP

### Closing the Loop

Proser gave Claude Code direct access to Slack to fix a sentence-case bug in WorkOS’s blog bot. The slide says it deployed, tested, and verified the fix without him.

[0:59](https://www.youtube.com/watch?v=so9l_MwS2yg&t=59s) [A Slack blog bot had an acronym bug; Claude Code was given Slack access to fix, deploy, test, and verify it.](https://assets.ai.engineer/sites/aiecode2025/sha256/5b09ad044beb489ad1fc766661acb116575754bce466a19f37f6bf7d2eb87971.webp)

CLOSING THE LOOP

• Slack bot at WorkOS – anyone requests a blog draft, gets it in 90 seconds
• Needed a bug fix – acronyms like SCIM and SSO getting mangled
• Normally: that window chaos you just saw
• Instead: gave Claude Code direct access to Slack – it fixed, deployed, tested, and verified without me

AIE
RUN MCP
Braintrust
WorkOS
OpenAI

Interface text:
Untethered Productivity - Sli…
localhost:3031/3
Ask Gemini
Work

### Closing the Loop in Action

Claude Code fixes the acronym bug, deploys the change, and tests it through Slack. The Blog Bot’s sentence-case step shows SCIM and SSO preserved.

[2:01](https://www.youtube.com/watch?v=so9l_MwS2yg&t=121s) [A terminal shows an acronym fix and deployment while a Slack bot processes a test request.](https://assets.ai.engineer/sites/aiecode2025/sha256/18a2292ad3a249aadc17e5027531c3962805b7272a5d216acd0a0d84229cea22.webp)

CLOSING THE LOOP In Action

Claude Code
~/blog-bot $ claude
> Fix the sentence case enforcer — it's uppercasing acronyms like "SCIM" and "SSO"
Reading src/pipeline/sentence-case.ts ...
Found the bug: regex doesn't preserve known acronyms in ACRONYM_LIST
Edit src/pipeline/sentence-case.ts
+ const preserved = ACRONYM_LIST.filter(
+ a => input.toUpperCase().includes(a)
+ )
✓ Tests passing (14/14)
✓ Deployed to Cloudflare Workers
> Now testing via Slack...

# blog-drafts
via Claude Slack Connector
zack  just now
Write a post about how SCIM provisioning and SSO configuration work together for enterprise User Management.
Sent using @Claude

Blog Bot  APP
✓ Classifying your input
✓ Generating draft with Claude Opus
✓ Reviewing technical accuracy
✓ Removing AI writing tells
✓ Enforcing sentence case ← SCIM + SSO preserved ✓
✓ Running voice and style checks

Interface text:
Untethered Productivity - Sli...
localhost:3031/4
Ask Gemini
Work
AIE
AI Engineer EUROPE
RUN MCP

### Closing the Loop: Verified Result

Claude Code fixes the acronym bug and deploys the change. A Slack test runs Blog Bot through sentence-case enforcement and produces a draft with SCIM and SSO preserved.

[2:13](https://www.youtube.com/watch?v=so9l_MwS2yg&t=133s) [The demo shows a completed Slack draft with acronyms preserved after the fix.](https://assets.ai.engineer/sites/aiecode2025/sha256/3796976024dad7605fc8d58c91460e32a0c1862055b8802c65ce0a858c66ce75.webp)

CLOSING THE LOOP In Action

Claude Code
~/blog-bot $ claude
> Fix the sentence case enforcer — it's uppercasing acronyms like "SCIM" and "SSO"
Reading src/pipeline/sentence-case.ts ...
Found the bug: regex doesn't preserve known acronyms in ACRONYM_LIST
Edit src/pipeline/sentence-case.ts
+ const preserved = ACRONYM_LIST.filter(
+ a => input.toUpperCase().includes(a)
+ )
✓ Tests passing (14/14)
✓ Deployed to Cloudflare Workers
> Now testing via Slack...

# blog-drafts
via Claude Slack Connector

zack  just now
Write a post about how SCIM provisioning and SSO configuration work together for enterprise User Management.
Sent using @Claude

Blog Bot  APP
✅ Classifying your input
✅ Generating draft with Claude Opus
✅ Reviewing technical accuracy
✅ Removing AI writing tells
✅ Enforcing sentence case ← SCIM + SSO preserved ✓
✅ Running voice and style checks
✅ Delivering to Slack

Draft ready — How SCIM provisioning and SSO configuration work together
"Your app works great for small teams. Then a Fortune 500 prospect asks: 'Do you support SCIM provisioning? Can our IT admin configure SSO themselves?'..."
Category: guides · Slug: scim-sso-enterprise-user-management

Claude Code fixed the bug → deployed to CF → tested via Slack → acronyms preserved. The loop verified itself.
▶ Replay

AIE
RUN MCP
AI Engineer

Interface text:
Untethered Productivity - Sli...
localhost:3031/4
Ask Gemini
Work

### That felt incredible. It also scared me.

After Claude completed and verified the bug fix, Proser found the experience incredible and frightening: he saw no ceiling to what the tools could do.

[2:40](https://www.youtube.com/watch?v=so9l_MwS2yg&t=160s) [A black slide states that the experience felt incredible and also scary.](https://assets.ai.engineer/sites/aiecode2025/sha256/6ae828a1687556d787452c426634ad0838c1aa0d50f2f5e4410ea85948b1e945.webp)

That felt incredible.
It also scared me.

AIE
RUN
MCP
Engineering the future of AI

Interface text:
Untethered Productivity - Sli…
localhost:3031/5
Ask Gemini
Work

### The tools are nuclear

Proser is looking for developer balance as increasingly powerful tools meet a relatively ancient nervous system.

[2:52](https://www.youtube.com/watch?v=so9l_MwS2yg&t=172s) [The slide contrasts powerful tools with the relatively ancient nervous system and proposes developer balance.](https://assets.ai.engineer/sites/aiecode2025/sha256/f80a2efc8cd49a49a429eab4444f6fce31be2a14799e66c280c2efc2b262f161.webp)

The tools are nuclear.
Your nervous system is relatively ancient.

This is the tension. The answer is developer balance.

AIE
RUN MCP
Engineering the future of AI

Interface text:
Untethered Productivity - Sli…
localhost:3031/6
Ask Gemini
Work

### Why not stack 150 loops?

The demo shows 12 loops running and 11 completed, while warning that approvals can outpace reading. Proser says overseeing quality at that scale is hard to sustain across workdays.

[3:23](https://www.youtube.com/watch?v=so9l_MwS2yg&t=203s) [A dashboard shows 12 agent loops, 11 completed, alongside a warning about approving work without reading.](https://assets.ai.engineer/sites/aiecode2025/sha256/27c483fdce1d7d27d04609cf25a700b1b7bed5c1a200f8215ab2135f2d7fee47.webp)

SO WHY NOT STACK 150 LOOPS?

ACTIVE AGENT LOOPS
Auth refactor ✓
Dashboard UI ✓
API migration ✓
Test suite ✓
Blog post pipeline ✓
Onboarding flow ✓
Billing integration ✓
Search indexer
Email templates ✓
CI/CD pipeline ✓
Monitoring alerts ✓
SDK update ✓

Loops running: 12  Completed: 11

I can't track any of these
12 loops. Approving without reading. This is the trap.
▶ Replay the spiral

AIE
RUN MCP
AI Engineer
EUROPE

Interface text:
Untethered Productivity - Sli[illegible]
localhost:3031/7
Ask Gemini
Work

### The agents aren't the bottleneck. We are.

Proser argues that agents can scale and verification can be automated, but human attention degrades under load, limiting how much work one person can oversee.

[3:33](https://www.youtube.com/watch?v=so9l_MwS2yg&t=213s) [The slide contrasts scalable agents and automatable verification with finite human attention.](https://assets.ai.engineer/sites/aiecode2025/sha256/b74febedc00e763a03963e08576377eb862a2f6b91c01821c3499167d4c8887a.webp)

The agents aren't the bottleneck.
We are.

Agents
Scale infinitely. Never tired. Don't context-switch.

Verification
Can be automated. Lint, test, screenshot, review gates.

Your attention
Fixed. Finite. Degrades under load. This is the constraint.

AIE
AI Engineer
EUROPE
RUN MCP

Interface text:
Untethered Productivity - Sli…
localhost:3031/8
Ask Gemini
Work

### You're Not Imagining It

Simon Willison says four parallel agents leave him wiped out by 11 AM. Proser sees similar strain on the Applied AI team and introduces his approach to developer balance.

[4:01](https://www.youtube.com/watch?v=so9l_MwS2yg&t=241s) [A slide cites Simon Willison on fatigue from running four parallel agents and introduces advice for finding developer balance.](https://assets.ai.engineer/sites/aiecode2025/sha256/a8590185769cef9a508ae34a205d2f52687b150bb8cdbbdd436c97c5b9227ffa.webp)

YOU’RE NOT IMAGINING IT

SIMON WILLISON · Lenny's Podcast, Apr 2 2026

“I fire up 4 parallel agents and I'm wiped out by 11 AM. Finding our new limits is a personal skill we need to learn.”

I'm seeing this in my own work on the Applied AI team.
Here's how I recommend finding developer balance.

AIE
RUN MCP
AI Engineer

Interface text:
Untethered Productivity - Sli…
localhost:3031/9
Ask Gemini
Work

[4:22](https://www.youtube.com/watch?v=so9l_MwS2yg&t=262s) [A quotation about exhaustion from parallel agents introduces the need for developer balance.](https://assets.ai.engineer/sites/aiecode2025/sha256/b42674745dd6d4e3a560b157664de234e4c3d4ec099f0755f57e2611975460c1.webp)

YOU’RE NOT IMAGINING IT

SIMON WILLISON · Lenny's Podcast, Apr 2 2026

“I fire up 4 parallel agents and I'm wiped out by 11 AM. Finding our new limits is a personal skill we need to learn.”

I'm seeing this in my own work on the Applied AI team.
Here's how I recommend finding developer balance.

AIE
RUN MCP
Engineering the future of AI

Interface text:
Untethered Productivity - Sli…
localhost:3031/9
Ask Gemini
Work

### Developer Balance

Proser assigns agents speed and execution while people supply judgment and decide when to stop. He recommends verification in every loop so developers can walk away with confidence.

[4:32](https://www.youtube.com/watch?v=so9l_MwS2yg&t=272s) [Developer balance assigns speed and execution to agents while retaining human judgment and verification.](https://assets.ai.engineer/sites/aiecode2025/sha256/f9e8c5d4cb595f7d80ef60204e898dbb747b142ac1611b7923e21b3a4ecf6859.webp)

DEVELOPER BALANCE

We need to bring the human developer into balance with this new way of working.

It has never been faster to burn yourself out. Getting this right is critical.

Agents for what they do best: speed, tireless execution, pattern detection.
Us for what we still do best: judgment, taste, and knowing when to stop.
Build verification into every loop so you can walk away with confidence.

Here's the stack that lets me do that.

AIE
RUN MCP
Engineering the future of AI

Interface text:
Untethered Productivity - Sli…
localhost:3031/10
Ask Gemini
Work

### The Enabling Stack

Proser outlines an early stack for untethered work: filter incoming signals, dictate intent, control agents remotely, and use work patterns to recommend automation.

[5:10](https://www.youtube.com/watch?v=so9l_MwS2yg&t=310s) [Four capabilities: signal layers, voice-first flows, remote control, and a system that improves itself.](https://assets.ai.engineer/sites/aiecode2025/sha256/4fa41c3efff2322750a9250d6c2e71d29db0aa9f93649bfaf6ce2b427df6b9ce.webp)

THE ENABLING STACK

Four capabilities that make untethered work possible:

⚡ Signal Layers
Never open Slack. Only see the delta.

🎤 Voice-First Flows
Dictate intent. Your voice is the new keyboard.

📱 Remote Control
Walk away. Agents keep working on your machine.

🧠 The System Improves Itself
Finds your patterns. Recommends what to automate.

Let me walk through each one.

AIE
RUN MCP
Engineering the future of AI

Interface text:
Untethered Productivity - Sli…
localhost:3031/11
Ask Gemini
Work

### Signal Layers

In the demo, Claude Code scans Slack, creates two Linear tickets and deduplicates another against an existing ticket. The slide claims a 90% reduction in perceived context-switching cost.

[6:05](https://www.youtube.com/watch?v=so9l_MwS2yg&t=365s) [A simulated workflow scans messages, creates and deduplicates tickets, and summarizes the result.](https://assets.ai.engineer/sites/aiecode2025/sha256/b0e83cbf60765deffd3e704f72bbecab840cfc7b9bb6389aceeab21e990b7763.webp)

⚡ SIGNAL LAYERS

Slack 16
Slack MCP + Linear MCP

Claude Code
$ morning brief
Scanning Slack channels...
→ #eng-requests: auth bug — action needed
→ #incidents: API latency — action needed
→ #product-asks: dashboard timeline — deduped w/ AIE-139
→ DM Sarah: deploy question — surfaced
→ #general: lunch — filtered
Creating Linear tickets...
✓ AIE-142 created from #eng-requests
✓ AIE-143 created from #incidents
↩ AIE-144 deduped → existing AIE-139
Done. 16 messages → 2 new tickets, 1 deduped.
You never opened Slack. You never opened Linear.

noise filtered out

Linear
AIE-142 — created
Auth bug blocking deploy
from #eng-requests

AIE-143 — created
API latency investigation
from #incidents

AIE-144 — deduped
Dashboard shipping timeline
from #product-asks

Clean. Organized. Deduped.

Two MCP connectors. 90% reduction in perceived context-switching cost.
Slack + Linear flow into Claude Code. One interface. Zero alt-tabbing.
▶ Replay

AIE
AI Engineer
EUROPE

Interface text:
Untethered Productivity - Sli…
localhost:3031/12
Ask Gemini
Work

### Signal Layers

Claude Code scans Slack for actionable requests and uses Linear to deduplicate them. In the demo, 16 messages yield two new tickets and one deduplicated request, keeping the developer focused away from Slack.

[6:23](https://www.youtube.com/watch?v=so9l_MwS2yg&t=383s) [The completed message-to-ticket workflow and its summary are shown again.](https://assets.ai.engineer/sites/aiecode2025/sha256/8f306e0afb153d9e1eb4438ce44ae06eabb0f2ba70982b0fd3ed4585c755a972.webp)

⚡ SIGNAL LAYERS

Slack 16
Slack MCP + Linear MCP

Claude Code
$ morning brief
Scanning Slack channels...
→ #eng-requests: auth bug — action needed
→ #incidents: API latency — action needed
→ #product-asks: dashboard timeline — deduped w/ AIE-139
→ DM Sarah: deploy question — surfaced
→ #general: lunch — filtered
Creating Linear tickets...
✓ AIE-142 created from #eng-requests
✓ AIE-143 created from #incidents
↩ AIE-144 deduped → existing AIE-139
Done. 16 messages → 2 new tickets, 1 deduped.
You never opened Slack. You never opened Linear.

noise filtered out

Linear
AIE-142 — created
Auth bug blocking deploy
from #eng-requests

AIE-143 — created
API latency investigation
from #incidents

AIE-144 — deduped
Dashboard shipping timeline
from #product-asks

Clean. Organized. Deduped.

Two MCP connectors. 90% reduction in perceived context-switching cost.
Slack + Linear flow into Claude Code. One interface. Zero alt-tabbing.
▶ Replay

AIE
RUN MCP
Engineering the future of AI

Interface text:
Untethered Productivity - Sli...
localhost:3031/12
Ask Gemini
Work

[6:47](https://www.youtube.com/watch?v=so9l_MwS2yg&t=407s) [A Slack and Linear workflow filters messages and creates or deduplicates tickets.](https://assets.ai.engineer/sites/aiecode2025/sha256/dde3dfe8481b341594926e334e29431b3c61895d5f569f376b3f19e672b45ea3.webp)

⚡ SIGNAL LAYERS

Slack 16
Slack MCP + Linear MCP

Claude Code
$ morning brief
Scanning Slack channels...
→ #eng-requests: auth bug — action needed
→ #incidents: API latency — action needed
→ #product-asks: dashboard timeline — deduped w/ AIE-139
→ DM Sarah: deploy question — surfaced
→ #general: lunch — filtered
Creating Linear tickets...
✓ AIE-142 created from #eng-requests
✓ AIE-143 created from #incidents
↩ AIE-144 deduped → existing AIE-139

noise filtered out

Linear
AIE-142 — created
Auth bug blocking deploy
from #eng-requests

AIE-143 — created
API latency investigation
from #incidents

AIE-144 — deduped
Dashboard shipping timeline
from #product-asks

AIE
RUN MCP
Engineering the future of AI

Interface text:
Untethered Productivity - Sli...
localhost:3031/12
Ask Gemini
Work

### Voice-First Flows: Voice Capture

The demo turns a filler-heavy spoken request into a polished auth refactor instruction, while comparing 90 WPM typing with 179 WPM voice.

[7:01](https://www.youtube.com/watch?v=so9l_MwS2yg&t=421s) [A voice recording waveform appears at the start of a four-stage pipeline.](https://assets.ai.engineer/sites/aiecode2025/sha256/2beb20c733e30b6f02c17b11a93f420d752dd1078cb7da773a6ae6d35e24c50a.webp)

VOICE-FIRST FLOWS The Pipeline

Voice Capture → Speech Recognition → AI Enhancement → Polished Output

“um so basically I need to like refactor the a...”
Recording...

90 WPM TYPING → 179 WPM VOICE = 2x FASTER

AIE
Engineering the future of AI

Interface text:
Untethered Productivity - Sli...
localhost:3031/13
Ask Gemini
Work

[7:06](https://www.youtube.com/watch?v=so9l_MwS2yg&t=426s) [A raw transcription includes filler words in a request to refactor an authentication module.](https://assets.ai.engineer/sites/aiecode2025/sha256/5f56f29d0d8a6e62342868284fcf44744d09725de72d8abf993dbc2f03dd76c1.webp)

VOICE-FIRST FLOWS The Pipeline

Voice Capture → Speech Recognition → AI Enhancement → Polished Output

RAW TRANSCRIPTION
um so basically I need to like refactor the auth module because um the current implementation is using deprecated methods and uh we should probably add better error handling too I think

Notice the “um”, “like”, “uh” filler words...

90 WPM TYPING → 179 WPM VOICE = 2x FASTER

AIE
RUN MCP
Engineering the future of AI

Interface text:
Untethered Productivity - Sli...
localhost:3031/13
Ask Gemini
Work

[7:09](https://www.youtube.com/watch?v=so9l_MwS2yg&t=429s) [The pipeline displays a polished request to refactor an authentication module and improve error handling.](https://assets.ai.engineer/sites/aiecode2025/sha256/0388f361ab4b46da66434e438283a98b1ab666d705d18ab00ce088a6d2309d96.webp)

VOICE-FIRST FLOWS The Pipeline

Voice Capture → Speech Recognition → AI Enhancement → Polished Output

Text inserted at cursor!
Refactor the auth module: the current implementation uses deprecated methods. Add improved error handling.
Clean, professional text — no editing needed
▶ Replay

90 WPM TYPING → 179 WPM VOICE = 2x FASTER

AIE
RUN MCP
Engineering the future of AI

Interface text:
Untethered Productivity - Sli...
localhost:3031/13
Ask Gemini
Work

### Voice-first flows: The multiplier

An illustrative race shows three voice-dispatched agents finishing tasks while a keyboard-only developer is 26% through the first. Proser describes speaking across multiple agent windows.

[7:49](https://www.youtube.com/watch?v=so9l_MwS2yg&t=469s) [Three voice-dispatched tasks are complete while the keyboard-only task is at 26%.](https://assets.ai.engineer/sites/aiecode2025/sha256/aeba384591cb083005c31f02cfc475b95304ca031f72b32eb3d385e90ec763b6.webp)

VOICE-FIRST FLOWS The Multiplier

What happens when you can speak instructions to 3 agents at once?

VOICE-DISPATCHED AGENTS
Agent A — 100% — Auth module refactor — Done
Agent B — 100% — Dashboard API endpoints — Done
Agent C — 100% — Test suite migration — Done

KEYBOARD-ONLY DEVELOPER
Typing — 26% — Still typing first task...

Voice dispatched 3 tasks in the time keyboard completed 26% of one
Replay race

AIE
Engineering the future of AI

Interface text:
Untethered Productivity - Sli...
localhost:3031/14
Ask Gemini
Work

### Remote Control: The Idea

Proser connects remote control to the shower principle: stepping away can invite new insights while an agent continues working.

[8:12](https://www.youtube.com/watch?v=so9l_MwS2yg&t=492s) [A slide contrasts focused and diffuse modes and suggests work can continue while away from the desk.](https://assets.ai.engineer/sites/aiecode2025/sha256/c6d4be489bafae36c0c10779049fd43184df6e3dcb4cacb160cb4a9617fbf438.webp)

📱 REMOTE CONTROL The Idea

You know the shower principle?

You're stuck on a hard problem at your desk. Focused mode — deep concentration, narrowing in. Then you walk away — go for a run, stand in line at the grocery store — and suddenly the solution hits you. Diffuse mode. Your brain makes connections when you step away.

We've always known this. But before, stepping away meant stopping work.

Now it doesn't.

Show of hands — who's controlled an agent from their phone while away from the desk? [hands] OK. For the rest of you, watch this.

AIE
RUN MCP
AI Engineer EUROPE

Interface text:
Untethered Productivity - Sli[illegible]
localhost:3031/15
Ask Gemini
Work

[9:21](https://www.youtube.com/watch?v=so9l_MwS2yg&t=561s) [Slide contrasts focused and diffuse thinking and proposes continuing work while away from the desk.](https://assets.ai.engineer/sites/aiecode2025/sha256/738d45c49d211d8caeb1bc6e77381b51af4fb4614c8a80a1874eb622ea10954d.webp)

📱 REMOTE CONTROL The Idea

You know the shower principle?

You're stuck on a hard problem at your desk. Focused mode — deep concentration, narrowing in. Then you walk away — go for a run, stand in line at the grocery store — and suddenly the solution hits you. Diffuse mode. Your brain makes connections when you step away.

We've always known this. But before, stepping away meant stopping work.

Now it doesn't.

Show of hands — who's controlled an agent from their phone while away from the desk? [hands] OK. For the rest of you, watch this.

AIE
RUN MCP
Engineering the future of AI

Interface text:
Untethered Productivity - Sli[illegible]
localhost:3031/15
Ask Gemini
Work

### Remote Control: The Flow

In the example, a phone message redirects an agent running on the dev machine from auth work to a Redis cache. The timeline ends with a PR ready at 9:35.

[10:21](https://www.youtube.com/watch?v=so9l_MwS2yg&t=621s) [A diagram shows a user redirecting an agent from a phone while the agent runs on a development machine.](https://assets.ai.engineer/sites/aiecode2025/sha256/684e40b503b1e7876b6d6398bdbf88568c944b23a25c193531d91d387cd7a47e.webp)

REMOTE CONTROL The Flow

YOUR DEV MACHINE
$ claude --remote-control
Session: abc-xyz-123
Accessible via Claude app
⋯ Redirecting to fix/api-cache ...
✓ src/auth.ts modified
✓ src/middleware.ts modified
✓ fix/api-cache — PR #312 ready
Agent keeps running headless

YOU
Pull out phone. Redirect agent.
Done. PR ready. Still outside.

CLAUDE APP
Connected to dev machine
You: Stop auth work. Cache the /api/users response instead — use Redis with 5min TTL
Claude: Done. Added Redis cache to /api/users. PR #312 ready for review.
Your voice → agent on your machine

Timeline: 9:00 – Start agent; 9:05 – Walk away; 9:20 – Insight; 9:21 – Redirect; 9:35 – PR ready
▶ Replay

AIE
AI Engineer EUROPE
RUN MCP

Interface text:
Untethered Productivity - Sli…
localhost:3031/16
Ask Gemini
Work

### Verification Is the Bottleneck

Proser’s first verification gate uses lint and build checks to catch syntax, type and import issues. He also calls for unit tests and hooks so agents verify their work before he walks away.

[11:10](https://www.youtube.com/watch?v=so9l_MwS2yg&t=670s) [Slide introduces lint and build as the first verification gate.](https://assets.ai.engineer/sites/aiecode2025/sha256/5251b4c8d856f8a23074f9bd08b9a8bd46bf48c3aa0d6ff87a6c83d3f1fc95c1.webp)

VERIFICATION IS THE BOTTLENECK

You can only walk away when agents can prove their own work.

1
GATE 1: Lint & Build
tsc + eslint for TypeScript. Table stakes. Catches syntax errors, type mismatches, import issues.

AIE
RUN MCP
AI Engineer EUROPE

Interface text:
Untethered Productivity - Sli…
localhost:3031/17?clicks=1
Ask Gemini
Work

### Choreography of a Day

Proser proposes starting with focused desk work, launching agents, then walking and reviewing their work by phone before returning for a second focused block.

[11:21](https://www.youtube.com/watch?v=so9l_MwS2yg&t=681s) [Slide begins a daily schedule with focused desk work and launching agents.](https://assets.ai.engineer/sites/aiecode2025/sha256/4ef051d98b8d31d0b0eb01a6612417df39618b968757dd8280c60f0efa19f2b3.webp)

CHOREOGRAPHY OF A DAY

7:00 – 9:30  DESK  Home office / deep work
Focused mode
Architect. Plan. Define intent. Kick off agents with verification gates. This is your highest-leverage window.

9:30  DISPATCH
Launch & leave
[illegible]

AIE
RUN MCP
Engineering the future of AI

Interface text:
Untethered Productivity - Sli...
localhost:3031/18?clicks=1
Ask Gemini
Work

[13:03](https://www.youtube.com/watch?v=so9l_MwS2yg&t=783s) [Day timeline from focused desk work through dispatch, walking, mobile review, lunch and a second focused block.](https://assets.ai.engineer/sites/aiecode2025/sha256/2e8b3f607b87751c71a452e28d21eb82a1b2b34737ecb344c03c87480ed0ca07.webp)

CHOREOGRAPHY OF A DAY

7:00 – 9:30  DESK  Home office / deep work
Focused mode
Architect. Plan. Define intent. Kick off agents with verification gates. This is your highest-leverage window.

9:30  DISPATCH  Last thing before you leave the desk
Launch & leave
Spin up 2-3 worktree agents. Voice-dispatch tasks. Walk out the door.

9:45 – 11:00  TRAIL  Outside – trail, park, neighborhood
Walk. Think. Diffuse mode.
Agents run on your machine. You're outside getting sunlight. Pull out phone to check signal layer. Approve a PR from the trail.

11:00 – 12:00  MOBILE  Coffee shop, standing desk, wherever
Review & redirect
Check diffs on phone. Voice-dictate next tasks. Redirect agents if an insight hit during the walk.

12:00 – 1:00  LUNCH  Away from the desk
Eat. Review from phone.
Agents are still running. Approve merges between bites. Or don't – the verification gates catch issues for you.

1:00 – 3:00  DESK  Back at the desk – refreshed
Second focused block

AIE
RUN MCP
AI Engineer
EUROPE

Interface text:
Untethered Productivity - Sli...
localhost:3031/18?clicks=6
Ask Gemini
Work

### The Week Without a System

Proser’s experiment starts with two agents on Monday and reaches 18 sessions by Friday, when he says he can’t recall what shipped. The slide asks whether a system could learn from the context left behind.

[13:23](https://www.youtube.com/watch?v=so9l_MwS2yg&t=803s) [Monday-to-Friday chart shows agent sessions increasing as focus declines and work becomes harder to track.](https://assets.ai.engineer/sites/aiecode2025/sha256/d7d68a4b7bc4cc16dc32903edceb9d1920f01ac6fac1796d404daec09a590197.webp)

THE WEEK WITHOUT A SYSTEM

MON 😊 Fresh start. Two agents running.
TUE 😁 Picking up speed. Five sessions open.
WED 😰 Context-switching across nine outputs.
THU 😫 Rubber-stamping PRs. Can't track them all.
FRI 🤯 Fried. 18 sessions. Zero recall of what shipped.

AIE
RUN MCP
Engineering the future of AI

Interface text:
Untethered Productivity - Sli…
localhost:3031/19
Ask Gemini
Work

[13:30](https://www.youtube.com/watch?v=so9l_MwS2yg&t=810s) [A week of increasing agent sessions and declining recall, followed by a question about learning from lost context.](https://assets.ai.engineer/sites/aiecode2025/sha256/d75352eb4d628d116fd038ef643ab635f0f6fcab2db0b86ebf42a220b6a35953.webp)

THE WEEK WITHOUT A SYSTEM

MON 😊 Fresh start. Two agents running.
TUE 😁 Picking up speed. Five sessions open.
WED 😰 Context-switching across nine outputs.
THU 😫 Rubber-stamping PRs. Can't track them all.
FRI 🤯 Fried. 18 sessions. Zero recall of what shipped.

All that context — every conversation, every fix, every pattern — normally lost.
What if the system itself could learn from it?
▶ Replay

AIE
RUN MCP
Engineering the future of AI

Interface text:
Untethered Productivity - Sli…
localhost:3031/19
Ask Gemini
Work

## Full transcript

[0:00](https://www.youtube.com/watch?v=so9l_MwS2yg&t=0s) [upbeat music] Hey everyone, uh, I'm Zack.

[0:16](https://www.youtube.com/watch?v=so9l_MwS2yg&t=16s) I work at WorkOS. Thanks for coming. Uh, WorkOS is, um, provides drop-in APIs that allow you to take your software and go up market and sell larger deals to enterprises.

[0:26](https://www.youtube.com/watch?v=so9l_MwS2yg&t=26s) Uh, but what I'm gonna talk about now is, um, 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.

[0:35](https://www.youtube.com/watch?v=so9l_MwS2yg&t=35s) So show of hands if anyone is, uh, AI coding with agents lately and feels a little bit like this. And yeah, despite, you know, getting more done than ever before, like, you're completely fried at the end of the day, right?

[0:46](https://www.youtube.com/watch?v=so9l_MwS2yg&t=46s) And, like, adrenaline dumping constantly. So this has been my experience, and, uh, 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, it's worse than ever before, right?

[0:56](https://www.youtube.com/watch?v=so9l_MwS2yg&t=56s) So I think a lot of us are feeling this way, um, like the, the tools are, are, like, insanely powerful, and our skills are more in demand than ever before, and yet we're, like, exhausted by 11:00 a.m.

[1:07](https://www.youtube.com/watch?v=so9l_MwS2yg&t=67s) So I'll, 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

[1:23](https://www.youtube.com/watch?v=so9l_MwS2yg&t=83s) 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, uh, pass right now is mangling some of our acronyms like SCIM and SSO.

[1:37](https://www.youtube.com/watch?v=so9l_MwS2yg&t=97s) So normally I'd be living in that kind of window hell that I just showed you, and, um, instead, this time I made a very minor change that ended up being super impactful.

[1:46](https://www.youtube.com/watch?v=so9l_MwS2yg&t=106s) So I gave Claude Code, which is my current, like, preferred aperture for working, the ability to read and write to Slack as well, and it already had my Linear ticket access.

[1:55](https://www.youtube.com/watch?v=so9l_MwS2yg&t=115s) 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.

[2:04](https://www.youtube.com/watch?v=so9l_MwS2yg&t=124s) 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, it fired it into this blog post channel.

[2:17](https://www.youtube.com/watch?v=so9l_MwS2yg&t=137s) And then the BlogBot that it's working on, you know, it's sitting in that code base on my-- in my working directory, picked it up and ran all the way through and got to the step that was relevant.

[2:25](https://www.youtube.com/watch?v=so9l_MwS2yg&t=145s) And then Claude verified the access and, uh, the, the outcome and then said, "Okay, now I have, uh, definitively fixed this bug." So when I came back to it, I came back to, um, a c-completed loop that was-- had been fixed, and I didn't have to tell it, "Hey, this part's still broken."

[2:42](https://www.youtube.com/watch?v=so9l_MwS2yg&t=162s) So that felt incredible and I, and I think that that's, uh, an important part of what we're going to all build into our toolkit, and we already are. Um, but it also scared me because I realized that there's like, there's n- there's nothing-- there's no ceiling to this, right?

[2:56](https://www.youtube.com/watch?v=so9l_MwS2yg&t=176s) 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, is how do I find my own kind of developer d- balance in this, this world, right?

[3:06](https://www.youtube.com/watch?v=so9l_MwS2yg&t=186s) So why not just stack that same, uh, process? Why not use that harness and just fix 150 bugs every day at work? Uh, well, you know, the agents can kinda do that, especially if you give them enough context, if you give them the right, uh, verification criteria, if you give them the tools to verify their own work.

[3:22](https://www.youtube.com/watch?v=so9l_MwS2yg&t=202s) But at the end of the day, like, 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, like, another eight-hour work session and not be completely destroyed.

[3:34](https://www.youtube.com/watch?v=so9l_MwS2yg&t=214s) So what I think I'm finding, and I think a l- a lot of other folks I've been talking to recently are finding, is that, uh, the agents are not the bottleneck now, and I think that's going to increasingly be the case, but we are.

[3:44](https://www.youtube.com/watch?v=so9l_MwS2yg&t=224s) So agents can scale infinitely, especially now that they're made available as of last night via Claude API. Um, you can give them verification criteria and the tools that they need in order to match that criteria, but our attention is still, you know, in meat space, if you will, and it still degrades under load.

[4:00](https://www.youtube.com/watch?v=so9l_MwS2yg&t=240s) It's, it's still the hard constraint, essentially. Uh, 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.

[4:09](https://www.youtube.com/watch?v=so9l_MwS2yg&t=249s) Um, as Simon Willison said recently, like last week, that he fires up four parallel agents and he's wiped out by 11:00 a.m. And so he suggests that all of us finding our own individual, uh, balance and, and sort of our personal limits is now something that we all need to do on our own.

[4:24](https://www.youtube.com/watch?v=so9l_MwS2yg&t=264s) I'm definitely seeing this also on the Applied AI team. So, uh, here's a couple of tips and tricks or things that I've used l- uh, recently and found success with, and so I'll share them.

[4:33](https://www.youtube.com/watch?v=so9l_MwS2yg&t=273s) Some of them I'm sure you've already seen. Um, so we essentially need to bring the human developer into balance with this new way of working because now that we have these like hyper-charged tools, it's faster than ever to burn yourself out, especially if you just scale linearly in terms of your-- what you're taking on and at work

[4:49](https://www.youtube.com/watch?v=so9l_MwS2yg&t=289s) and what you're, you're outputting. And so see, um, the way that I'm sort of breaking it down in my mind is that agents are gonna do better in terms of infinitely scaling, uh, looping infinitely until they have, uh, reached the criteria you've given them.

[5:02](https://www.youtube.com/watch?v=so9l_MwS2yg&t=302s) Um, but we still have judgment, taste, knowing that something is actually solved, knowing that the, the criterion is actually met in, in, uh, in terms of human needs and business needs.

[5:12](https://www.youtube.com/watch?v=so9l_MwS2yg&t=312s) And so this is kind of an early breakdown of the stack that I'm seeing. So the first I'm calling signal layers, for lack of a better word, and I'll, I'll develop that a little bit in a second.

[5:21](https://www.youtube.com/watch?v=so9l_MwS2yg&t=321s) Uh, the second is voice-first flows. I've been doing voice fir-first coding now for about a year and a half, and it's been life-changing. Um, and then remote control, which is becoming more and more recent, um, m- more applicable, and I think we're gonna start seeing it everywhere.

[5:34](https://www.youtube.com/watch?v=so9l_MwS2yg&t=334s) Right now it's sort of a Claude Code specific thing. And then the system improving itself. So, um, 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, um, material in seconds and

[5:52](https://www.youtube.com/watch?v=so9l_MwS2yg&t=352s) 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, uh, what I mean by this.

[5:59](https://www.youtube.com/watch?v=so9l_MwS2yg&t=359s) So calling back to the, the bug that I showed you that I fixed and had Claude do it. Um, my problem is that if I were to go and go comb through Slack myself, uh, it's like 80% guaranteed that I'm gonna get distracted by some other thread.

[6:13](https://www.youtube.com/watch?v=so9l_MwS2yg&t=373s) I'm gonna find something else, or somebody's gonna have a new ask for me, and that's gonna kind of pull me off task. And so instead, I had Claude Code, um, be able to read my Slack and do it on a loop so that it can see are there @ mentions, are there DMs, are there actually, like, high

[6:28](https://www.youtube.com/watch?v=so9l_MwS2yg&t=388s) priority asks that need to be actioned? Meanwhile, it's al-al-always had access to my Linear via MCP, and so it can deduplicate asks and find the real tickets. And 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

[6:45](https://www.youtube.com/watch?v=so9l_MwS2yg&t=405s) to be able to do as the human developer. Uh, and I think that there's a ton of tools that are coming out that we're all seeing here too that are gonna make this kind of like, um, just a bespoke experience wherever you wanna work.

[6:56](https://www.youtube.com/watch?v=so9l_MwS2yg&t=416s) Um, but it's sort of about managing the now extra insane levels of traffic and pinging and, and noise that we're all gonna deal with. The second is just voice-first flows, like another, um, just nudge if you haven't tried this yet.

[7:07](https://www.youtube.com/watch?v=so9l_MwS2yg&t=427s) Uh, highly recommend it. I'm a person that loved to type. I've grown up typing since I was [REDACTED:age]. I think at my best I was hitting 90 words per minute in a weird non-standard way with my, uh, giant sausage fingers.

[7:18](https://www.youtube.com/watch?v=so9l_MwS2yg&t=438s) But now with, uh, voice-first tools, um, it's significantly faster. I regularly hit, like, 184 words per minute on a, on a given day. And what that enables is not just speaking into one thing quickly and, and having it done, you know, faster.

[7:34](https://www.youtube.com/watch?v=so9l_MwS2yg&t=454s) It enables kind of parallel workflows, right? So imagine if 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.

[7:53](https://www.youtube.com/watch?v=so9l_MwS2yg&t=473s) Um, and I think that if you consider, you know, that, that small things grow quickly, right, in, in terms of software, what d- how does this compound over the course of a year or two, three years of working?

[8:03](https://www.youtube.com/watch?v=so9l_MwS2yg&t=483s) Um, and this has been really key for me because, uh, as I get more and more comfortable with voice flows, it also enables what I'm gonna show next, which is spending less and less time at your actual desk while still getting work done.

[8:15](https://www.youtube.com/watch?v=so9l_MwS2yg&t=495s) The next is remote control. Right now this is kind of, um, a Claude Code specific thing, but I expect that's going to rapidly change. So before we go look at exactly what that means in the Claude ecosystem, um, we'll just talk-- touch on the shower principle.

[8:27](https://www.youtube.com/watch?v=so9l_MwS2yg&t=507s) 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.

[8:37](https://www.youtube.com/watch?v=so9l_MwS2yg&t=517s) You likely have a very clear bru-blueprint in your mind of what you're trying to build and how you wanna do it. And that focus is excellent for getting something over the line and building something exactly the way you want.

[8:47](https://www.youtube.com/watch?v=so9l_MwS2yg&t=527s) But it's, um, also ideal for having blind spots and missing what you need, uh, creative solutions to things and, and increasing your inhibitions. Um, but paradoxically, when you get up and walk away and you start playing with your dog or, or walking your kids to the park or taking a shower, you, uh, it's like there's a flash

[9:03](https://www.youtube.com/watch?v=so9l_MwS2yg&t=543s) of insight and you get the fully formed solution. And the, the thesis, the, the shower principle 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.

[9:21](https://www.youtube.com/watch?v=so9l_MwS2yg&t=561s) And the key thing I wanna stress here is that we've always had this and there's been, you know, hundreds of books written about it and we've all talked about it for decades.

[9:28](https://www.youtube.com/watch?v=so9l_MwS2yg&t=568s) 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.

[9:37](https://www.youtube.com/watch?v=so9l_MwS2yg&t=577s) So what remote control means in the-- Let's just take the Claude Code ecosystem example. If I'm starting a Claude Code session and I pass the remote control flag or I run remote control or I have in my config enable rem-remote control, then I can start at my desk.

[9:49](https://www.youtube.com/watch?v=so9l_MwS2yg&t=589s) It's running on my dev machine. It has access to, you know, the file system, et cetera. But then as soon as I, uh, pull up Claude on my phone on a different network, CDMA, off the Wi-Fi from my house, like, you know, miles away in the trail, I can still see that session and I can still talk

[10:04](https://www.youtube.com/watch?v=so9l_MwS2yg&t=604s) 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.

[10:12](https://www.youtube.com/watch?v=so9l_MwS2yg&t=612s) And so what this enables now is, uh, and what I'm gonna propose that enables is, um, starting your day in focus mode, getting everything loaded up that you need to do that's super important, and then, uh, getting your agents churning, making sure work is proceeding the way that you want, and then leaving the desk, reducing your RSI

[10:31](https://www.youtube.com/watch?v=so9l_MwS2yg&t=631s) and the n-number of, like, 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

[10:46](https://www.youtube.com/watch?v=so9l_MwS2yg&t=646s) in the woods. Um, so I'm, I'm not just blowing sunshine. Like it's, it's possible. Um, and the really nice thing about it is that when you talk to that session through your phone, uh, that s- the session on Claude Code is still running on your machine, still has access to do whatever it needs.

[11:02](https://www.youtube.com/watch?v=so9l_MwS2yg&t=662s) If you have some genius idea of, like, this is the design that's gonna nail it, then you just fire that back. You don't have to remember to do it when you get back to your desk.

[11:09](https://www.youtube.com/watch?v=so9l_MwS2yg&t=669s) You're gonna come back to it having already been applied. So of course, in order to do this, I, I often say that speed requires safety. And so there's levels of doing this and having verification and, and now with new tools coming online, like not only Chrome use, but also computer use for agents, um, this is going to

[11:26](https://www.youtube.com/watch?v=so9l_MwS2yg&t=686s) get more sophisticated. Uh, the gate one is like the minimal lint and build and unit test, right? Let the agents with hooks, um, every single time verify their own work at the code level to make sure nothing's broken.

[11:38](https://www.youtube.com/watch?v=so9l_MwS2yg&t=698s) You know, gate two is when you tell, uh, the Claude Code that you must verify your own work with the browser, click through it, and sh-ensure that you haven't broken login, for example.

[11:47](https://www.youtube.com/watch?v=so9l_MwS2yg&t=707s) Um, three is closer to, like, constitutional AI in the, in the way that, um, 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.

[12:03](https://www.youtube.com/watch?v=so9l_MwS2yg&t=723s) Um, and so taking all this together, how does this actually change a working software developer's day? Uh, so like I said before, I propose like, uh, a deep focus session in the beginning of the day.

[12:13](https://www.youtube.com/watch?v=so9l_MwS2yg&t=733s) You might go through all the backlog tasks in GitHub, the software development life cycle chores that you need to q- queue up, fire those all into Codex, start working on the features you really care about in, um, in an IDE perhaps, or in Claude Code.

[12:25](https://www.youtube.com/watch?v=so9l_MwS2yg&t=745s) And then essentially you walk away, uh, after getting them kinda going on their, the work tracks that you've identified for that day because you have access to them on your phone.

[12:34](https://www.youtube.com/watch?v=so9l_MwS2yg&t=754s) So even when you're out wandering around on, on the EDGE or on LTE, you can, uh, fire messages back to them, and you can start reviewing the PRs as they come through on your phone.

[12:44](https://www.youtube.com/watch?v=so9l_MwS2yg&t=764s) And now a- again, because agents are, 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 [REDACTED:username] or @, you know, Cursor Agent or [REDACTED:username] and say, "This needs to change."

[12:59](https://www.youtube.com/watch?v=so9l_MwS2yg&t=779s) And most of the time it's gonna get it right. Um, and so this kind of enables this complete loop where you're actually spending less and less time away from your desk, uh, uh, less and less time at your desk.

[13:09](https://www.youtube.com/watch?v=so9l_MwS2yg&t=789s) You're spending less and less time injuring yourself, your wrists, your hands, um, 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.

[13:22](https://www.youtube.com/watch?v=so9l_MwS2yg&t=802s) So, um, I'll just quickly show that a, a key learning that I've found in, in doing this kind of as an experiment is that, uh, if you just use the tools on your own, like in the beginning of, of the week, um, Monday feels amazing.

[13:35](https://www.youtube.com/watch?v=so9l_MwS2yg&t=815s) I can rip through a ton of work. Tuesday feels the same. Now I got a bunch of random asks in the middle of the week that kind of threw me off course, and, and then by Friday I'm completely wasted, and I don't remember what the hell I did.

[13:45](https://www.youtube.com/watch?v=so9l_MwS2yg&t=825s) And, uh, I know that work shipped, but it's all disorganized. Uh, as my, uh, illustrious colleague who's with us here, Nick, reminded me, all of Claude Code's conversations are saved locally in JSONL files.

[13:57](https://www.youtube.com/watch?v=so9l_MwS2yg&t=837s) And what that enables you to do, um, 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

[14:14](https://www.youtube.com/watch?v=so9l_MwS2yg&t=854s) 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.

[14:24](https://www.youtube.com/watch?v=so9l_MwS2yg&t=864s) 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.

[14:40](https://www.youtube.com/watch?v=so9l_MwS2yg&t=880s) Um, there is a built-in skill in Claude 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.

[14:51](https://www.youtube.com/watch?v=so9l_MwS2yg&t=891s) Um, so highly recommend doing that, and then tightening that loop so that you can s- still get your work done, still deliver what you need to at work, but spend less and less time at your desk.

[14:59](https://www.youtube.com/watch?v=so9l_MwS2yg&t=899s) And so what that starts to look like is you're working, you're still paying attention through your main preferred aperture, whatever it is, maybe it's Zed, maybe it's Cursor, maybe it's Claude 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.

[15:15](https://www.youtube.com/watch?v=so9l_MwS2yg&t=915s) So 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, I can do this way more efficiently, way more quickly in a way more, um, reliable manner.

[15:30](https://www.youtube.com/watch?v=so9l_MwS2yg&t=930s) Uh, last thing I'll just share for, um, for giggles. Uh, I love, um, my Oura Ring, and one of the first things I did was connect it via MCP.

[15:38](https://www.youtube.com/watch?v=so9l_MwS2yg&t=938s) There's a, a couple of GitHub projects that enable you to do that, and then I gave it to Claude. And so, uh, when I'm arguing with Claude about a project, there, there are times he will literally come back and say, uh, "You didn't sleep last night, and so we're gonna tackle the first part of this, and we're

[15:51](https://www.youtube.com/watch?v=so9l_MwS2yg&t=951s) not gonna do the rest of it, and you're gonna do it tomorrow." And I tell him, "The hell with you. You're a machine. Do what I want," and I just do it anyway.

[15:57](https://www.youtube.com/watch?v=so9l_MwS2yg&t=957s) But at least I thought about taking a break. Um, and so, uh, this, this is kind of a fun thing too, but I, I do think there is something to this as well, uh, where you start to actually look at your work holistically, not, not just in terms of the conversations you're having with which colleagues, um, your

[16:13](https://www.youtube.com/watch?v=so9l_MwS2yg&t=973s) 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?

[16:21](https://www.youtube.com/watch?v=so9l_MwS2yg&t=981s) Um, and I think this is super important because if we just kinda do this mindlessly, the default path is going to be burnout, but now burnout turbo, like super fast and easier than ever, uh, enabled by LLMs, right?

[16:34](https://www.youtube.com/watch?v=so9l_MwS2yg&t=994s) Um, whereas the intentional path is a little bit more like, how do I preserve myself, still do my best work, and direct, uh, agents to do the minutia for me while I'm still responsible for the quality and the review and, and actually shipping?

[16:47](https://www.youtube.com/watch?v=so9l_MwS2yg&t=1007s) Um, so, uh, if you find any of this interesting, I would recommend try, uh, building one signal layer. It can be as simple, uh, as just plugging in Slack or Linear or whatever you find to be the highest, um, cost context switch for you into your preferred pane of glass that you're working with.

[17:03](https://www.youtube.com/watch?v=so9l_MwS2yg&t=1023s) Add some verification gates you don't have. For Chrome-- for, for, uh, uh, Claude Code, it's as simple as passing --chrome now and giving it access to its own browser.

[17:12](https://www.youtube.com/watch?v=so9l_MwS2yg&t=1032s) And then with the margin that you get back, use that to go to eat a picnic in the park alone, right? Or go on a walk, or, you know, play with your dog or whatever the case may be.

[17:21](https://www.youtube.com/watch?v=so9l_MwS2yg&t=1041s) So yeah, the tool, the tools are nuclear now. Um, our nervous systems are still ancient. And so what I'm thinking about these days is trying to find some developer balance.

[17:28](https://www.youtube.com/watch?v=so9l_MwS2yg&t=1048s) Hope that was helpful. [audience clapping] Thank you so much. Any questions? Yes.

[17:36](https://www.youtube.com/watch?v=so9l_MwS2yg&t=1056s) Yeah. So I guess I'm somewhat early in my career-

[17:40](https://www.youtube.com/watch?v=so9l_MwS2yg&t=1060s) Uh-huh

[17:40](https://www.youtube.com/watch?v=so9l_MwS2yg&t=1060s) ... and that means skill development is also very important.

[17:43](https://www.youtube.com/watch?v=so9l_MwS2yg&t=1063s) Yep.

[17:43](https://www.youtube.com/watch?v=so9l_MwS2yg&t=1063s) And, um, also doing deep work and-- or at least, like, you know, I learned to program by doing a lot of deep work, getting into, running into issues-

[17:52](https://www.youtube.com/watch?v=so9l_MwS2yg&t=1072s) Yep

[17:52](https://www.youtube.com/watch?v=so9l_MwS2yg&t=1072s) ... and, um, and big-- overcoming those hurdles.

[17:56](https://www.youtube.com/watch?v=so9l_MwS2yg&t=1076s) Totally.

[17:57](https://www.youtube.com/watch?v=so9l_MwS2yg&t=1077s) Um, it sort of-- And, and I'm also super on board with this new flow of working, but it sort of almost felt like I-

[18:07](https://www.youtube.com/watch?v=so9l_MwS2yg&t=1087s) It's been a skill deficit and, like, it's ma-made it harder to learn. So have you found a balance for that where, uh, yet you can still push forward in, I don't know, skill, but, um, while getting the benefits of this approach?

[18:21](https://www.youtube.com/watch?v=so9l_MwS2yg&t=1101s) Yeah, excellent question. So to repeat in case it's not recorded, um, the question is basically, if I'm early in my career, uh, this is all like skill advancement, but then how do I actually do the hard skill development?

[18:31](https://www.youtube.com/watch?v=so9l_MwS2yg&t=1111s) And it's-- my fear is almost that this could kind of take it away from me, right? 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.

[18:44](https://www.youtube.com/watch?v=so9l_MwS2yg&t=1124s) Um, so I'm shipping like TypeScript systems and RAG systems and, and doing AWS deployments because I used to do that the hard way for many, many years. And so like I have that [REDACTED:physical_attribute], um, those [REDACTED:physical_attribute] and like [REDACTED:physical_attribute] of doing it, and I can immediately catch Claude, for example, and, um, and say like, "No,

[19:03](https://www.youtube.com/watch?v=so9l_MwS2yg&t=1143s) that's insane. We're not doing that," um, 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.

[19:11](https://www.youtube.com/watch?v=so9l_MwS2yg&t=1151s) 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 s- even say like, "Test me.

[19:18](https://www.youtube.com/watch?v=so9l_MwS2yg&t=1158s) Where do I-- where am I missing this?" And like, my mental model here is still murky. So highly recommend doing that. Like build some of those skills, still code some stuff by hand, figure out what's painful about it.

[19:27](https://www.youtube.com/watch?v=so9l_MwS2yg&t=1167s) But then once you start to develop those skills and you have confidence in them, then it's okay to ki- if you've shipped a ton of Ruby apps, it might be okay to start shipping Ruby apps faster with LLMs and Claude.

[19:38](https://www.youtube.com/watch?v=so9l_MwS2yg&t=1178s) Um-

[19:38](https://www.youtube.com/watch?v=so9l_MwS2yg&t=1178s) Yeah. So like only delegate code you're qualified to review or what is-

[19:41](https://www.youtube.com/watch?v=so9l_MwS2yg&t=1181s) I, I would. If I w- if my focus is kind of like skilling up and making sure that I'm on a solid foundation, yeah, I would recommend that. Um, and I would also say don't get discouraged because in the past when I was coming up and learning, like I didn't know the names of the things that I

[19:54](https://www.youtube.com/watch?v=so9l_MwS2yg&t=1194s) 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 with yourself about, "I don't know this," you can go faster, and I st- I still think there's a super bright future for that.

[20:05](https://www.youtube.com/watch?v=so9l_MwS2yg&t=1205s) So yeah. Great question.

[20:07](https://www.youtube.com/watch?v=so9l_MwS2yg&t=1207s) Thanks.

[20:07](https://www.youtube.com/watch?v=so9l_MwS2yg&t=1207s) Yep.

[20:08](https://www.youtube.com/watch?v=so9l_MwS2yg&t=1208s) Yeah. So you talked about getting Claude to look at your own chat history with all those JSONL files. Uh, I, I've tried stuff like that, and like a problem I found is that, like, those JSONL files are not really meant for AI consumption.

[20:19](https://www.youtube.com/watch?v=so9l_MwS2yg&t=1219s) They get really long. There's a lot of junk in there. Do you just point Claude straight at it, or do you have some kind of intermediary step where there's something that parses that into a more amenable format?

[20:29](https://www.youtube.com/watch?v=so9l_MwS2yg&t=1229s) Yeah, that's a great question. I mean, I have just pointed it at it before. Uh, the question is, how do you ha-handle Claude going back and reviewing, doing aggregate kind of analysis on JSONL files if they're super gross and not meant for AI consumption?

[20:40](https://www.youtube.com/watch?v=so9l_MwS2yg&t=1240s) Um, I have had success just pointing it at it, but the other thing you can do is use hooks so that at the end of every coding session, you can 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

[20:52](https://www.youtube.com/watch?v=so9l_MwS2yg&t=1252s) separate, uh, 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, your analysis at the end of the week on that.

[21:02](https://www.youtube.com/watch?v=so9l_MwS2yg&t=1262s) And are you using AI or just something deterministic?

[21:04](https://www.youtube.com/watch?v=so9l_MwS2yg&t=1264s) Uh, well, it would be, it would be used, like for example, I would do it with Claude hooks, and so it would be like 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 trigger.

[21:14](https://www.youtube.com/watch?v=so9l_MwS2yg&t=1274s) Yeah, but how do you determine which are the bits to save?

[21:16](https://www.youtube.com/watch?v=so9l_MwS2yg&t=1276s) Uh, you could just tell it in the prompt, basically. You could say like, "Look specifically for things that-

[21:21](https://www.youtube.com/watch?v=so9l_MwS2yg&t=1281s) It would be an AI prompt?

[21:22](https://www.youtube.com/watch?v=so9l_MwS2yg&t=1282s) Yeah, yeah. It would be an AI prompt to say like, "You're specifically look, on the hunt for things that, uh, we could make more efficient in the future," or, or indications of struggle and churn.

[21:30](https://www.youtube.com/watch?v=so9l_MwS2yg&t=1290s) Yep.

[21:31](https://www.youtube.com/watch?v=so9l_MwS2yg&t=1291s) Do you also make, uh, make use of nighttime, like a, like a night shift for your, for your agent?

[21:35](https://www.youtube.com/watch?v=so9l_MwS2yg&t=1295s) I do. I have ex-- uh, the question is, do you make use of night shift for agent? I've been experimenting with OpenClaw. Um, so I do that with, uh, cron jobs, and I have like some, uh, uh, doing some content for me.

[21:45](https://www.youtube.com/watch?v=so9l_MwS2yg&t=1305s) Um, then I wake up in the morning, kind of review it and freak out and scream at it, and then eventually merge like a, a small percentage of them.

[21:51](https://www.youtube.com/watch?v=so9l_MwS2yg&t=1311s) Um, I'd like to get to the point where with like better systems and verification that's like churning through. I think the thing I'm gonna end up s-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

[22:08](https://www.youtube.com/watch?v=so9l_MwS2yg&t=1328s) literally going every fifteen minutes, all day long and all night long, churning through personal and, uh, earmuffs, company work too.

[22:16](https://www.youtube.com/watch?v=so9l_MwS2yg&t=1336s) Hi. Um, do you let your agents, um, speak back to you, or do you read it? If it's very verbose, what do you do? Because obviously reading is faster than, than speaking.

[22:27](https://www.youtube.com/watch?v=so9l_MwS2yg&t=1347s) Yeah, great question. Uh, the question is, do you let your agents speak back to you in terms of voice, um, in terms of speed and everything? I actually do all of that.

[22:34](https://www.youtube.com/watch?v=so9l_MwS2yg&t=1354s) I, I have-- if I'm working most of the time with Claude Code, I'm speaking to it, and then it's writing back to me, and I'm reading it. Um, but I s- do a lot of work just in like OpenAI's advanced voice mode.

[22:44](https://www.youtube.com/watch?v=so9l_MwS2yg&t=1364s) That's one of my favorite things about that, ChatGPT, and it's one of the only reasons I would use ChatGPT over Claude. And I'll go for a walk for two hours, and I'll like 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

[22:58](https://www.youtube.com/watch?v=so9l_MwS2yg&t=1378s) or architecture that I can paste."

[23:00](https://www.youtube.com/watch?v=so9l_MwS2yg&t=1380s) That's stuck at four point one, right? That's GPT-4.1.

[23:03](https://www.youtube.com/watch?v=so9l_MwS2yg&t=1383s) Uh, I think it's-- I, I can talk to-- But even that is quite, you know, intelligent enough to have like a-- I've had,

[23:09](https://www.youtube.com/watch?v=so9l_MwS2yg&t=1389s) you know, conversations of arguable quality with it before. Um, but I, uh, there's also the voice space is moving so quickly that even last night I found one that, like, there's an open source Ghost Pepper that's basically Wispr Flow.

[23:21](https://www.youtube.com/watch?v=so9l_MwS2yg&t=1401s) It's local only and doesn't use an API. I think there's like a tremendous amount of ability. I, I have OpenClaw on Twilio, so at night I can ask for the call and 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."

[23:33](https://www.youtube.com/watch?v=so9l_MwS2yg&t=1413s) Um, yeah, I find, I find general voice is super efficient. Yeah.

[23:37](https://www.youtube.com/watch?v=so9l_MwS2yg&t=1417s) Thank you.

[23:38](https://www.youtube.com/watch?v=so9l_MwS2yg&t=1418s) Yep. Yes, sir.

[23:39](https://www.youtube.com/watch?v=so9l_MwS2yg&t=1419s) Uh, do you do every kind of work with that? So I, 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, you know, do many things in parallel.

[23:50](https://www.youtube.com/watch?v=so9l_MwS2yg&t=1430s) But then when I have a more chunky feature, you know, something that needs to touch the back end, database, front end, that changes like the way the application work or refactor, it, it feels like it grinds all of that to a halt, and I'm not able to parallelize anymore-

[24:02](https://www.youtube.com/watch?v=so9l_MwS2yg&t=1442s) Yeah

[24:02](https://www.youtube.com/watch?v=so9l_MwS2yg&t=1442s) ... 'cause I need my focus. Are, are you able to work on that sort of like more chunky task yourself?

[24:06](https://www.youtube.com/watch?v=so9l_MwS2yg&t=1446s) Yeah, I think, uh, I think that's a great question. I think everyone's struggling with that. The question is, th- you know, these flows work really, really well for discrete bite-sized tasks, and I, I agree with that.

[24:13](https://www.youtube.com/watch?v=so9l_MwS2yg&t=1453s) And then how do you do bigger, chunkier ones that are like, it's gonna touch the entire stack? It's gonna, you know, an entire new feature for like a distributed cloud system.

[24:21](https://www.youtube.com/watch?v=so9l_MwS2yg&t=1461s) Um, where my mind goes for that is, is Git worktrees first of all, so the agents can run in truly in parallel without stepping on each other's work, and then agent teams, um, with really clearly defined prompts.

[24:31](https://www.youtube.com/watch?v=so9l_MwS2yg&t=1471s) And then again, that makes the verification gates and the unit tests, um, even more important. And then kind of, you know, continuous integration, getting to the point where I'm constantly testing the application.

[24:41](https://www.youtube.com/watch?v=so9l_MwS2yg&t=1481s) They're constantly building against a spec. I'm flowing back my insults and rage and, you know, into the system, and then it's like fixing it as we go. Um, I think that's gonna keep evolving though, and I, I imagine that as models get better, there's gonna be more and more complete harnesses to make that more reliable.

[24:58](https://www.youtube.com/watch?v=so9l_MwS2yg&t=1498s) Yeah. That's a great question. All right. Thank you so much. [outro music]
