← From Idea to Build PlanArrows or space to advance · F for fullscreen · ⌘P to save as PDFSessions

The First Build · Session 01 · Dates TBD

From Idea to Build Plan

Vibe coding, prompting, Git, and a build you can recover

Ship AIPhoenix, ArizonaPress → to begin

Ship AIFrom Idea to Build Plan01/20

AI can build faster than you can recover. Tonight we fix the second half.

Speed becomes useful when the outcome is clear, the change is small, and there is always a clean way back.

Ship AIFrom Idea to Build Plan02/20

Tonight

  1. 01The four waves of AI-assisted building
  2. 02Where vibe coding works — and where judgement starts
  3. 03Turn one idea into a buildable brief
  4. 04Read the shape of the app in front of you
  5. 05Use Git as the save system
  6. 06Generate, inspect, undo, and save one visible slice
  7. 07Keep secrets out of the browser and the repository
Ship AIFrom Idea to Build Plan03/20

Where we are

  1. Session 01From Idea to Build Plan
  2. Session 02Make It Real
  3. Session 03Direct the Agent
  4. Session 04The First Build Hackathon

Four sessions, one product. Every session leaves a clean checkpoint the next one can trust, and catching up late is explicitly allowed.

Ship AIFrom Idea to Build Plan04/20

Act one

The builder's mental model

The tools changed in waves. The responsibility did not: you still own the outcome, the boundaries, and the decision to ship.

Ship AIFrom Idea to Build Plan05/20

Four waves, one direction

  1. AutocompleteThe model finishes the line while you hold the whole plan.
  2. Copy and pasteThe model returns a snippet; you move it into the codebase.
  3. Vibe codingYou describe a screen or simple workflow and iterate by feel.
  4. Agentic engineeringThe agent reads the system, plans, uses tools, checks the result, and keeps going.

Each wave still has a job. The mistake is using the fastest mode for work whose risk you cannot explain.

Ship AIFrom Idea to Build Plan06/20

Know which mode you are in

Vibe coding

  • A visible, reversible slice
  • Low-risk product exploration
  • Fast feedback from the browser
  • You can explain the desired result
  • A wrong turn is cheap to undo

Engineer it

  • Auth, payments, or permissions
  • Business rules with costly edge cases
  • Changes across several systems
  • Data that cannot be recreated
  • A failure users may not notice

The line is not beginner versus expert. It is reversible versus consequential.

Ship AIFrom Idea to Build Plan07/20

Intent over implementation does not mean judgement overboard.

Ask the agent to choose the code. Keep the product decision, the constraints, and the evidence of done.

Ship AIFrom Idea to Build Plan08/20

Act two

Make the idea buildable

A useful brief is small enough to finish and precise enough that two builders would recognize the same result.

Ship AIFrom Idea to Build Plan09/20

The prompt is a compact product brief

  1. WhatThe outcome in one sentence — a verb and the person it helps.
  2. WhereThe route, component, workflow, or repository area that changes.
  3. BehaviorWhat the user can do and what the system must return.
  4. ConstraintsWhat must stay untouched, plus security and accessibility boundaries.
  5. DoneThe observable checks that prove the slice works.

Example: add an empty-state CTA at /ideas. It opens the create form by mouse or keyboard, preserves existing routes, and shows success and failure. Those are checks the agent can finish.

Ship AIFrom Idea to Build Plan10/20

Read the app before changing it

What it answersLook here
RoutesWhich URLs and screens exist?app/ or pages/
ComponentsWhich pieces are reused?components/
PackagesWhat does the project depend on?package.json
CommandsHow does it run and check itself?scripts in package.json
HistoryWhat changed, and what can I recover?git log + git diff

You do not need to memorize the tree. You need to know which question each part can answer.

Ship AIFrom Idea to Build Plan11/20

Live build: orient before editing

~/your-product

Ask the agent: map this project before you edit it

entry route: app/page.jsxshared UI: components/checks: npm run buildproposed first slice: empty-state CTA

Have the agent name the entry point, reusable pieces, commands, and the smallest file set it expects to touch. If the plan names half the repository, the slice is not small enough yet.

Do this against the actual starter project. A generic tour teaches vocabulary; a project map teaches where to look tomorrow.

Ship AIFrom Idea to Build Plan12/20

Try the reusable skill

Run one useful example.

Use the prepared task and inspect the draft against the source facts.

Checking exercise availability…Made-to-order furniture · fictional classroom example

02 Start with a prepared example

Apply the write a small feature brief guide to the supplied classroom example. Produce the most useful draft, plan or review for this task in under 180 words. Use only supplied facts; identify missing evidence.

Read the instructions ↗
This uses an actual reusable skill. Authored by Ship AI. The result is a draft for you to review.
Your example output
Your output will appear here when you run the example.

    Choose a task, then run the example.

    Ship AIFrom Idea to Build Plan13/20

    Act three

    Build with a way back

    Git is not ceremony. It is the save system that lets you move quickly, inspect what the agent did, and discard the turn that went wrong.

    Ship AIFrom Idea to Build Plan14/20

    The safe iteration loop

    repeat
    1. 01Start from a clean checkpoint
    2. 02Ask for one reviewable change
    3. 03Run it and inspect the diff
    4. 04Keep it or restore the checkpoint

    Small commits are not about a tidy graph. They make the blast radius of a bad instruction small enough to understand.

    Ship AIFrom Idea to Build Plan15/20

    Configuration has a boundary

    Safe for the browser

    • A public site URL
    • A public analytics key
    • Theme and display settings
    • Anything a visitor may inspect

    Server only

    • Database credentials
    • Payment secret keys
    • Private API tokens
    • Anything that grants authority

    Environment variables do not make a browser value secret. If frontend code can read it, a visitor can read it too.

    Ship AIFrom Idea to Build Plan16/20

    Exercise: generate, reject, recover, save

    ~/your-product

    git status → git diff → npm run build → git commit

    1 visible slice, 3 files changed.env.local ignored — no secrets stagedbuild passedcheckpoint: first useful interface

    Build one visible slice from the brief. Inspect it in the browser and in the diff. Undo one intentionally bad change, rerun the check, then save only the clean version.

    The exercise is complete only after the repository is pushed and another person can describe what the commit changed.

    Ship AIFrom Idea to Build Plan17/20

    The checkpoint you leave tonight

    ArtifactEvidence
    Product briefOne user, one job, one core pathA stranger can restate it
    Project mapRoutes, components, commandsYou can find the first file
    Prompt recipeWhat · where · behavior · constraints · doneThe change stayed narrow
    RepositoryOne clean, pushed checkpointA bad turn was recovered

    Write all four into 01-foundations/. The next session assumes the repository starts here.

    Ship AIFrom Idea to Build Plan18/20

    Fast is only useful when back is cheap.

    Ship AIFrom Idea to Build Plan19/20

    Next

    Make It Real — Session 02, Workuity Biltmore

    Next session follows one real record from a form, through an API, into a database, and back onto the screen — then secures and deploys the whole path.

    shipai.club · Free program sessions

    Session page
    Ship AIFrom Idea to Build Plan20/20
    01/20