← Back to Blog

Reality Check: API vs Coding Plan LLMs — When Code Isn't Enough

I asked two different LLMs to "build a Python API to scrape Twitter and store results in Postgres." One returned code. The other returned a plan. The difference in outcomes was stark.

The Setup

I prompted each model with the same task, same constraints, same data format. The API LLM was told: "Generate the complete working code." The Coding Plan LLM was told: "Outline the architecture and implementation steps."

API Output (Code-First)

from fastapi import FastAPI, HTTPException
import tweepy
import asyncpg
import os

app = FastAPI()

@app.get("/tweets/{user}")
async def get_tweets(user: str, count: int = 100):
    # ... 47 lines of code ...
    return {"tweets": tweets}

The reality: The code compiled. It ran. It hit rate limits on day one. No retry logic, no error handling for network failures, no pagination for >100 tweets, no environment variable validation, no tests, no deployment instructions. It worked in a sandbox. It failed in production.

Coding Plan Output (Plan-First)

1. Authentication Layer — Create auth.py with OAuth2.0 handling for Twitter API v2. Use python-dotenv for env vars.
2. Database Abstraction — Use asyncpg with connection pooling. Create models.py with SQLAlchemy schema.
3. Scraper Service — Implement in scraper.py with exponential backoff, rate-limit awareness, and pagination.
4. API Endpoints — FastAPI routes with proper error handling, request validation, and response models.
5. Testing — Pytest fixtures with mocked Twitter responses, integration tests against test DB.
6. Deployment — Dockerfile, docker-compose.yml, CI/CD pipeline skeleton.

The reality: No code shipped. But the plan exposed every dependency, every failure mode, every operational concern. When I asked for code, it was accurate, complete, and production-ready.

The Trade-offs

The Hybrid Reality

The best developers use both. Here's the workflow I landed on:

1. Plan first — Get the architecture, dependencies, and failure modes on the page
2. Code second — Generate code, but with the plan as a checklist
3. Test third — Write tests for every edge case the plan identified
4. Deploy fourth — Containerize with the deployment instructions

Bottom Line

The question isn't "which is better?" — it's "what's the cost of being wrong?"

• Prototype at 2am? API-first is fine.
• Production system with customers? Plan-first saves weeks of debugging.
• Team of 5 engineers? Plan-first scales better.
• Freelancer billing hourly? API-first gets you paid faster.

Reality check: The LLMs gave me what I asked for. I needed to ask for what I actually needed.

---

Which workflow works for your team? Have you seen API outputs that actually ship to production? Drop your stories below.