The Oneshot Paradigm

The most counterintuitive truth in AI-assisted development: fixing forward is slower than fixing backward.

The Principle

⚠️

When something doesn't work on the first try, go back to the original prompt with error logs and context. Don't try to patch the broken output.

❌ THE SLOW WAY (Fixing Forward)
┌─────────────────────────────────────────────────────────────┐
│  Prompt → Broken Code → Fix attempt → More bugs →          │
│           Fix attempt → Still broken → Fix attempt →       │
│           Context pollution → Start over anyway            │
│                                                             │
│  Time: 45 minutes                                          │
│  Result: Frustrated, context polluted, same problem        │
└─────────────────────────────────────────────────────────────┘

✅ THE FAST WAY (Oneshot Paradigm)
┌─────────────────────────────────────────────────────────────┐
│  Prompt → Broken Code → STOP                               │
│                           ↓                                │
│  Original Prompt + Error Log + "Avoid this" → Working Code │
│                                                             │
│  Time: 5 minutes                                           │
│  Result: Clean solution, fresh context                     │
└─────────────────────────────────────────────────────────────┘

Why This Works

AI models don't "learn" from mistakes in a conversation. When you try to fix broken code, the AI:

Carries forward confusion from the original error
Patches symptoms instead of addressing root causes
Pollutes context with failed attempts
Compounds errors with each iteration

Going back to the original prompt with new information gives AI a clean slate with complete context.

The Oneshot Formula

[Original Prompt] + [Error Log] + [What to Avoid] = Working Solution

Example: Failed API Integration

First Attempt (Failed):

"Create a function to fetch user data from the /api/users endpoint"

Result: Returns undefined, crashes on empty response.

❌ Fixing Forward (Don't do this):

"The function returns undefined, can you fix it?"
"It's still not working, now I get a type error"
"Actually the whole thing is broken, let's try again"

✅ Oneshot Paradigm (Do this):

"Create a function to fetch user data from the /api/users endpoint.

Here's what happened on my first attempt:
- Error: Cannot read property 'data' of undefined
- The endpoint returns { users: [...] } not { data: [...] }

Requirements:
- Handle the actual response shape { users: [...] }
- Return empty array if no users
- Handle network errors gracefully"

Visual: The Oneshot Loop

         ┌──────────────────────────────────────┐
         │         INITIAL PROMPT               │
         │    "Create feature X..."             │
         └──────────────┬───────────────────────┘
                        │
                        ▼
         ┌──────────────────────────────────────┐
         │         AI GENERATES CODE            │
         └──────────────┬───────────────────────┘
                        │
                        ▼
         ┌──────────────────────────────────────┐
         │           TEST IT                    │
         └──────────────┬───────────────────────┘
                        │
              ┌─────────┴─────────┐
              │                   │
              ▼                   ▼
         ┌─────────┐         ┌─────────┐
         │  WORKS  │         │ FAILED  │
         └────┬────┘         └────┬────┘
              │                   │
              ▼                   │
         ┌─────────┐              │
         │  SHIP!  │              │
         └─────────┘              │
                                  │
    ┌─────────────────────────────┘
    │
    │  DON'T fix forward!
    │  Instead, go back to start:
    │
    ▼
┌───────────────────────────────────────────────────┐
│              ENHANCED PROMPT                       │
│  ┌───────────────────────────────────────────┐   │
│  │ Original prompt                            │   │
│  ├───────────────────────────────────────────┤   │
│  │ + Error log / what happened               │   │
│  ├───────────────────────────────────────────┤   │
│  │ + "Avoid [specific problem]"              │   │
│  ├───────────────────────────────────────────┤   │
│  │ + Additional constraints learned          │   │
│  └───────────────────────────────────────────┘   │
└───────────────────────────────────────────────────┘
              │
              │ Fresh context, complete information
              ▼
         [AI generates correct code]

Real Examples

Example 1: Database Query

First attempt failed with:

Error: relation "users" does not exist

Oneshot retry:

"Write a query to get all active users.

Previous attempt failed with: relation "users" does not exist

Context I forgot to mention:
- Table is actually called "user_accounts" (not "users")
- Schema is "app" not "public"
- Active users have status = 'active' (not is_active = true)

Please query app.user_accounts where status = 'active'"

Example 2: React Component

First attempt failed with:

TypeError: Cannot read properties of undefined (reading 'map')

Oneshot retry:

"Create a UserList component that displays users.

My first attempt crashed with: Cannot read properties of undefined (reading 'map')

The issue was:
- Data comes from useQuery hook which is initially undefined
- Need to handle loading state
- Need to handle empty array case

Please include:
- Loading spinner while fetching
- Empty state message
- Null check before mapping"

Example 3: Authentication Flow

First attempt failed with:

401 Unauthorized - Token expired

Oneshot retry:

"Implement the login flow with JWT tokens.

First attempt failed because I didn't specify:
- Tokens expire after 15 minutes
- Need refresh token logic
- Need to handle 401 by refreshing, not logging out

Please implement with:
- Access token (15 min expiry)
- Refresh token (7 day expiry)
- Auto-refresh on 401 response
- Only logout if refresh also fails"

When to Use Oneshot vs. Fix Forward

Situation	Approach
Fundamental misunderstanding	Oneshot — AI needs complete context
Type error / typo	Fix forward is fine
Wrong API shape	Oneshot — describe actual shape
Logic error	Oneshot — explain expected behavior
Missing import	Fix forward is fine
Security vulnerability	Oneshot — explain the threat model
Performance issue	Oneshot — provide benchmarks and targets

The 3-Strike Rule

If you've tried to fix something 3 times and it's still broken, STOP. Go back to the beginning with a fresh prompt containing everything you've learned.

Strike 1: "Fix this error" → Still broken
Strike 2: "Try this instead" → Different error
Strike 3: "What about..." → Even more broken

STOP! → Oneshot with full context → Works

Key Takeaways

Fresh context beats polluted context — AI works better with clean information
Error logs are gold — They tell AI exactly what went wrong
"Avoid X" is powerful — Explicitly state what NOT to do
3 strikes = restart — Don't waste time patching patches

"The fastest path forward is sometimes going back to the beginning."

Eagle Sight Tornado Building