Geoffrey Litt argues AI coding agents struggle with UI because specification and implementation tasks constantly blur

@jamescham I have tried many of these structures. In my domain, the main problem is mostly that they can't see and understand highly interactive interfaces well enough to reliably validate their work. When the models can't fully close their own loops, a lot of these strategies don't work.

@andy_matuschak After spending a few months trying to keep as many parallel agents going as possible concurrently, I’ve now settled on a chief-of-staff style delegation pattern, where I spend 95% of my time working with one agent, who I use to scope jobs-as-context-packets for subagents

@andy_matuschak both happy camps keep attention single-homed: in (a) you are the one thread, in (b) one other thing fully owns you while agents run offstage. the middle asks you to half-watch several loops at once, and partial attention split across threads isnt weaker focus, its no focus

@andy_matuschak @jamescham i also am very skeptical of claims for long running agents; the best loop is two agents debating each other and i am the final judge with relatively short bursts. anything more long ranging breaks down unless its a trivial problem

@andy_matuschak I’m here too. I experimented quite a bit with Cursors agent interface but found it unsatisfying because of this I think. I have found the closest middle ground to be highlighting a large chunk of code (e.g. a function and delegate to agent) while I think through next steps

"teams of agents making technical plans, reviewing each others' work, autonomously and adversarially testing, etc. You still get robust "technical oversight"—just by other agents."

i think this doesn't work either. i'm somewhere in the middle ground too, and the primary reason is that i think it makes me feel connected to the codebase and understand the nuances and design decisions that went into it. agents reviewing the plans, etc doesn't really solve this for me

@andy_matuschak you would love what @humanlayer_dev do.

What delegated slow loops have you found highly satisfactory experiences from? For me it’s either just

1. Translating a very clear spec, or from one language to another. Essentially some task with low room for variance. 2. Optimization tasks like auto research

Just about nothing else yet

@andy_matuschak That’s a good point. We don’t have great tools to validate highly interactive interfaces (yet). I know that @sschillace was exploring a few but might have decided we weren’t quite ready.

@andy_matuschak I often find myself jumping back and forth between a and b – multiple controlled fast loops for the planning/understanding phase + a longer running loop for the actual implementation.

@focusmoapp (unattributed AI-generated replies pollute the commons 👎)

@andy_matuschak How are 1-2 minute cycles with tight human intervention any form of agentic looping?

Loops are meant to be largely unattended.

@andy_matuschak So I’m either capturing a task and scoping out tickets to send off to sub agents who will work independently, reviewing the output of those agents with the chief of staff, or occasionally deep diving into a task where I don’t trust the subagents to be able to do a good enough job

@andy_matuschak This is hilarious but invites borderline AI-psychosis😅

I have family that can code + business-lead. They're my modulised-experts performing your camps strategy - or else i'd be falling in the same trap

Human-gating is core + AI is referential to humans. That system always wins

@andy_matuschak Middle ground is hard because partial control creates mental drag. Either you stay in tight loops and own it, or you fully delegate and free your mind.

@andy_matuschak 1000% agree that the middle place is a nightmare. context switching like that sucks, it’s so hard to keep track of things and find flow esp between multiple projects