Solves

Solves Phases: P0 to P100

Bridge from product write-up into executable build phases.

Solves — P0 to P100

What this is: the bridge from the product write-up to code.
What this is not: a stack, a schema, or a ticket dump.
Parent doc: PRODUCT-WRITEUP.md. If they fight, this file plus write-up §12 win.
Date: 29 Aug 2026 (America/Chicago)

How to read it: P0 is nothing. P100 is a stranger can use the whole system. Each jump is a system, not a page. The next agent turns each P-band into coding tasks. They do not invent systems that are not here.

Two build rules, before anything else (the founder hits these every vibe-coded project):

  1. One task list. If it is not on the list, it is not in the repo.
  2. One paper CSS system. If a page needs new CSS, it is not done.

The systems (plain English)

System Job First appears
Task list One place for all work P10
Paper UI The look: letter, note, box, button P10
Public read Anyone can look, no account P20
Problem A standing letter P20
Solve A note on that letter P20
API Same objects the site uses P30
User A person, from sign-in P40
SSO Google or GitHub, one tap P40
Create problem Signed-in person starts a letter P50
AI refine Tightens the letter in their words P50
Post solve Signed-in person adds a try P60
Compare Two notes on the same letter P70
Seed examples Desk is not empty on first visit P80
Trust bits “This is someone else’s page,” legal stub P80
Ship bits Phone check, domains pointed P90

Not in P0–P100 (do not sneak them in): hire, escrow, bounty, hosted demos, iframe, comments, likes, profiles as a product, search as a product, Zapier, MCP, leftover-thread bot, ads, featured-for-pay, “we build the winner,” a second CSS kit.

P0 — Start

Nothing is built. The write-up exists. Domains are bought (solvesmyproblem.com, getsolves.com, ssolves.com). They do not have to point yet.

Done: this phases doc is the list. The coding-task agent only works from here.

P10 — Spine

The two things that stop vibe-code rot.

Task list. One list. Every later P-band becomes tasks on this list. A task says: what it is, which system, what done looks like, what it must not do.

Paper UI. One system: warm off-white, ink text, one type family, a small space scale, one letter width. Components only: page, letter, note, box, button. Home and a fake Problem and a fake Solve already look like the same paper, even if the data is fake.

Not yet: real accounts, real API, real AI.

Done: you can open a phone-width page that looks like Solves, and the task list is the only backlog.

P20 — Look

A visitor can read. No account.

Public read. Home: one box, one paragraph of purpose, a few problems. Problem: a letter. Solve: notes on the letter. If two notes exist, they sit side by side.

Data can still be fake or filed by hand. It must be real pages, not a mock image. Real HTML on first paint. Same paper components as P10.

Not yet: sign-in, create, AI, API.

Done: a stranger understands the site in one pass and can open a problem with two notes.

P30 — Same objects everywhere

The site stops being a special case.

API (read). List problems. Get one problem with its solves. Get one solve. Anyone can read. The pages in P20 now come from these objects, not from pasted HTML.

Problem and Solve exist as the only content objects. No User yet.

A founder key may load example rows so we are not stuck. That is seeding, not the product.

Not yet: public write, SSO.

Done: change a problem in one place, the page and the read API both show it.

P40 — Who you are

SSO. Google and GitHub. One tap. That creates a User. No extra profile form if we can avoid it.

User is now a real object: who they are (name, avatar if given). Not a freelance shop, not a settings maze.

Reading is still public. Writing still waits for P50–P60.

Not yet: create problem, post solve (the buttons can show “sign in to do this”).

Done: a person can sign in with Google or GitHub and see they are signed in. Sign out works.

P50 — Say a problem

This is the first write system.

Create problem. Signed-in user. The home box is the start. Not a 12-field form.

AI refine. A short back-and-forth that turns “I have a stack of PDFs” into a letter: what done looks like, what they already tried, in their words. One question at a time. Polite no to Uber-clones, homework, generic “I have an app idea.”

If they are not signed in, the box still takes the first words, then asks them to sign in with Google or GitHub to save and publish.

Human publishes. Drafts can exist. Unpublished = not public, not in the read list.

Not yet: posting a solve.

Done: a signed-in person can go from a messy sentence to a published Problem letter without a form from the county clerk.

P60 — Post a try

Post solve. Signed-in user. On a Problem: what I did, a link (https), up to 4 pictures. Code / prompt / repo stay behind “How they did it.”

No hire button. No score. No iframe. No hosting their app.

Done: two different signed-in people (or one person twice, for testing) can leave two notes on the same letter.

P70 — The loop

The system is one piece.

A stranger reads. They sign in. They create a problem (AI helps). Someone posts a solve. A second solve appears. The two notes sit side by side on the letter.

Empty states exist: no solves yet, AI said no to homework, sign-in failed.

Chrome has no “vibe,” “ship,” or “prompt.” Buttons are English.

Done: you can tell the story of the product by clicking through, not by explaining.

P80 — The desk is not empty

Seed examples. A handful of real-looking problems (the 15 jobs are a menu to pick from, not a build requirement). Must-have for a first public look: two solves each on a PDF-to-Excel job and a card-on-invoice job. Placeholders are fine until the founder writes the letters.

Trust bits. Before a solve link opens: “This is someone else’s page. We didn’t build it.” A short privacy / terms stub. We don’t handle their card, clinic, or church data.

Not yet: a bot that scrapes forums. A human or a founder script loads the examples.

Done: first visit is not a blank product. Trust copy is on the paper.

P90 — Holds together

Phone. Every page is the same paper at phone width. Mad CSS is a ship-blocker.

Domains. Point solvesmyproblem.com (public), getsolves.com (short), ssolves.com (same site). Founder task; do not block code on it, do not ship a public link until it is done.

Read API still matches the pages. Write is only signed-in users (plus founder seed key).

Done: you would let a parent and a 20-year-old use it without standing over their shoulder.

P100 — Usable

A stranger can:

  1. Understand the homepage.
  2. Read a problem with no account.
  3. Sign in with Google or GitHub.
  4. Create a problem and refine it with AI.
  5. Post a solve.
  6. See two tries on one letter.

Same objects on the API. One task list. One CSS system. Three names can point here.

P100 is not “the company is finished.” It is “the system exists.” Stop. Do not add a new system to hit 100.

After P100 (named so nobody sneaks them in)

Do these only after P100 is real. Each is its own later band.

Later What it is Why it waits
Moderation Hold / reject junk problems Need real posts first
Webhooks / Zapier / MCP Others write without the UI Site must be the first client
Leftover-thread bot Suggests example problems Inventory, not the system
Featured / money Pin a problem, tool-company promo Need traffic
Light profiles “These solves are mine” Empty profiles are trash
Bounty Optional purse on a problem that already has tries Liquidity is hard; don’t start here
Hosted demos We run their app Liability. Default is still a link

What the coding-task agent does with this file

  • Turn each P-band into a short list of tasks on the one task list.
  • Every task names the system (table at the top).
  • Do not write tasks for “After P100” until P100 is done.
  • Do not invent a stack in the task titles if you can say it in product words.
  • First tasks are always: the list itself, then paper CSS.
  • If a task needs new CSS, it is the wrong task.

One-page scoreboard

P You have You can tell someone
0 Docs, domains bought “We’re starting.”
10 List + paper “It looks like Solves.”
20 Readable pages “You can look.”
30 Objects + read API “The site and the API are the same.”
40 Google / GitHub user “You can sign in.”
50 Create + AI refine “You can say a problem.”
60 Post solve “You can try.”
70 Full loop “You say it, they try, you look.”
80 Examples + trust “It isn’t empty. Links are honest.”
90 Phone + domains “I’d show my parent.”
100 Usable system “Use solvesmyproblem.com.”

Bridge only. Parent: PRODUCT-WRITEUP.md. No TAM. No stack. No schemas.