Automating Routine: What You Can Already Hand Off to AI

It's March 31, 2026. You woke up, opened your laptop, and spent 30 minutes reading someone else's code changes. Then 20 minutes writing tests you'll never look at again. Then 15 minutes composing an email that says "per my previous message" in four different polite ways. Then another hour wrestling a spreadsheet into submission.

You've done nothing that matters, and it's already lunch. 😼

Here's the uncomfortable math: you're burning 50+ hours a month on tasks that an AI can handle for roughly 65 cents. Not with some vaporware tool launching next quarter — with commands you can type into a terminal right now. This guide gives you the exact scripts, costs, and caveats. Copy, paste, reclaim your calendar.

Category 1: Code tasks

Code review

The old way: You read every PR — a pull request, meaning someone's proposed code changes — checking for style, bugs, security holes, and missed edge cases. That's 15–60 minutes per PR, and your eyes glaze over by the third one.

The new way:

claude "Review the diff in the last commit. Check for:
  1. Security vulnerabilities
  2. Performance issues
  3. Missing error handling
  4. Logic bugs
  5. Style inconsistencies
Report findings with severity (critical/warning/info)."

Or wire it into CI — continuous integration, the system that automatically tests your code whenever you push changes. Here's a GitHub Actions workflow that reviews every PR automatically:

name: AI Code Review
on: [pull_request]
jobs:
  review:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
        with:
          fetch-depth: 0
      - name: Review with Claude
        run: |
          DIFF=$(git diff origin/main...HEAD)
          jq -n --arg diff "$DIFF" '{
            "model": "claude-haiku-4.5",
            "max_tokens": 2000,
            "messages": [{
              "role": "user",
              "content": ("Review this code diff for bugs, security issues, and style problems. Be concise.\n\n" + $diff)
            }]
          }' | curl -s -X POST https://api.anthropic.com/v1/messages \
            -H "x-api-key: ${{ secrets.ANTHROPIC_API_KEY }}" \
            -H "anthropic-version: 2023-06-01" \
            -H "content-type: application/json" \
            -d @- > review.json

Cost: ~$0.002 per review with Claude Haiku. That's $0.06/month at one PR per day.

Reality check: Catches about 70% of what a human reviewer finds. It misses business logic understanding and architectural taste. But it nails the boring stuff — null checks, race conditions, security patterns — precisely because it doesn't get bored. 😸

Test generation

The old way: You write tests manually, or more honestly, you skip them because it's tedious. 30–60 minutes per module when you do bother.

The new way:

claude "Read src/auth/ and write comprehensive tests for the login flow.
Cover: happy path, wrong password, account locked, rate limiting,
SQL injection in email field, missing fields.
Use pytest. Mock the database. Output to tests/test_auth.py."

Cost: ~$0.01 per module with Sonnet. Generated tests are verbose but thorough — they test edge cases you'd skip because "who enters a 10,000-character email?" Someone will.

Refactoring

The old way: Renaming a function across 30 files. Migrating from one ORM — object-relational mapper, the layer between your code and database — to another. Hours to days.

The new way:

claude "Refactor the codebase to replace all direct SQL queries with
Supabase client calls. ~15 files using raw SQL.
For each file:
1. Replace the SQL query with the equivalent Supabase call
2. Update the imports
3. Update error handling to match Supabase patterns
4. Run the tests to verify"

Cost: $0.10–0.50 for a large refactor. Claude Code reads all the files, understands the patterns, and applies changes consistently. Still review the diff before committing — always. 😾

Category 2: Content and communication

Email drafting

The old way: Stare at blank screen. Write. Rewrite. Rewrite again. 10–30 minutes per important email.

The new way: A tiny Python script using the Anthropic API — the programming interface that lets your code talk to Claude:

import anthropic

client = anthropic.Anthropic()

def draft_email(context: str, tone: str = "professional") -> str:
    response = client.messages.create(
        model="claude-haiku-4.5",
        max_tokens=1000,
        messages=[{
            "role": "user",
            "content": f"""Draft an email based on this context:
{context}

Tone: {tone}
Rules:
- Get to the point in the first sentence
- No filler phrases ("I hope this email finds you well")
- Under 150 words
- Clear call to action at the end"""
        }]
    )
    return response.content[0].text

python email_drafter.py "Declining a meeting invite from VP of Marketing
about Q3 planning because I have a conflicting deadline. Suggest async
alternative. Tone: friendly but firm."

Cost: ~$0.001 per email. Essentially free.

Documentation

The old way: Nobody writes docs. The README says "TODO." It's been saying "TODO" since 2024.

The new way:

claude "Read every file in src/. Generate:
1. A README.md with project overview, setup instructions, and architecture
2. Inline docstrings for every public function missing one
3. An API.md documenting every endpoint in src/routes/

Be accurate — read the code, don't guess."

Cost: $0.05–0.20 depending on codebase size. AI-generated docs are wordy but accurate. They describe what the code does correctly. They won't explain why the code exists — that's your job. But "accurate and verbose" beats "nonexistent" every single day.

Changelog and release notes

git log --oneline v1.2.0..HEAD | claude "Convert these commits
into user-facing release notes. Group by: New Features, Bug Fixes,
Improvements. Ignore internal refactoring. Write for end users,
not developers."

Cost: ~$0.001. This one shouldn't even require thinking about.

Category 3: Data processing

CSV cleanup

The old way: Open Excel. Fix formatting. Remove duplicates. Standardize dates. 30 minutes to 2 hours of soul-crushing tedium.

The new way:

import anthropic

client = anthropic.Anthropic()

def clean_csv(filepath: str, instructions: str) -> str:
    with open(filepath) as f:
        data = f.read()
    response = client.messages.create(
        model="claude-haiku-4.5",
        max_tokens=4096,
        messages=[{
            "role": "user",
            "content": f"""Clean this CSV data:
{instructions}

Data:
{data[:3000]}

Return the cleaned CSV. Maintain the header row."""
        }]
    )
    return response.content[0].text

python clean_csv.py contacts.csv "Standardize phone numbers to +1-XXX-XXX-XXXX.
Remove duplicate emails (keep the row with more data).
Fix obvious city name typos. Convert dates to YYYY-MM-DD."

Cost: ~$0.005 per file.

Weekly reports

The old way: Query the database, export to spreadsheet, make charts, write commentary. 2–4 hours every week.

The new way:

import anthropic, subprocess
from datetime import datetime

client = anthropic.Anthropic()

data = subprocess.run(
    ["psql", "-c", "SELECT * FROM weekly_metrics", "--csv"],
    capture_output=True, text=True
).stdout

response = client.messages.create(
    model="claude-sonnet-4-6",
    max_tokens=2000,
    messages=[{
        "role": "user",
        "content": f"""Generate a weekly business report from this data:
{data}

Include:
- Executive summary (3 sentences)
- Key metrics with week-over-week changes
- Notable trends or anomalies
- Recommended actions

Format as markdown."""
    }]
)

with open(f"reports/weekly-{datetime.now():%Y-%m-%d}.md", "w") as f:
    f.write(response.content[0].text)

Schedule it with cron — a built-in tool that runs scripts on a timer:

# crontab -e
0 9 * * MON python3 /path/to/weekly_report.py

Cost: $0.02 per report. $0.08/month for a weekly cadence. 😸

Category 4: System administration

Log analysis

The old way: grep -r "ERROR" /var/log/ then stare at 200 lines of stack traces pretending you understand the pattern. 30+ minutes.

The new way:

tail -200 /var/log/app/error.log | claude "Analyze these error logs.
Group by error type. Identify the root cause of the most frequent error.
Suggest a fix with code if possible."

Cost: ~$0.003 per analysis.

Monitoring scripts

claude "Write a bash script that:
1. Checks if nginx is running, restarts if not
2. Checks disk usage, alerts if > 80%
3. Checks SSL cert expiry, alerts if < 14 days
4. Checks main API endpoint responds with 200
5. Sends alerts to a Telegram bot
6. Runs every 5 minutes via cron

Use curl for HTTP checks. Use openssl for cert checks.
Include the cron line at the top as a comment."

Working monitoring script in 30 seconds. Review it, test it, deploy it. Cost: ~$0.003, one-time, for a script you'll run for months.

Category 5: Research and decisions

Technology evaluation

The old way: 20 browser tabs, three comparison articles from 2023, a Reddit thread that devolves into an argument about Rust. 2–4 hours per decision.

The new way:

claude "I need a message queue for a Python backend.
Requirements: ~10K messages/day, dead letter queue,
works with Supabase, team of 1.

Compare: Redis Streams, RabbitMQ, SQS, Supabase Queues.
For each: pricing at my scale, setup complexity,
Python SDK quality, gotchas. Give me a recommendation."

Cost: ~$0.005 with Sonnet. Better comparison than 2 hours of tab-switching.

Caveat: Always verify pricing numbers independently. AI can be outdated on specific costs. The analysis framework is solid; the dollar amounts need a spot-check. 😾

The damage report

Task	Manual time	AI time	AI cost/mo	Hours saved/mo
Code review (1/day)	30 min	2 min	$0.06	9.3
Test generation (2/week)	45 min	5 min	$0.08	5.3
Email drafting (3/day)	15 min	1 min	$0.09	14.0
Documentation	4 hours	15 min	$0.20	3.75
Changelog (2/month)	30 min	2 min	$0.002	0.9
CSV cleanup (2/week)	30 min	3 min	$0.04	3.6
Weekly report	2 hours	5 min	$0.08	7.7
Log analysis (daily)	15 min	2 min	$0.09	6.5
Total			~$0.65	~51 hours

Sixty-five cents. Fifty-one hours. Six working days back every month. Not a typo.

What NOT to automate (yet)

Some things AI still does poorly as of March 2026:

• Anything requiring real empathy — customer apology emails, firing conversations, sensitive HR matters. AI can draft; a human must review and send.
• Strategic decisions — AI can analyze data and present options, but "should we pivot?" stays with you.
• Legal documents — AI can draft, but never ship legal text without a lawyer's eyes on it.
• Creative brand work — AI generates options, but brand voice and creative direction need human taste.
• Security-critical code — AI can write it, but security-critical paths need a human who understands the threat model.

The pattern: AI handles the 80% that's repetitive and structured. The 20% requiring judgment, empathy, or accountability stays yours. Automate the 80%, focus your energy on the 20% that actually matters.

Now do something about it

Remember that morning from the opening? The one where you burned half your day on busywork? That morning is optional. 😹

The biggest obstacle isn't technical — every script above works today. It's psychological. "I should do this myself" feels responsible. But spending an hour formatting a CSV isn't responsible — it's avoidant. You're hiding in busywork instead of doing the hard things only you can do: talking to customers, making product decisions, closing deals.

Pick one automation from this guide. Just one. Set it up this week. Feel how it changes your day. Then automate the next thing. By month's end, you'll wonder why you ever did any of it by hand — and you'll have 51 hours of proof that you were right to stop. 😼