●2.1.301 — Adds the vim % motion, LaTeX math rendering in the VS Code panel, and a retry-watchdog limit for usage-limit waits (10/15)●2.1.299 — Conversations over 200K tokens left idle about 54 minutes get compacted; MCP allow rules now match only the server they name●SONNET 4.5 — Retires on the Claude API on 11/30, 44 days left. Migrate to Sonnet 5.5●WINDOWS — Reports say hooks break silently only on Japanese-locale Windows; check the character encoding first●FAST MODE — Opus 5.5 fast mode is out of research preview and no longer needs the beta header (10/15)●NEW — I Put a Ten-Line Promise File at the To…●2.1.301 — Adds the vim % motion, LaTeX math rendering in the VS Code panel, and a retry-watchdog limit for usage-limit waits (10/15)●2.1.299 — Conversations over 200K tokens left idle about 54 minutes get compacted; MCP allow rules now match only the server they name●SONNET 4.5 — Retires on the Claude API on 11/30, 44 days left. Migrate to Sonnet 5.5●WINDOWS — Reports say hooks break silently only on Japanese-locale Windows; check the character encoding first●FAST MODE — Opus 5.5 fast mode is out of research preview and no longer needs the beta header (10/15)●NEW — I Put a Ten-Line Promise File at the To…
Where the human still has to press the button — lessons from delegating ad ops to Cowork
From actually delegating repetitive ad operations — AdMob bidding-partner sign-ups and floor tuning — to Cowork, here is the boundary I found between what AI can fully own and the single moves a human still has to make by hand.
Repetitive work like ad operations is exactly what you want to hand to AI. But once you actually delegate it to Cowork, you notice that the moves you have to make with your own hand — "past this point, I cannot let it auto-run" — exist more clearly than you expected. Recently I applied to 11 AdMob server-side bidding partners at once, and in parallel reviewed the floors (eCPM thresholds) across 42 mediation groups, working through it with Cowork. The boundary that emerged between "delegate" and "press yourself" turned out to be a design principle for delegating any operation to AI.
I have built apps solo since 2014 — about 50 million cumulative downloads, AdMob revenue peaking above one million yen a month. The reason I can run an ad business of this scale alone, alongside my art practice, is that I hand a large share of the repetitive operations to AI. But not "all of it." If anything, explicitly deciding each time what to delegate and what to press myself was the core of delegating without accidents.
What can be fully delegated — most of the sign-up flow completes with AI
First, the impression: the delegatable range is wider than you would think. Enabling each partner from the AdMob console under "Mediation → Bidding → Set up ad source" splits into two flow types.
One is doc-type: pressing "Steps to sign the partnership agreement" opens a Google help page, step 1 auto-completes, and you return to AdMob and press step 2, "Review and agree," to enable it. Improve Digital and Mobfox were this type, and I could hand it entirely to Cowork without issue.
The other is form-type: you go to the partner's external site to fill a form, agree to terms, and submit. Chocolate Platform, Nativo, Verve, Sharethrough, and Yieldmo fall here. The form fields even carry over a publisher ID like pub-0667784050147760 from Google automatically, so Cowork can read the page structure and proceed through entry and submission. Verve reached full activation this way.
What matters here is that when you ask Cowork to operate the screen, you do not bounce it back to the human with "I opened a tab, you take it from here." You have it fill the form inputs and click the button in one continuous run, via JavaScript. Open a tab and ask for manual work, and you end up with a half-finished automation that steals your own time. Once you decide to delegate, run it through to where no human touchpoint remains. That is the basic posture of delegation.
The move to press yourself #1 — the reCAPTCHA v2 checkbox
The flagship un-delegatable move is reCAPTCHA. And the awkward part is that whether it passes automatically or requires a human depends on the kind of reCAPTCHA.
Sites using reCAPTCHA v3 (the invisible kind), like Verve, are only scored behind the scenes at submit time, so Cowork's submit action passes them automatically. But sites that present reCAPTCHA v2 (the checkbox kind), like Sharethrough, require by design a human to tick "I'm not a robot" — and that one step cannot be automated.
Not knowing this boundary, you end up chasing logs over "why won't it submit." Before I started applying, I had Cowork determine for each partner whether the form used v2 or v3, and built the split from the outset: I press the checkbox by hand only on the v2 sites. Identifying the un-delegatable move in advance keeps the whole operation's tempo from breaking.
✦
Thank you for reading this far.
Continue Reading
What follows includes implementation code, benchmarks, and practical content we hope you'll find useful. This site runs without ads — server and development costs are supported entirely by members like you. If it's been helpful, we'd be truly grateful for your support.
WHAT YOU'LL LEARN
✦A concrete boundary in AdMob operations: what Cowork can own, and what a human must press (reCAPTCHA v2, floor writes, seller IDs)
✦Why a 'human enters → AI reads back the actual value to verify' split is more reliable than auto-entry, and how to implement it
✦How to design evidence-based verification — which matters more the more you hand operations to AI — in real ad-ops
Secure payment via Stripe · Cancel anytime
✦
Unlock This Article
Get full access to the rest of this article. Buy once, read anytime. This site is ad-free — your support goes directly toward keeping it running.
The other thing to press yourself is the final entry of the floor value. The reason differs from reCAPTCHA — it is a reliability problem with automated operation.
AdMob's mediation group edit screen changes the button IDs of the floor input field every time, and is built in a way that makes it easy to "misfire" — typing the value into the wrong field. I once actually entered a value into the group-name field by mistake, and since then I treat auto-entry of this part as forbidden.
What I do instead is a split where the human enters and the AI reads back the actual value to verify. In the monthly floor review, Cowork pulls the actual eCPM and match rate for all 42 groups from the report and, following the rules (on iOS, floor = actual eCPM × 55%; lower it if the ratio exceeds 65%, raise it if the ratio is under 40% and match rate is over 95%), computes the new floor for each group. AI up to the calculation. The human types the value into the edit screen. After that, Cowork re-reads the edit screen and verifies "does the entered actual value match the proposed value." This round trip lets me keep the misfire risk of auto-entry at zero while delegating just the judgment and the verification to AI.
# The verification side of "human enters → AI reads back the actual value"# Cowork re-reads the floor edit page and reconciles proposed vs actualGROUP_ID="7930061941" # e.g. BW-INT-AND-USPROPOSED="0.50" # floor proposed by the AIACTUAL=$(fetch_floor_from_admob "$GROUP_ID") # read the actual value from the edit pageif [ "$ACTUAL" != "$PROPOSED" ]; then echo "⚠️ mismatch: group=$GROUP_ID proposed=$PROPOSED actual=$ACTUAL → ask for re-entry"else echo "✅ group=$GROUP_ID floor confirmed at $ACTUAL"fi
The point is not "do not let the AI enter values," but shifting the AI's role toward 'propose' and 'verify' and leaving only the irreversible write to the human. The human writes; the AI confirms its correctness. That turns "fast but accident-prone automation" into "fast and accident-free operation."
The move to press yourself #3 — judging not to "fill in" an unconfirmed value
The third is slightly different in nature: the boundary of not letting the AI fill in what it does not know.
Server-side bidding partners are designed to hand you their own seller ID (the authorized-seller line) after approval. Before approval, the seller ID is not confirmed. If you have the AI build out app-ads.txt at this stage, the temptation arises to fill in a guessed seller ID when only the domain is known.
app-ads.txt declares "who is authorized to sell my inventory on this domain," so a fabricated ID can, in the worst case, leave that line's demand unauthorized and invalid. So I explicitly include in my instruction to Cowork: "Do not append to app-ads.txt until you receive each partner's specified line in the approval email. Do not fabricate seller IDs." Precisely because AI tends to dislike blanks and try to fill something in, you need to give "do not fill until confirmed" as a human-side rule.
The "evidence-based" verification design that matters more the more you delegate
What the three moves above share is a posture: never trust the AI's output as-is; always back it up against the real thing. This jumps in importance the more of the operation you hand to Cowork.
The trap that bit hardest this time was "partnership enabled ≠ eligible to serve." Even when AdMob shows "partnership active," that only means the account contract is done — it does not guarantee serving. In fact, partners like BidMachine and LY Ads are mixed in: they can be "enabled" in AdMob, yet require integrating an adapter SDK. Swallow the AI's status report of "it's enabled, so it must be serving," and you lose the ability to explain why impressions never rise.
So set the completion condition of an operations task not at "it got enabled" but at "real impressions appeared in the report." When you delegate operations to AI, I strongly recommend that the human define these evidence-based completion conditions up front. "It's done" as reported and "it's actually working" are different things, and the only thing that bridges the gap is a verification step.
A design principle for delegating operations to AI in solo development
To close, here are the principles distilled from this work.
Separate the work to delegate from the work to press, explicitly, before you start. Concretely, keep three things on the human side: human-required actions like a reCAPTCHA v2, irreversible writes (floor entry), and the handling of unconfirmed values (seller IDs). Let the AI handle "propose," "operate the screen," and "verify," and have it read writes back to confirm their correctness. And always make the completion condition of an operations task something you can judge from real data.
I make my artwork entirely by hand, with no AI at all — but I pour AI fully into the operations that bring that work to the world, and into the ad operations of my app business. The reason I can draw the line of the creative core by hand, the repetitive operations to AI is, I think, that I can identify the "move the human must press" even within operations. Widening what you delegate to AI and clearly holding the moves you will not delegate are not in conflict; they coexist.
Start by writing out, within your own operations flow, one each of three kinds of move: "this is irreversible," "this is unconfirmed," and "this needs a human's authentication." Just handing everything else to Cowork makes the operation astonishingly lighter.
Share
Thank You for Reading
Claude Lab is ad-free, supported entirely by members like you. We publish practical guides daily with implementation code, benchmarks, and production-ready patterns. If you've found it useful, we'd love to have you on board.