Chapter 11: Prompt Chaining — Building Complex Features Step by Step

Why Long Prompts Fail

Here is a failure pattern every vibe coder runs into: you write a detailed, comprehensive prompt asking the AI to build a complete feature. The output looks impressive on first glance. But when you try to run it, things are missing, assumptions are wrong, and the integration points are broken.

The problem is not the AI. It is the prompt structure.

Long, complex, multi-requirement prompts force the model to make many implicit decisions simultaneously. Some of those decisions conflict. Others are based on assumptions the model makes because it does not know enough about your specific codebase.

The solution is prompt chaining: breaking complex features into a logical sequence of focused prompts, where each output feeds the next.

---

The Anatomy of a Prompt Chain

A prompt chain has three types of steps:

Design prompts — Produce specifications, schemas, and architecture decisions. No code yet.

Build prompts — Implement one specific piece, referencing the design output.

Integration prompts — Connect the built pieces together and handle edge cases.

---

Example: Building a Subscription System

Let's walk through building a full Stripe subscription system using prompt chaining. A single mega-prompt for this almost always breaks. A chain works reliably.

Step 1: Design Prompt (Database Schema)

Before writing any code, design the database schema for a subscription system.
Requirements:
- Users can subscribe to one of three plans: free, pro ($9/mo), enterprise ($49/mo)
- Each user has exactly one active subscription at a time
- We need to track subscription history (upgrades, downgrades, cancellations)
- We need to store Stripe customer IDs and subscription IDs

Output: A Supabase SQL schema (CREATE TABLE statements) with comments explaining each decision.
Do not write any application code yet.

Review the schema. Adjust if needed. Then proceed.

Step 2: Build Prompt (Stripe Webhook Handler)

``` Using this database schema:

[paste the schema from Step 1]

Build a Next.js API route at /api/stripe/webhook that handles these Stripe events:

• customer.subscription.created → insert into subscriptions table
• customer.subscription.updated → update existing subscription record
• customer.subscription.deleted → mark subscription as cancelled
• checkout.session.completed → link Stripe customer to our user record

Test the webhook with the Stripe CLI. Then proceed.

### Step 3: Build Prompt (Checkout Route)

Build a Next.js API route at /api/checkout that:

• Requires authenticated user (Supabase session)
• Accepts { priceId: string } in the request body
• Creates or retrieves a Stripe customer for the user
• Creates a Stripe Checkout session for the given price
• Returns { url: string } (the Checkout redirect URL)
• Handles the case where the user already has an active subscription (returns the Stripe Customer Portal URL instead)

### Step 4: Build Prompt (Frontend Pricing Page)

• Shows our three plans: Free (0), Pro ($9/mo), Enterprise ($49/mo)
• Highlights the user's current plan
• Shows a "Upgrade" button for plans above the current one
• Shows a "Manage Subscription" button for users on paid plans
• Calls /api/checkout on button click and redirects to the returned URL
• Shows a loading state during the API call

### Step 5: Integration Prompt (Middleware & Access Control)

• Create a utility function getSubscriptionTier(userId) that reads the user's active subscription from Supabase and returns 'free' | 'pro' | 'enterprise'

• Create a middleware helper requireSubscription(tier) that wraps API routes and returns 403 if the user's tier is below the required level

• Apply requireSubscription('pro') to our existing /api/generate route

• Add a subscription status indicator in the app navbar showing the current plan name

---

The Chain Design Principles

• Each step should produce something you can verify. If you cannot test or review the output of a step independently, split it further.

• Carry forward only what the next step needs. Do not dump the entire previous output into every prompt — extract and paste only the relevant parts.

• Design before building. Schema and architecture decisions are cheapest to change at the design stage. Let the AI reason through them without code first.

• One integration point per step. When connecting components, focus on one connection at a time. Connecting everything simultaneously is where chains break.

Key Takeaway

Prompt chaining is the single biggest quality improvement you can make to your vibe coding workflow. It requires more planning upfront but produces dramatically more reliable, integrated code. Think of it as the equivalent of writing a technical specification before coding — the upfront cost pays for itself many times over.