Claude Code Routines hit 347 points on HN — here's why developers are rate-limited within minutes

Yesterday, Anthropic's official docs on Claude Code Routines hit the top of Hacker News with 347 points and 218 comments.

For those who missed it: Routines let you define repeatable multi-step workflows in Claude Code. Think: audit my codebase, review this PR, refactor this module — all as named, chainable commands.

It's genuinely brilliant. And it immediately makes the rate limit problem much worse.

---

What Routines Do

A routine is a .claude/routines/ YAML file that chains multiple Claude Code steps:

# .claude/routines/pr-review.yml
name: pr-review
description: "Full PR review workflow"
steps:
  - run: git diff main --stat
  - prompt: Summarize the changes in this PR
  - prompt: Identify any security issues or edge cases
  - prompt: Write a constructive review comment
  - run: echo "Review complete"

Then you run it:

claude routine pr-review

Instead of typing 4 separate prompts manually, one command handles the whole workflow.

---

Why This Is Amazing

Routines solve the biggest friction in Claude Code: repetition.

Every time you open a PR, you ask Claude the same questions:

• What changed?
• Any security issues?
• What should I add to the review?

With routines, that's one command. The muscle memory is built once.

Other useful routines:

# .claude/routines/deploy-check.yml
name: deploy-check
steps:
  - run: npm test
  - prompt: Review test results and identify any failures that block deployment
  - run: npm run build
  - prompt: Check the build output for warnings or errors
  - prompt: Give me a go/no-go recommendation for deploying

# .claude/routines/onboard-codebase.yml  
name: onboard-codebase
steps:
  - run: find . -name '*.md' | head -20
  - prompt: Summarize the project structure and main entry points
  - run: cat package.json
  - prompt: What does this project do and how does it fit together?
  - prompt: What are the top 3 things I should understand before touching this codebase?

---

The Rate Limit Math

Here's the problem Routines quietly introduce:

Before Routines:

• You type one prompt
• Claude responds
• You think about it
• Maybe you type another prompt
• Natural pacing = natural rate limiting

After Routines:

• One command fires 4-6 prompts in sequence
• Each step waits for the previous response
• Claude is working continuously for 5-10 minutes
• Token usage per session: 3-5x higher than manual prompting

If you run 3-4 routines in a morning session, you'll hit Claude Pro's usage limits before lunch.

The HN thread had dozens of comments from developers who hit this immediately:

"I ran my onboarding routine on a new codebase and hit the limit halfway through step 3."

"These are incredible but I burned through my daily quota in 90 minutes."

---

The Practical Solution

For developers who want to use Routines seriously, there are two paths:

Option 1: Claude Pro Max ($100/month) — Higher limits, still hits them with heavy routine use.

Option 2: API-direct access — No usage caps on a per-token billing model. You pay for what you use, no artificial throttling.

I use SimplyLouie's developer API for exactly this reason. $10/month gives you Claude API access without the usage throttling that makes Routines impractical for real workday use.

The curl API call is simple:

curl -X POST https://simplylouie.com/api/chat \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "message": "Review this PR diff and identify security issues",
    "context": "$(git diff main)"
  }'

You can wire this directly into your routine scripts:

#!/bin/bash
# pr-review.sh — runs like a Routine but via API (no rate limits)

DIFF=$(git diff main)

STEP1=$(curl -s -X POST https://simplylouie.com/api/chat \
  -H "Authorization: Bearer $LOUIE_API_KEY" \
  -H "Content-Type: application/json" \
  -d "{\"message\": \"Summarize this diff: $DIFF\"}" | jq -r .response)

echo "Summary: $STEP1"

STEP2=$(curl -s -X POST https://simplylouie.com/api/chat \
  -H "Authorization: Bearer $LOUIE_API_KEY" \
  -H "Content-Type: application/json" \
  -d "{\"message\": \"Security issues in this diff: $DIFF\"}" | jq -r .response)

echo "Security: $STEP2"

---

Getting the Most From Routines

Routine design principles that minimize token waste:

1. Front-load the shell commands

steps:
  - run: git diff main --stat  # free, no tokens
  - run: npm test              # free, no tokens  
  - prompt: Based on the above, should I merge this PR?

2. Chain context explicitly

steps:
  - prompt: List the 3 files most likely to have bugs
  - prompt: For each file you listed, show me the riskiest function

3. Keep routines focused
A 10-step routine = 10x the token cost. Break big routines into smaller named ones you call deliberately.

---

My Routine Setup

Here's what I actually use daily:

.claude/routines/
├── morning.yml      # git status + TODOs + priority setting
├── pr-review.yml    # diff + security + review comment
├── debug.yml        # error context + hypothesis + fix suggestions
├── refactor.yml     # code smell detection + refactor plan
└── deploy-check.yml # tests + build + go/no-go

Each one is 3-4 steps maximum. Short enough to stay within limits during interactive use, meaningful enough to save real time.

---

Routines are the best thing Anthropic has shipped for Claude Code workflow in months. If you're hitting rate limits, the issue isn't the Routines — it's the billing tier.

For heavy Routine users, the developer API tier at $10/month is the practical path to making these workflows actually sustainable.

---

What routines are you building? Drop them in the comments — I'm genuinely curious what workflows people are automating first.