Hand Claude Code a One-Line Done-When and Let It Run — Inside My Four-Site Article Pipeline

The five-attempt retry cap

Canly's /e2e-dev caps Lambda-side fix retries at five attempts. It is a safety valve — prevents broken code from being deployed repeatedly to dev, and prevents the model from looping forever.

I borrowed the same cap. If article_gate.py reports violations, the article is discarded and regenerated, up to five times. If five attempts all fail, the task exits without pushing and writes a halt report.

# Control flow embedded in the scheduled task prompt
N=0
while [ $N -lt 5 ]; do
  N=$((N+1))
  echo "=== Generate attempt $N/5 ==="
 
  # Ask Claude Code to generate the article
  # (JA/EN pair created inside the prompt)
 
  # Mechanical verification
  if python3 article_gate.py "$JA_PATH" "$EN_PATH"; then
    echo "Gate passed on attempt $N"
    git add content/ && git commit -m "Add: $TITLE (JA+EN)"
    git push origin main
    break
  else
    echo "Gate violations detected, regenerating"
    rm "$JA_PATH" "$EN_PATH"
  fi
done
 
if [ $N -ge 5 ]; then
  echo "5 attempts exhausted, halting without push"
fi

With the cap in place, the "broken article shipped to production" incident count for the last three weeks is zero. In exchange, "four out of five attempts failed and we shipped nothing" happens once or twice a month. That is by design and far healthier than pushing a marginal article through.

Average retries per article come out to about 1.4. Roughly 70% pass on the first try, 23% on the second, and 7% need three or more.

The baseline check buys you better gap analysis

The detail in /e2e-dev I keep coming back to is the baseline step — sending the same utterance to Slack before implementation so the gap is named explicitly before any code is written.

In the Labs pipeline I added an equivalent. Before generating an article, Claude Code is asked to observe three things:

1. The last five article slugs and their character-count distribution in the same category, to avoid duplicate topics and stay near the prevailing length.
2. Recent article_gate.py violation history for the category. If AI-explainer markers keep showing up there, the generation prompt can lean harder on those bans.
3. A whitelist of existing internal-link targets, so Claude Code does not invent slugs that resolve to 404.

The baseline check itself takes about 30 seconds. It pays for itself: average retries drop by about 0.4 per article. Net of overhead, total wall-clock per article is roughly 4 minutes shorter.

Mapping Goal / Context / Constraints / Done-when into the prompt

Codex's /goal best-practice docs say a prompt should contain Goal, Context, Constraints, and Done-when. The pattern works for Claude Code too, and every Lab scheduled task now follows the same skeleton:

# Goal
Produce one JA/EN article for category "{category}" on {topic_hint},
based on a personal experience, and push it to the {site} repo main branch.

# Context
- Existing slugs: $(ls content/articles/ja/{category}/ | sed 's/.mdx$//')
- Recent character-count distribution: $(...)
- Personal experience stock: $WS/.auto-memory/reference_experience_sources_current.md
- Author voice guide: $WS/_documents/AUTHOR_VOICE_STYLE_GUIDE.md
- Personalization spec: $WS/_documents/PERSONALIZATION_MAX_GUIDE.md

# Constraints
- Polite Japanese (-masu form); avoid plain form
- Avoid template intros, template closings, AI-explainer markers (gate enforces)
- Slug must not collide with existing posts
- Internal links must point to real articles
- No naked URLs; use Markdown link syntax
- Premium posts need 3 highlights and 3+ practical-value signals

# Done-when
python3 article_gate.py content/articles/ja/{category}/{slug}.mdx \
                       content/articles/en/{category}/{slug}.mdx
returns exit code 0, and JA and EN MDX counts match site-wide.

# Stop conditions
- 5 generation attempts without passing the gate → exit without push
- git pull --rebase conflicts → retry 3x, otherwise exit
- GitHub PAT rejected → exit immediately

Once all four Lab tasks moved to this skeleton, the "Claude Code wandered off mid-task" symptom basically stopped. Codex /goal's four-element structure is general enough to drop into Claude Code scheduled tasks as-is.

Practical-value signals beat character counts

The hardest call on the premium-quality gate was character-count thresholds. I started with an 8,000-character hard floor and watched what happened: the first 6,000 characters were dense and useful, and the last 2,000 were padding. The model was hitting the number.

So I dropped the floor and switched to signaling "what the reader actually gets." A premium post now needs at least three of these six signal types:

1. Runnable code — at least one fenced block with 5+ lines.
2. Concrete metrics — money like ¥1,200, percentages, or 2.4x-style multipliers.
3. Structured steps — numbered lists or "Step 1, Step 2..." markers, three or more.
4. Real gotchas — words like "error," "trap," "watch out for" twice or more, accompanied by a fix.
5. Concrete recommendations — "I recommend," "personally I would" twice or more.
6. Domain metrics — eCPM, LTV, Day 1 retention, AdMob, Stripe, and so on.

Average premium article length went from 7,200 characters to 5,400. Reader conversion to paid went from 0.8% to 1.4%. Shorter, denser writing converted better, not worse. Counting characters as a quality proxy is actively misleading once a model is in the loop. Signaling what the reader walks away with is what works.

A whitelist guard against phantom internal links

Claude Code invented internal links pointing to articles that did not exist on six separate occasions in the first three weeks. Hard 404s on the live site.

The fix was to constrain link choice to a pre-supplied whitelist:

# Internal-link candidates handed to Claude Code in the scheduled task
RELATED_SLUGS=$(find content/articles/ja -name "*.mdx" | \
  xargs grep -l "tags:.*Claude Code" | \
  head -20 | \
  xargs -I {} sh -c 'F={}; basename ${F%.mdx}; head -3 $F | grep "^title:"')
 
# Embedded in the prompt
cat << PROMPT
If you use an internal link, pick from the list below.
Targets outside this list will 404.
 
$RELATED_SLUGS
PROMPT

On top of that, article_gate.py extracts every text link and checks the corresponding MDX file is present in the git tree. Two layers — generation and verification — keep 404s out.

The side effect: no more micromanaging the AI

The Canly post has a line about not having to babysit the model anymore that I keep nodding at. Before the gate was wired up, I refreshed scheduled-task logs several times a day to make sure nothing had wandered off. With 4 sites × 4 articles per day running unattended, I now glance at logs once in the evening. The time I freed up goes into Crashlytics, AdMob revenue checks, and Stripe payment notifications.

For an indie developer, this is a much bigger lift than it sounds. While the article loop runs itself, I have been picking up the iOS wallpaper app refresh, the Firebase CocoaPods-to-SPM migration, and the AdMob mediation expansion from 4 networks to 7. Time with my kids, who live apart from me, has also clearly increased.

Where this pattern fits and where it does not

The E2E-driven autonomous loop works when the done-when can be decided by a machine. The Dolice Labs case fit because "write one article and push" has clean inputs and outputs and the done-when compresses into a single Python script.

Where it does not fit is anywhere a subjective human judgment is part of the spec. "Reads well," "fits our brand," "feels honest" — those do not collapse into mechanical rules. I still do OGP image selection, image swaps, and timing decisions by hand.

The Canly post closes by noting the final Slack eyeball check stays in the loop. That matches my experience. The pattern works as "machine-decidable done-when + final human eyes." Where AI can decide, let it. Where it cannot, take the work back. Naming that split at the prompt level was the single most impactful change to my operations.

When I draft a new scheduled task now, the first question I ask myself is whether the done-when fits into one line of Python. If it does, it becomes a pipeline. If it does not, I keep doing it by hand. That cut, more than anything else, is what lets one person run four sites and six apps in parallel.