Nestor G Pestelos Jr · Writing · Print

The Employee You Can't Stop Managing

Published August 21, 2026

TL;DR

Treating AI agents like employees shifts software from static tools into collaborative relationships. But without strict systems discipline, ephemeral boundaries, and hard concurrency caps, it turns the solo builder into an exhausted middle manager.

The New Hire Fantasy

The most compelling reframe of generative AI treats personal software as an employee rather than an application. The mental model shifts how builders invest:

The metaphor is intuitive because onboarding an agent feels like training a junior engineer. But treating agents as employees imports a hidden organizational structure. When you hire an employee, you take on management overhead. When you deploy a dozen AI employees, you take on all of it at once.

The Maker-to-Manager Trap

The friction starts when the volume of agent output collides with the limits of human attention:

The solo developer who set out to build products wakes up as an on-call manager for a fleet of tireless, error-prone reports.

Stateful Employees vs. Ephemeral Workers

The root failure lies in conflating persistent identity with task execution.

Elvis Sun argues that naming agents limits how far you can scale. He keeps one named orchestrator and lets unnamed subagents spawn for a job and die when the job ends.

Most engineering tasks need an ephemeral subroutine, not a named employee:

DimensionEphemeral SubagentStateful "Employee" Agent
LifecycleShort-lived; spawns on demand, terminates on returnLong-lived; persistent session across tasks
Context ManagementStateless; context injected per task by orchestratorAccumulates history, prompt cache, and memory banks
Failure ModeIsolated failure; destroyed on errorState drift, conversational hallucination
Best Used ForLinting, test execution, file editing, scrapingHigh-context domains, customer relationship logs
Managerial DragNear-zero on closed-loop tasks; returns a diff or return codeHigh; requires ongoing supervision and prompt pruning

Management drag also depends on task determinism. In closed-loop environments with objective evaluation metrics (unit test suites, static analysis, and CI pipelines), self-healing agent harnesses evaluate outputs with automated test runners and trigger repairs without human triage. The managerial burden concentrates in open-ended, subjective, and architectural workflows where correctness cannot be verified by an automated test.

The Guardrails of Attention

You do not need dedicated hardware or custom agent frameworks to start today. If you operate multiple agents, your own attention is the ultimate scarce resource. Dropping a larger frontier model into an ambiguous workspace still produces more articulate mistakes.

Ahmad Osman converts agent guessing into deterministic execution with modularity, domain-driven design, painfully explicit specs, and excessive documentation. Without docs that answer where, what, how, and why, agents guess, and guessing degrades codebases.

Brian Casel stores work, content, and audience feedback as markdown files in a shared Dropbox folder both he and his agents can read and write.

  1. The zero-infrastructure on-ramp: Replace conversational chat sessions with single-file specifications. Create a simple TASK.md or AGENTS.md file defining inputs, constraints, and success criteria before spawning a coding agent. Give the agent a single, bounded objective and let it run to completion.
  2. The decommissioning protocol: Every agent deployment needs an explicit exit trigger. If an agent requires repeated manual interventions on the same workflow, do not keep coaching it in chat. Decommission the agent session, capture the failure mode as a written specification or lint rule, and rebuild the task as an ephemeral script.
  3. Strict concurrency limits: Never run more parallel agent workflows than you can review in a single sitting. Capping active runs (for instance, maximum two parallel pipelines) prevents unreviewed output from piling up.
  4. Batch review windows: Do not poll agent runs in real time. Launch background jobs, let them finish asynchronously, and review completed diffs in focused batches.
  5. Separation of concerns: An agent's operational task list must remain strictly separate from human promises and obligations.

The "agent as employee" model is a useful metaphor for investing in tooling, infrastructure, and onboarding. Treated as an operating philosophy, it recreates the corporate hierarchy that solo developers built their workflows to avoid. Before you hire a fleet of digital employees, build the factory floor: plain text, explicit specifications, ephemeral subagents, and a concurrency cap. Durable leverage comes from deterministic systems that need little supervision.

Sources

Back to top