CYDERCODER // PLAYBOOK
SYS.STATUS: OK 00%
> INITIALIZING...
Install this playbook for offline access
You're offline — reading cached content
WHO THIS IS FOR

Built for every stage of the builder journey

Beginners

Clear path from zero to deployed product in one afternoon. Exact AI prompts to copy. Explains the why, not just the how — all the way to production with a custom domain.

  • Build your first website end-to-end
  • Deploy with Vercel, set up Google Search Console
  • Understand what React is doing behind the scenes

Senior Devs

A reference manual for AI architecture decisions. RAG chunking, MCP, multi-agent systems, CDN caching, deployment strategies — without the fluff.

  • RAG chunking strategies, MCP protocol architecture
  • Typography scale, color theory, motion design systems
  • CDN caching, edge functions, deployment strategies
Portrait Lock Active
Please rotate your device back to Portrait orientation to read the playbook content.
Back to Dashboard

The AI Workflow: The Senior Orchestration Engine

01. The Myth of “Vibe Coding”

Junior developers treat tools like Bolt.new or Lovable like a slot machine — they drop in a huge, vague prompt like “Build me an e-commerce store with user accounts” and press generate.

When the AI inevitably makes an architectural error, they try to fix it by typing “No, fix that error.” This creates a death loop where the AI patches bad code with worse code until the token window is saturated and the app breaks completely.

The Senior Realization: Senior developers do not use AI to skip thinking. They use AI to skip typing. The human remains the architect; the AI is the tireless junior engineer executing the structural blueprint.

The Three Modes of AI Usage

Not all AI interaction is equal. Understanding which mode you’re in prevents you from wasting tokens and burning time.

ModeWhat It MeansExample
Generator ModeAI creates something from scratch based on a prompt”Generate a React login form with Supabase auth”
Transformer ModeAI modifies existing code based on specific instructions”Add rate limiting to this Express middleware”
Navigator ModeAI explains, debugs, or plans without writing code”Why is this useEffect causing an infinite loop?”

The trap: Junior devs use Generator Mode for everything. Senior devs use Generator Mode once (for scaffolding), then switch to Transformer Mode for all subsequent work. The moment you find yourself re-prompting the generator more than twice for the same file, you’ve entered the death loop.


02. The Five Levels of AI Tooling

Every AI tool falls into a specific capability tier. Knowing which level you’re operating at prevents you from using a sledgehammer where you need a scalpel.

LevelWhat It DoesToolsWhen to UseCost
5: Autonomous AgentsFull task executionDevin, OpenAI CodexEnd-to-end without supervisionVery high
4: Execution AgentsTerminal commands, testsAntigravity, Mimo AgentRun commands, debug systemHigh
3: Code-Native IDEsFile-aware editingCursor, WindsurfEdit existing code across filesMedium
2: Scaffold EnginesFull-stack generationLovable, Bolt.newBootstrap new projectsMedium
1: Chat & ReasoningText generation, planningClaude, ChatGPT, GeminiCode snippets, explanationsLow

The Critical Rule: Match the Level to the Task

TaskCorrect LevelWrong LevelWhy
Plan a database schemaLevel 1 (Claude)Level 2 (Lovable)You need thinking, not generation
Bootstrap a full-stack appLevel 2 (Bolt.new)Level 1 (ChatGPT)You need a running project, not code snippets
Add a middleware functionLevel 3 (Cursor)Level 2 (Lovable)You need file-aware editing, not a full rebuild
Run the test suiteLevel 4 (Antigravity)Level 3 (Cursor)You need terminal execution, not code editing
Deploy to productionLevel 4 (Antigravity)Level 2 (Lovable)You need system operations, not UI generation

Senior Move: The Level Handoff

The elite workflow never stays at one level. You move up and down the stack as the task demands:

Level 1 (Claude):  "Design the auth flow for a SaaS app"
        │
        ▼
Level 2 (Bolt):    Scaffold the project with the schema Claude defined
        │
        ▼
Level 3 (Cursor):  Refactor the generated components to match your design system
        │
        ▼
Level 1 (Gemini):  "Write a skeleton loading animation with shimmer effect"
        │
        ▼
Level 4 (Antigravity): Implement the animation in the project, run tests
        │
        ▼
Level 3 (Cursor):  Final polish, code review, optimization

Notice the pattern: Level 1 for thinking, Level 2 for scaffolding, Level 3 for editing, Level 4 for executing. You drop down to cheaper levels for creative work and climb up to expensive levels only when you need system access.


03. The Elite Multi-Tool Lifecycle

In 2026, no serious full-stack app is built inside a single chat window. The most efficient workflow splits development into specialized stages, using each tool for what it does best.

Level 1ConceptClaude / Gemini
Level 2PrototypeLovable / Bolt
Level 3ProductionCursor / GitHub
Level 1+4PolishGemini / Claude

Stage 1: Conceptual Architecture (Level 1 — Claude / Gemini)

The Goal: Define the database schema, data relationships, component tree, and API contracts before touching code.

Why this matters: Chat models without project context choose popular packages based on intuition. Reasoning models look at your constraints and output clean markdown specifications. You need the spec before the scaffold.

What to generate:

  • Database schema with exact column types
  • Component hierarchy (parent → child relationships)
  • API endpoint list with request/response shapes
  • Auth flow diagram

Tell Claude or ChatGPT: “Create a spec.md file for a Community Savings App with:

  • Database schema: users table (id, email, role, created_at), contributions table (id, user_id, amount, cycle_id, created_at)
  • API endpoints: signup, get contributions, create contribution
  • Component tree and auth flow diagram”

What the AI gives you: A structured markdown file with tables defining your database schema, API endpoints, and component hierarchy. This becomes your blueprint — paste it into Lovable as the first prompt.

Stage 2: Rapid Scaffolding (Level 2 — Lovable / Bolt.new)

The Goal: Generate the full boilerplate, front-end visual states, and initial API wrappers within minutes.

Tool Selection:

ToolBest ForStack
Bolt.newRapid prototyping, npm package testing, component previewsAny (WebContainer sandbox in browser)
LovableClean full-stack TypeScript with backend integrationReact + Supabase + Stripe
v0UI component generation, shadcn/ui patternsReact + Tailwind + shadcn

The Senior Move: Paste your spec.md as the first prompt. This forces the AI to build around your concrete schema instead of inventing its own. Once the MVP works — core routes render, auth flows, database connects — stop prompting. Do not try to build enterprise complexity inside a browser chat window.

Stage 3: Export & Ground (Level 3 — GitHub & Local IDE)

The Goal: Move the generated code out of the browser and into your secure local environment.

The Execution:

  1. Use Lovable’s or Bolt’s GitHub integration to push to a clean branch
  2. Clone the repository locally
  3. Open in Cursor or your preferred IDE
  4. Run npm install and verify the app boots

From this point, you own the code. Browser token limits, session timeouts, and context windows no longer apply. You have full git history, full file access, and full control.

Stage 4: Polish & Optimize (Level 1 + Level 4)

The Goal: Implement micro-interactions, animations, performance optimizations, and final QA.

This is where most devs waste tokens. They stay in the scaffold engine trying to generate complex animations, custom physics, or performance optimizations. The scaffold engine wasn’t built for that.

The correct workflow:

Step 1: Ask Gemini or Claude (Level 1) to generate the animation code

Prompt: "Write a skeleton loading component with a shimmer animation
         using CSS custom properties. The shimmer should sweep left to
         right over 1.5s with a 10% gradient width. Output only the
         React component file."

Step 2: Copy the generated code into your project manually or via
        Antigravity (Level 4) to write the file and run the dev server

Step 3: Refine in Cursor (Level 3) if adjustments are needed

Why this works: Level 1 models (Gemini, Claude) are optimized for code generation — they produce clean, isolated snippets at low cost. Level 4 agents (Antigravity) are optimized for execution — running commands, writing files to disk, starting servers. Using Level 4 to generate a loading animation wastes expensive execution tokens on creative work that a cheaper model handles better.


04. Blueprint: Step-by-Step Production Run

Let’s trace the exact pipeline to build a production-ready SaaS application cleanly.

Step 1: Ground the System Specs

Before opening any app builder, write a raw markdown specification. This is your architectural contract — the AI builds around it, not instead of it.

# spec.md — Community Savings Platform

## Tech Stack
- Frontend: React 18 + Tailwind CSS + shadcn/ui
- Backend: Supabase (PostgreSQL + Auth + RLS)
- Payments: Stripe (one-time contributions)
- Hosting: Vercel (frontend) + Supabase (backend)

## Core Features
1. User auth (email/password + Google OAuth)
2. Savings cycles (admin creates, members join)
3. Contribution tracking (amount, timestamp, cycle)
4. Dashboard (personal stats, cycle progress)

## Database Schema
[Your schema from Stage 1 goes here]

## Component Tree
App
├── AuthProvider
│   ├── LoginPage
│   ├── SignupPage
│   └── DashboardLayout
│       ├── Sidebar
│       ├── CycleList
│       │   └── CycleCard
│       ├── ContributionForm
│       └── StatsPanel

Step 2: Feed the Spec to the Scaffold Engine

Paste the entire spec.md into Bolt.new or Lovable as your opening prompt. Add: “Build this application exactly as specified. Do not deviate from the schema or component tree.”

The explicit instruction prevents the AI from “improving” your architecture with its own ideas.

Step 3: Visual Edits Over Conversational Patches

When adjusting UI — margins, typography, colors, spacing — do not write text prompts. Use the visual editor (Lovable’s design panel) or inspect the CSS directly. Writing “Make the header padding slightly smaller” consumes 200+ tokens and often produces the wrong result. Clicking the padding value and changing 16px to 12px takes 2 seconds and costs zero tokens.

Step 4: The Clean Handoff

Once the core layout, database integration, and auth states work:

  1. Commit and sync to GitHub
  2. Close the browser tab — sever the prompt loop
  3. Clone locally, open in Cursor
  4. From here: use @file references for targeted edits only

The rule: After the handoff, you never go back to the scaffold engine. All further work happens in your IDE with file-scoped AI assistance.


05. Unwritten Rules of the AI Workflow

Rule 01: Generate Snippets, Not Systems

Never ask an AI to generate an entire application in one shot. Generate individual components, individual functions, individual files. Then assemble them yourself.

Why: AI generates better code when the scope is narrow. A prompt asking for “a full auth system” produces mediocre code. A prompt asking for “a JWT refresh token middleware with rotation” produces excellent code.

Rule 02: Read the Error Before Pasting It

When a build fails, do not blindly copy-paste the terminal log into the chat box.

The Move: Look at the file path and error trace yourself. 9 times out of 10, it’s a missing environment variable, a mistyped import path, or a missing dependency. Fixing it manually prevents the AI from restructuring three unrelated files to fix a simple typo.

Rule 03: The Single-File Responsibility Principle

Never accept an AI suggestion that rewrites an entire 400-line file to add a single feature. If the AI proposes replacing the whole file, reject it. Instruct it to output only the specific function, component, or diff required.

Prompt pattern: “Do not rewrite the entire file. Show me only the new function I need to add and the exact line where it should be inserted.”

Rule 04: Use the Right Level for Animations

Loading screens, shimmer effects, page transitions, and micro-interactions are creative code generation tasks. They belong at Level 1 (Gemini/Claude), not Level 4 (execution agents).

The flow:

  1. Prompt Gemini or Claude: “Create a page transition component using Framer Motion. Fade in content over 300ms with a subtle Y-axis slide from 8px. Use React 18 concurrent features.”
  2. Copy the output into your project (manually or via Antigravity)
  3. Refine in Cursor if needed

Why: Execution agents burn expensive tokens on system operations. Generating a loading animation is pure text generation — use the tool built for text generation.

Rule 05: The Two-Prompt Maximum

If you’ve prompted the same AI tool more than twice to fix the same issue, stop. The tool has lost context or the problem is beyond its capability at that level.

The escape route:

  • Level 2 failing? → Drop to Level 1, analyze the problem, then manually fix in Level 3
  • Level 3 failing? → Drop to Level 1, ask for an explanation, then apply the fix yourself
  • Level 4 failing? → Check your environment variables and dependencies manually

Rule 06: Never Trust Generated Secrets

AI tools will happily generate API keys, JWT secrets, and database URLs in your code. Never use them. Always use environment variables and .env files that are gitignored.

Prompt pattern: “Use process.env.DATABASE_URL for the connection string. Never hardcode credentials.”


These are the exact patterns that separate senior engineers from vibe coders.

The Death Spiral Prompt

Bad: “Build me a full-stack social media app with posts, comments, likes, user profiles, real-time notifications, and a chat system”

Why it fails: The scope is too large. The AI will generate shallow code for all features instead of deep code for any single feature.

Good approach (step by step):

  1. “Design the database schema for a social media app with posts, comments, likes, and user profiles”
  2. “Build the user authentication flow with Supabase”
  3. “Build the post creation and feed display”
  4. “Add comments to posts”

Why it works: Each prompt has a narrow, achievable scope. The AI produces high-quality code because it can focus.

The Context Window Pollution

Bad: Pasting your entire 2,000-line codebase into the chat to fix a single CSS alignment issue.

Why it fails: The model has to process 2,000 lines of irrelevant code to find the 3 lines that matter. Quality degrades.

Good: “Here is my Header.tsx component [paste file]. The logo and nav links are not vertically centered. Fix the flex alignment.”

Why it works: The AI sees exactly the file that needs fixing and the specific problem to solve.

The Framework Migration Trap

Bad: “Rewrite my entire app from JavaScript to TypeScript”

Why it fails: The AI will generate a type-heavy mess where every variable is any and every function signature is wrong.

Good: “Convert just the /api/auth.ts file to TypeScript. Add proper types for the request and response objects. Do not change any logic.”

Why it works: Incremental migration with explicit constraints. The AI adds types without breaking working code.


Key Takeaways

ConceptMental ModelSenior Insight
Vibe CodingSlot-machine promptingGenerator mode once, transformer mode forever after
AI LevelsMatch tool capability to task complexityLevel 1 for thinking, Level 2 for scaffolding, Level 3 for editing, Level 4 for executing
Multi-Tool LifecycleSpecialized stages, specialized toolsNever build an entire app in one tool — hand off between levels
Spec-First BuildingArchitect before you generateWrite spec.md before opening Bolt or Lovable
Visual Over ConversationalClick beats typeUse visual editors for UI tweaks, not text prompts
The Clean HandoffBrowser → GitHub → Local IDEAfter scaffolding, sever the browser prompt loop permanently
Single-File ResponsibilityNarrow scope = high qualityNever accept a full-file rewrite for a single feature
Two-Prompt MaximumKnow when to drop levelsIf twice fails, change your approach, not your prompt