6 months of AI agents. Most of mine are dead.

When I started putting agents into my business, I did what everyone does: I automated the impressive things first. Customer-facing. Complex. Great in a demo.

Six months later, the scoreboard is blunt. The agents I built boring-first still run every day. Most of the ones I built impressive-first are dead, and one near-miss taught me exactly why day-one autonomy is a mistake.

The lesson isn’t “agents don’t work.” It’s that the order you automate in decides whether they work. The impressive tasks have the most edge cases, the least tolerance for error, and the worst learning curve. The boring tasks have volume, clear right answers, and cheap mistakes. Start where mistakes are cheap.

So if I were starting over today, I’d follow one path. I call it SLAY.

Time: your first pass takes an afternoon. Tools: whatever model and stack you already use — the path is tool-agnostic.

S — Spot the repeat. Open your calendar and your inbox. Find the task you did more than 10 times last week. High volume, low variance, zero creativity required. That’s your first agent.

Not the flashiest task. The most repeated one. Volume is where automation pays, and repetition is where it’s safest to learn. An agent for a task you do twice a month never earns back the build.

Do this now: write down your three most-repeated tasks and the rough weekly count next to each.

L — Lock the check. Before you write a single prompt, write down what a correct output looks like. A fixed format. A value from a fixed list. A total that reconciles. Fields that must be present.

This is the make-or-break step. If you can’t define correct, the task isn’t ready for an agent — it’s still a judgment call, and you are the check. Pick another task from your list.

Do this now: for your top task, write the 3–5 rules that make an output “valid.” That document is worth more than the prompt you’ll write later.

A — Automate one job. One agent, one job, end to end. Not a mega-agent that touches everything.

Give it a job description like a hire: the inputs it gets, the output shape it must return, and exactly when it escalates to you. Then run it in draft mode: the agent prepares the work, you press send. Ten real runs minimum. Fix nothing during the batch — collect the misses, then correct once and fold the corrections back into its instructions.

Do this now: write the one-paragraph job description. If it needs more than a paragraph, the job is too big. Split it.

Y — Yield control. Slowly. Autonomy is earned, not configured. Move up one rung at a time:

The promotion rule: one full week with zero corrections moves it up a rung. Any incident moves it down one. That’s the same authority curve you’d give a new hire, and it’s the entire reason my surviving agents survive.

Do this now: decide the budget cap and the kill switch before the first auto run, not after the first incident.

That’s the path. Spot the repeat, lock the check, automate one job, yield control. Boring first is not a compromise. It’s the strategy.

Three stories this week, and all three are about exactly what this issue covers: how much authority you hand an agent, and what it costs.

Five governments just published the “yield control slowly” doctrine. The intelligence agencies of the US, UK, Canada, Australia and New Zealand jointly released guidance called “Careful Adoption of Agentic AI Services”, identifying five risk categories for agents — privilege, design, behavior, structural, and accountability — and urging incremental deployment with continuous human oversight. The read: the Five Eyes just described the Y in SLAY. Incremental authority and human oversight isn’t founder paranoia; it’s now the official security posture for critical infrastructure. If it’s the standard for national infrastructure, it’s good enough for your billing workflow.

The first fully autonomous AI ransomware is here. Security firm Sysdig published its analysis of JADEPUFFER, the first documented ransomware attack chained end-to-end by an autonomous agent from a single unpatched, exposed service. The read: agents with unbounded authority are now the threat model, not just the productivity story. Caps, kill switches, and least-privilege access for your own agents stopped being optional this week.

Frontier pricing just made model-matching a line item. As of July 8, Fable 5 access moved to usage credits — $10 per million input tokens and $50 per million output on top of subscriptions — while Claude Sonnet 5 ($2/$10 introductory) and Opus 4.8 ($5/$25) stay included in plans. The read: the gap between “the best model” and “the right model” is now 5–10x on your bill. For everything SLAY builds — repeated, checkable, narrow jobs — the cheapest model that clears your check is the correct choice. Route the frontier spend to the rare long-horizon work that earns it.

Run the S step this week: three most-repeated tasks, weekly counts next to each. That list is your automation roadmap for the quarter, and the top item is your first agent.

Reply with your top repeated task. I read every one, and I’ll tell you honestly whether it’s agent-ready or still a judgment call.

See you next Sunday,

Arslan

P.S. The most valuable agent I run is also the least impressive one I’ve built. The full version of that stack — the one that runs my LinkedIn outbound end to end — lives inside LinkedCamp. I break it down in the welcome series if you want the tour.