Most operators still generate reports by hand. I don't.

Anthropic's engineers now ship 8x more code per quarter than they did 18 months ago. Over 80% of their production codebase is Claude-authored as of May 2026. [1] Most operators I talk to still frame AI coding as a 10–20% productivity boost. That framing is a year out of date.

This is a playbook post. One client scenario, the exact setup I built, and the cost math that made it a no-brainer. If you're still generating weekly ops reports by hand, read this one.

The number that changed how I scope this work

In March 2024, Claude could complete software tasks that took roughly 4 minutes. By March 2025, 90 minutes. By March 2026, 12-hour tasks. Task duration doubles every 4 months. [1] That's not a linear improvement — it's a compounding one that changes which problems are worth automating.

For client work, this matters in an unexpected place: operators have dozens of 2–8 hour weekly processes that nobody automates because they look too boring to justify an engagement. Report generation, data reconciliation, weekly summaries. "Building it" always felt like a weekend project that never happened.

That window is now measured in days, not weekends.

Source: Anthropic — Progress on Recursive Self-Improvement

The client scenario — an 8-hour weekly report nobody wanted to write

Services SMB. Three data systems: a Google Sheet (sales pipeline), Asana (project status), Stripe (billing). Every Monday, the ops person pulled data from all three, reconciled it in a Notion doc, and forwarded a summary to the founders before the 9 AM stand-up.

Eight hours. Every week. Delayed whenever two people had edited the spreadsheet. Wrong quarterly total twice in three months. The ops person described it as "the report I hate building but can't skip."

At $35/hour, that's roughly $14,500/year in ops person time spent on data plumbing. It wasn't in anyone's budget line because it was invisible — just "part of the job."

Here's where that time actually went and what the automation replaced:

| Task | Manual time/week | Automated time/week | |---|---|---| | Pull data from 3 systems | 2.5 hours | under 1 minute | | Reconcile and validate | 2 hours | 3 minutes (flagging script) | | Format and write report | 2.5 hours | under 5 minutes (template render) | | Review and publish | 1 hour | 15 minutes (human gate) | | Total | 8 hours | ~20 minutes |

What I actually built with Claude Code

Step 1: Document the existing process. I spent 90 minutes with the ops person, Claude Code open in another tab, working through their Monday ritual. Not a general description — the exact Google Sheet name, the exact columns, the exact Asana project filters they ran, the exact Stripe report they exported. Claude Code drafted a structured spec as we talked.

This took more time than anyone expected. It's also the hardest part.

Step 2: API extraction scripts. Once the spec existed, I handed it to Claude Code with the three API docs. It wrote:

• A Google Sheets reader (Sheets API v4, specific tab, specific column ranges)
• An Asana project status reader (filtering by completion rate and assignee)
• A Stripe MRR and invoice summary reader (current period, previous period delta)

Total token spend across two Claude Code sessions: roughly 40,000 tokens. Under $3.

Step 3: Report generation script. Claude Code wrote a Jinja2 template that renders the three data payloads into a structured Notion page. The founders asked for: ARR delta, pipeline velocity, on-track/off-track project count, top 3 client alerts. The template is now the source of truth for what the report looks like.

Step 4: Scheduling via n8n. A two-node n8n workflow: cron trigger at 6:00 AM Monday → HTTP request to the report script on a $5/month VPS. Slack notification to the ops person: "Draft ready, needs your review."

That's the whole system. Two working days to build. The client's ops person spent about three hours total on documentation and testing.

flowchart TD
  Cron["n8n: cron trigger<br/>Monday 6:00 AM"] --> Extract["Data extraction<br/>Sheets + Asana + Stripe APIs"]
  Extract --> Validate{"Validation checks<br/>completeness + anomaly"}
  Validate -->|pass| Render["Report render<br/>Jinja2 template to Notion page"]
  Validate -->|flag| Alert["Slack to ops:<br/>data anomaly, review needed"]
  Alert -.->|ops corrects source| Extract
  Render --> Notify["Slack to ops:<br/>draft ready for review"]
  Notify --> HumanReview{"Ops person<br/>reviews report"}
  HumanReview -->|approve| Publish["Publish to<br/>founders Notion workspace"]
  HumanReview -->|reject| Fix["Ops corrects<br/>source data, re-run"]
  Fix -.-> Extract

The cost math — where this actually pays

Monthly token cost for Monday runs plus occasional re-runs from validation flags: $18–22/month.

Annual ops person time: down from 400+ hours to under 30. They still review, approve, and investigate anomalies — that's the job now.

Net: roughly $240/year in token costs versus $13,500 in recovered ops time at the $35/hour rate.

This came out of a larger fractional engagement, so the build time was bundled. But even billed standalone at $150/hour for two days — $2,400 — the payback against annual time savings is under 3 months.

The framing I use on every call: this isn't replacing a $30/month SaaS tool. It's replacing a slice of a $60,000-a-year employee. Anchor the token cost against headcount, not against Zapier. The math changes completely. (The same anchor that closes n8n conversations.)

Industry-wide context: per-developer token consumption rose 18.6x over nine months in 2025–2026. [2] One company racked up a $500M Claude bill after neglecting usage limits. An engineer at a separate firm spent $40K on tokens in a single month. The operators who didn't track spend had a bad year. This system runs at $240/year because the scope is defined and the pipeline is fixed — not open-ended.

An ops report that takes 8 hours to build isn't a reporting problem. It's a documentation problem dressed up as a bandwidth problem.

The rule I don't break: agents flag, they don't publish

The first version published directly to the founders' shared Notion workspace. I pulled that back in the first week.

The script had an off-by-one in the week boundary logic. The Monday January 2nd report showed December numbers with no visible label difference. Two founders spent 40 minutes on a Zoom call trying to reconcile numbers that were fine — just labeled wrong.

Now there's a human gate: ops person sees the draft, spends 10–15 minutes verifying, clicks approve. Only then does it publish to the founders' workspace. This costs 10 minutes every Monday instead of zero. It's worth every second.

Agents should escalate by default, not ship by default. This is the same rule I apply to the support triage agent I reference in the eval-suite post. Draft-and-flag, not draft-and-send. The value isn't in removing humans from the loop — it's in removing the tedious 7 hours and 45 minutes so the human can spend 15 minutes on judgment instead of plumbing.

What you need before you can automate

Documentation comes first. Not "we do it roughly this way" — but the exact query, exact column header, exact output format. If the ops person can't describe the process as a precise sequence, Claude Code can't automate it reliably. It'll approximate, and approximations in financial reporting lose trust with founders fast.

The spec document from Step 1 is now the source of truth for that client process. When reporting requirements change — and they always do eventually — the ops person updates the spec, I update the template. Everything else stays the same.

The model can't fix an undocumented process. It can turn a documented process into code faster than you thought possible. Those are different things.

This is why I now include a documentation session in every automation scope. Usually 30–60 minutes. The client always underestimates how useful that document is outside the automation context: it's onboarding documentation, it's auditable process records, it's what survives personnel changes.

Where this applies for you

Any 4–8 hour weekly process that involves pulling data from 2+ sources into a fixed format, with a person who knows the process but can't hand it off, and a recurring deadline creating predictable Monday-morning pressure — that's the shape. The specific tool stack barely matters.

If you want to find out whether a specific process fits, book 15 minutes. I turn down more of these than I take — if the ops docs aren't there, the automation isn't ready. But when they are, or can be built in a session, the math usually works.

Sources

[1] Anthropic — Progress on Recursive Self-Improvement — https://www.anthropic.com/institute/recursive-self-improvement

[2] TechCrunch — The token bill comes due: inside the industry scramble to manage AI's runaway costs — https://techcrunch.com/2026/06/05/the-token-bill-comes-due-inside-the-industry-scramble-to-manage-ais-runaway-costs/

The short version

• Anthropic's engineers ship 8x more code per quarter with Claude writing over 80% of their codebase. That same multiplier is available for client ops work with the right setup.
• Pick one 4–8 hour manual process, document it precisely, then have Claude Code write the automation. The bottleneck is documentation, not the model.
• Token cost for a weekly automated report: $18–22/month. Annual ops time replaced: 370+ hours. Payback on a standalone build: under 3 months.
• Human review gates are non-negotiable. Agents draft, humans approve. The 10-minute review is cheaper than one wrong report in a founders' meeting.
• Per-developer token consumption rose 18.6x in nine months industry-wide. If you're not scoping AI automation to a fixed task, you're not controlling the cost.