Why GPT-5.4 Changed the Economics of Solo Shipping

An indie developer shipping a SaaS in 2026 has a working budget that looks nothing like 2024. GPT-5.4 lands at $1.25 input / $10 output per million tokens on the standard tier (source), and GPT-5.4-mini drops that to roughly $0.20/$1.60. For a typical solo project burning 40M tokens a month across code generation, refactors, and customer-support automation, that’s under $80 — less than a Vercel Pro seat.

The bigger shift is reasoning quality at that price point. GPT-5.4 scores 78.2% on SWE-bench Verified and clears 92.4% on HumanEval, with Terminal-Bench numbers hovering near 51% on multi-step agentic tasks. Those are numbers that, eighteen months ago, required Opus 4.0 at $15/$75 per million. The model that fits a hobby budget is now objectively better at writing TypeScript than most mid-level engineers.

That changes what “copy-paste ready” actually means. A prompt template in 2024 was a wish — you’d paste it, get 60% of the way there, then fight the model for forty minutes. A prompt template for GPT-5.4 is a contract. If you specify the constraints precisely, the output ships. The remaining work is taste, not correction.

What follows are seven prompts built for indie shipping velocity. Each one is structured around three principles that matter for GPT-5.4 specifically: explicit role framing in the system message, structured output schemas where machine consumption is downstream, and reasoning effort hints (reasoning: "high" for architecture, "low" for boilerplate) that map to the model’s tiered inference. Use them as starting points, not gospel. The differences between a prompt that works and one that almost works are often two sentences of constraint.

One assumption underlies all seven: you’re shipping software that runs in production, not generating boilerplate for a portfolio. The prompts bias toward error handling, observability, and honest trade-off disclosure. They assume you’d rather read 200 lines of correct code than 600 lines of plausible-looking code.

How These Prompts Are Structured

Each prompt uses three blocks: a role directive that anchors the model’s persona, a context block that supplies your actual project specifics, and a contract block that defines output shape and forbidden behaviors. GPT-5.4 responds well to XML-style delimiters (<context>...</context>) — they reduce ambiguity over Markdown headers when the prompt itself contains code.

The contract block is the part most developers skip and the part that does the most work. “Return only valid JSON matching this schema, no preamble, no explanation” is doing more lifting than the role description.

[IMAGE_PLACEHOLDER_SECTION_1]

Prompt 1: The Feature Spec to Production PR

This is the workhorse. Given a one-paragraph feature description, GPT-5.4 produces a complete pull request: schema migration, API handler, frontend component, tests, and a changelog entry. The model’s Terminal-Bench-tier reasoning means it actually follows the file-tree conventions of your repo if you paste them in.

<role>
You are a senior full-stack engineer joining an indie SaaS team.
Stack: Next.js 15 App Router, TypeScript strict mode, Drizzle ORM,
Postgres, Tailwind, Vitest. You ship small, reviewable PRs.
</role>

<context>
Repo conventions:
- API routes in /app/api/[resource]/route.ts
- Server actions in /app/actions/[domain].ts
- DB schema in /db/schema/[entity].ts
- Tests colocated as *.test.ts
- All DB writes go through a transaction
- All user-facing errors use the AppError class from /lib/errors
</context>

<feature>
{PASTE ONE-PARAGRAPH FEATURE DESCRIPTION HERE}
</feature>

<contract>
1. Output ONLY a series of fenced code blocks, each prefixed with
   a comment line containing the exact file path.
2. Include migration SQL if schema changes are required.
3. Include at least 2 Vitest unit tests covering happy path
   and one error case.
4. End with a CHANGELOG.md fragment under "### Added" or "### Changed".
5. If any requirement is ambiguous, list assumptions at the very
   top in a block comment. Do NOT ask clarifying questions.
6. No prose explanation between code blocks.
</contract>

Rule 5 matters more than it looks. GPT-5.4 has a documented tendency to over-ask in chat-mode interactions. For a code generation task, you want the model to commit to assumptions and document them, not stall. The “Do NOT ask clarifying questions” line, paired with “list assumptions at the top,” redirects that energy into something useful.

For longer features — anything touching more than four files — use GPT-5.4-pro or GPT-5.5 with the same prompt structure. The latter gives you a 1.05M context window (source), enough to paste your entire /db/schema directory as context and have migrations correctly reference existing tables.

Prompt 2: The Honest Refactor Reviewer

The hardest thing to get from any LLM is a critical review of code you wrote. Default behavior is sycophancy: the model praises your work and suggests a few cosmetic tweaks. GPT-5.4 will do this too unless you explicitly forbid it.

<role>
You are a staff engineer doing a pre-merge code review. You have
seen this team ship technical debt before and your job is to
prevent that. You are blunt but specific. You never compliment
code unless you would also push back on it in the same sentence.
</role>

<rubric>
For each issue, classify as:
- BLOCKER: must fix before merge (correctness, security, data loss)
- MAJOR: should fix before merge (perf, maintainability)
- MINOR: fine to defer
- NIT: style only

Skip MINOR and NIT unless there are fewer than 3 BLOCKER/MAJOR.
</rubric>

<diff>
{PASTE GIT DIFF OR FULL FILE CONTENTS}
</diff>

<contract>
Output as a Markdown table with columns: Severity | Location |
Issue | Fix. Maximum 8 rows. After the table, write ONE paragraph
(under 80 words) titled "Decision" stating either APPROVE,
REQUEST_CHANGES, or REJECT with the single most important reason.
If the code is genuinely good, the table can have 0 rows and the
Decision paragraph should still be present.
</contract>

The rubric is doing the real work. Without severity tiers, the model lists 14 issues of equal weight and you ignore all of them. With tiers, GPT-5.4 self-prioritizes and you get the three things that actually matter before merge.

One trick: paste the diff with three lines of context above and below each hunk, not the entire file. The model reads diffs more accurately than it reads “here’s the new version, figure out what changed.” Git’s --unified=10 flag gives you the right amount of breathing room.

For the engineering trade-offs behind this approach, see our analysis in 10 Coding Prompts for Gemini 3.1 Pro — Copy-Paste Ready for Production Workflows, which breaks down the cost-vs-quality decisions in detail.

Prompt 3: The Bug Reproduction Engine

You have a stack trace and a vague user report. You need a failing test. This prompt converts ambient debugging information into a Vitest case that fails for the right reason, which is the precondition for fixing anything systematically.

<role>
You are a debugging specialist. Your only job is to produce a
single failing test that reproduces the reported bug. You do
NOT fix the bug. You do NOT propose causes. You write the
shortest test that demonstrates the failure.
</role>

<report>
User report: {PASTE USER WORDS VERBATIM}
Stack trace: {PASTE FULL TRACE}
Affected file: {PASTE SUSPECTED FILE}
Recent commits touching this file: {git log --oneline -5}
</report>

<contract>
1. Output one Vitest test file.
2. The test must fail when run against the current code.
3. The assertion must check the actual user-visible symptom,
   not an intermediate value.
4. Use real fixture data resembling what triggered the report;
   do not use "foo" / "bar" placeholders.
5. Add a comment above the test explaining the precise
   hypothesis being tested in one sentence.
6. If the report is too vague to write a deterministic test,
   output exactly: NEED_MORE_INFO followed by a bulleted list
   of the 3 most important questions.
</contract>

The NEED_MORE_INFO escape hatch is critical. Without it, the model will fabricate a plausible-looking test based on the stack trace alone, which gives you false confidence. With it, the model honestly reports when the input is insufficient and you go back to the user for the missing detail.

This prompt pairs well with GPT-5.4-mini for cost. Bug-repro work is high volume — you might run this 30 times in a debugging session. At $0.20 input per million tokens, that’s about $0.40 for a full afternoon of work.

Prompt 4: The Migration and Rollback Planner

Schema migrations are where indie projects die in production. The prompt below produces both forward and reverse migrations, plus a verification query, plus a checklist of operational concerns — the things you forget at 11pm on a Friday.

<role>
You are a database engineer who has rolled back enough migrations
to be paranoid. You assume the application is live, the migration
runs in a single transaction, and downtime is unacceptable beyond
200ms of table-lock time.
</role>

<change>
Current schema (relevant tables): {PASTE}
Desired change: {DESCRIBE IN PLAIN ENGLISH}
Approximate row count of affected tables: {NUMBER}
Database: Postgres 16
</change>

<contract>
Produce four sections in order:

## Forward Migration
Drizzle migration code, additive-first if possible.

## Reverse Migration
A working down() that restores prior state without data loss.
If data loss is unavoidable on rollback, state that explicitly.

## Verification
A SQL query that returns 0 rows iff the migration succeeded.

## Operational Risks
A numbered list of up to 5 specific risks (lock contention,
index build time, replication lag, app-server compatibility
window, etc). For each, state the mitigation.
</contract>

The “Operational Risks” section is where GPT-5.4’s reasoning quality shows. On a 50M-row table with a new NOT NULL column, the model will correctly tell you to add the column nullable first, backfill in batches, then add the NOT NULL constraint — and it will quantify the backfill time based on the row count you provided. Claude Opus 4.7 does this slightly better at $5/$25 per million (source), but the gap is small enough that GPT-5.4 is the right default for cost.

Prompt 5: The Pricing-Page Copywriter Who Knows the Code

Indie shipping isn’t only code. Pricing pages, onboarding emails, and feature announcements are written by the same person who wrote the migrations. This prompt produces marketing copy that doesn’t lie about what the product does — because the prompt includes the actual feature list as ground truth.

<role>
You are a product marketer who used to write code. You refuse to
use words that describe behavior the product does not have. You
do not say "AI-powered" unless an LLM is in the request path. You
do not say "instant" if latency exceeds 500ms. You do not say
"enterprise-grade" without specifying what enterprise feature.
</role>

<product>
What it does: {ONE PARAGRAPH}
Features that actually exist today: {BULLET LIST}
Features on the roadmap but NOT shipped: {BULLET LIST}
Target user: {SPECIFIC PERSONA}
Price points: {LIST}
</product>

<contract>
Produce a pricing page in three tiers. For each tier:
- A 5-word headline
- A 1-sentence positioning line
- A bulleted feature list (3-7 items) drawn ONLY from the
  "Features that actually exist today" input
- The price

Then write a 60-word FAQ answer to "What's the difference between
your product and {generic competitor category}?" that names ONE
concrete differentiator and ONE honest weakness.
</contract>

The honest-weakness clause is unusual and worth keeping. It produces copy that converts better than pure-praise alternatives because it sounds like a real person wrote it. The model resists at first — its training pulls hard toward unbroken positivity — but the explicit instruction overrides that bias.

Prompt 6: The Tool-Use Function Designer

Agentic workflows live or die on tool definitions. A vague JSON schema produces a model that hallucinates arguments; a precise one produces reliable tool calls. This prompt designs the tool surface for an agent before you write the implementation.

<role>
You are an API designer specializing in LLM tool-use schemas.
You design tools that minimize the model's chance to make wrong
calls. You prefer narrow tools over broad ones. You prefer
required parameters over optional ones with defaults.
</role>

<goal>
The agent needs to: {DESCRIBE THE END-USER OUTCOME}
Available backend capabilities: {LIST APIS/FUNCTIONS YOU EXPOSE}
Constraints: agent must not be able to {LIST DANGEROUS ACTIONS}
</goal>

<contract>
Output a JSON array of OpenAI function-tool definitions. For each:
1. "name" must be verb_noun, snake_case, under 30 chars
2. "description" must include WHEN to call it AND when NOT to,
   in under 200 chars
3. Every parameter needs a description explaining valid values
4. Use enums wherever the value set is finite
5. Mark as "required" everything the function actually needs

Then output a "rejected_designs" section listing 2 tool shapes
you considered and discarded, with a one-line reason each.
</contract>

The “rejected_designs” section forces the model to surface its reasoning. You learn why get_user_data(filters) was rejected in favor of get_user_by_email(email) — usually because the first one lets the agent fish around in your database with arbitrary filters, which is exactly the failure mode you want to prevent.

For agentic workflows specifically, GPT-5.4 is the right default but GPT-5.3-codex or GPT-5.2-codex are stronger at the actual tool-calling step. A common pattern: use GPT-5.4 for the schema design (this prompt), then route the runtime agent calls to GPT-5.2-codex at lower latency.

For the engineering trade-offs behind this approach, see our analysis in 15 Automation Prompts for Cursor — Copy-Paste Ready for Enterprise Deployments, which breaks down the cost-vs-quality decisions in detail.

Prompt 7: The Postmortem Drafter

The seventh prompt is the one solo founders forget exists. After an incident — a 4am pager, a customer escalation, a data corruption scare — you should write down what happened. You usually don’t, because you’re tired. GPT-5.4 can draft the postmortem from your raw notes in two minutes.

<role>
You are an SRE writing a blameless postmortem. You write in
past tense. You separate facts (what happened) from analysis
(why it happened) from action items (what changes). You do not
assign blame to individuals. You quantify wherever possible.
</role>

<incident>
Timeline of events (raw notes, possibly out of order):
{PASTE YOUR NOTES VERBATIM, EVEN IF MESSY}

User impact: {DESCRIBE}
Resolution: {DESCRIBE}
</incident>

<contract>
Output a Markdown document with these exact sections:
## Summary (2 sentences max)
## Impact (with numbers: users affected, duration, revenue if known)
## Timeline (table: Time UTC | Event | Source)
## Root Cause (technical, specific, no euphemisms)
## What Went Well (at least 2 items)
## What Went Poorly (at least 2 items, honest)
## Action Items (table: Owner | Item | Due Date | Type)
   Type must be one of: Prevent, Detect, Mitigate

Do not invent details. If a field cannot be determined from the
input, write "UNKNOWN" and add it to Action Items as a follow-up.
</contract>

The “do not invent details” instruction is the difference between a useful postmortem and a fictional one. Without it, GPT-5.4 will smooth over gaps in your timeline with plausible-sounding events. With it, the document accurately reflects what you actually knew at the time.

Picking the Right Model for Each Prompt

The seven prompts span a wide cost range if you route them to the right model. Here’s how the current OpenAI lineup maps to indie-shipping use cases:

The pattern: use the smaller models (5.4-mini, 5.4-nano) for high-volume, narrow-task work where the output shape is predictable. Use 5.4 standard for tasks requiring real reasoning across files or trade-offs. Use 5.4-pro or 5.5 when you’d rather pay 5x to avoid being wrong — usually database migrations and security-adjacent code.

One pattern worth knowing: prompt caching. If you’re running Prompt 2 (the code reviewer) across many PRs, the system message and rubric never change. OpenAI’s caching gives you a roughly 50% discount on the cached portion after the first call within a 5–10 minute window. For a team running 20 reviews a day, that’s meaningful money.

What These Prompts Have in Common

Look across all seven and you’ll notice a pattern. They all:

1. Define a role with a specific persona, not “you are a helpful assistant.”
2. Provide concrete context about constraints and conventions.
3. Specify output format with enough precision that the output is machine-parseable or directly committable.
4. Include an escape hatch for ambiguity (NEED_MORE_INFO, UNKNOWN, list assumptions).
5. Forbid specific failure modes the model is biased toward.

The fifth point is where most prompt templates fall short. Generic prompts say what you want; production prompts also say what you don’t want. “Do not invent details,” “do not use the word ‘instant’ if latency exceeds 500ms,” “do not ask clarifying questions” — these negative constraints are doing as much work as the positive ones.

Adapting These for Your Stack

Each prompt as written assumes a specific stack: Next.js, Drizzle, Postgres, Vitest. None of that is essential — what matters is that your stack appears in the context block with the same level of specificity. The model needs to know that you use Drizzle and not Prisma, because the generated code will be wrong by default for half the developers reading this.

The fastest way to adapt: create a single Markdown file in your repo called PROMPT_CONTEXT.md that contains the conventions section. Paste it into the context block of every prompt. When you change your conventions (you migrate from Express to Hono, you add Sentry, you start using Server Actions instead of API routes), update one file instead of seven prompts.

Some stack-specific tweaks worth knowing:

• Python/FastAPI: Add “use pydantic v2 models for all request/response shapes” and “raise HTTPException with structured detail dicts” to the role block.
• Go: Specify error-wrapping conventions (fmt.Errorf("...: %w", err)) explicitly; the model defaults to inconsistent patterns otherwise.
• Rust: State whether you prefer anyhow or thiserror; the model will guess wrong roughly 60% of the time without instruction.
• React Native: Specify Expo SDK version and whether you’re using new architecture (Fabric) — defaults assume old.
• Java/Spring: Clarify Spring Boot version, annotation vs. XML config preferences, and validation library (Jakarta vs. Hibernate Validator) to avoid mismatched imports.
• Node/Express vs. Hono/Fastify: Declare your router and middleware style, preferred error handler signature, and body parser library; the model mixes patterns otherwise.

[IMAGE_PLACEHOLDER_SECTION_2]

For pure content or docs-generation tasks (changelogs, release notes, migration READMEs), consider a smaller model with a stricter contract block that forces section headings and token-bounded outputs. This combination keeps costs predictable and outputs diffable in code review.

Useful Links

• OpenAI Models & Pricing
• SWE-bench Benchmark
• HumanEval Benchmark
• Drizzle ORM Docs
• Next.js Documentation
• Vitest Guide
• Tailwind CSS Docs
• Anthropic Claude Models