Idea #1
We are stuck in a structurally worst-of-both-worlds moment with AI agents — call it the 'awkward in-between' — and understanding it as a phase (not a permanent condition) changes how you should invest your time right now. Before agents, deep focus work was both practical and the norm: one person, one hard problem, hours of uninterrupted flow. That model is gone, but the replacement isn't here yet. Current LLMs and harnesses are good enough that running them in parallel feels like the only way to maximize output, but not good enough to run unsupervised for a full day — so every session demands constant babysitting and input. The result is a day that looks like dozens of micro-context-switches: start a session, wait, get pinged, provide input, feel guilty about the gap, start another session, repeat. This isn't a personal failure or bad discipline; it is the structural reality of where agent capabilities sit today. The practical implication: strategies suited to the pre-agent era (block four hours, deep focus, one problem) don't fit the current moment, and strategies suited to the future (delegate to fully autonomous agents, check in once a day) don't work yet either. You have to build for where capabilities are actually going, not where they are right now.
Idea #2
Financial controls for AI agents must live on the financial instrument itself, not in prompts or code — because any constraint expressed in text can be reasoned around, ignored, or simply fail to bind when the agent encounters an edge case. Spending limits written into a system prompt are advisory; a card-level limit is physically enforced by the card issuer regardless of what the agent does. The practical implementation: use a virtual card API (the example is Revolut Business) to have the agent open its own card at the moment it needs to make a purchase. That card carries hard constraints — a $50 weekly spend ceiling, locked to a specific merchant category (software), locked to a single country (US), and an end-of-month expiry — all set at card creation time through the API, not in any instruction the agent sees. If the agent tries to spend $60, the card declines; there is no code path or prompt that overrides it. A webhook from the card provider notifies the owning system on every transaction, so charges are visible in real time without requiring active monitoring. This separation of 'what the agent is instructed to do' from 'what the financial system will actually allow' is the security boundary that makes autonomous agent spending tractable. The broader principle applies beyond finance: whenever you need a hard constraint on agent behavior, look for where enforcement can be moved out of the agent's context entirely and into an external system that does not read or reason about your prompts.
Idea #3
The right response to agent-induced context switching is NOT to open more parallel sessions — it is to invest in harness autonomy, even at the cost of near-term output. When you make your harness a little more capable, the temptation is always to use that extra capability to start yet another parallel session rather than to extend the unsupervised run-time of the ones you already have. That temptation compounds the fragmentation problem. The alternative is to periodically step back from direct output work and instead design the harness to plan, implement, and validate autonomously — the full loop — so each session runs longer before needing human input. This is a genuine short-term sacrifice: time spent on harness architecture is not time spent shipping. But the payoff is that each session covers more ground unattended, decisions get batched instead of scattered, and the number of concurrent conversations you must track shrinks. The concrete example is a 'software factory' architecture: the agent does high-level release planning with the human up front, then autonomously splits the work into issues, and a manager agent oversees the implementation loop for an entire day or more. The human reviews the batch output in a staging environment at the end, rather than monitoring every step. The key insight is that harness engineering is the 'training' for the agent — codifying how you work and how you validate means the agent can run independently far longer, because it is operating according to your specific standards rather than generic defaults.
Source: AI Makes Us WAY Faster but Fries Our Focus (Here's What I Do About It) (Cole Medin)
Text summarized and optimized using Anthropic’s models and reviewed by a human.