AdoptAnOrganizer

The zero-cost, AI-assisted playbook for building your Minimum Viable Product (MVP).

💡 Shortcut: You can just point your AI agent at this page's URL and tell it to follow the playbook. It will read through everything and get you most of the way through the project on its own.

0. Your Core Resources

Keep these links handy. You will feed them to the AI so it understands your vision.

1. The Setup

You do not need to hire a developer. Choose an AI coding assistant that fits your workflow:

Browser-Based (No Install):

  • → Claude — Paste prompts directly, copy generated code
  • → Bolt.new — Full-stack app builder with preview
  • → Lovable.dev — Similar to Bolt, good for rapid prototyping

Local/CLI-Based (More Control):

Once you've chosen your tool:

  1. Create an account or install as needed.
  2. Start a new blank project.
  3. Follow the sequential prompts below. Do not skip steps. Let the AI finish generating the code for one prompt before pasting the next.

1b. Going Agentic (Recommended)

Instead of copying and pasting code from a chat window, agentic tools give the AI direct access to your filesystem and terminal. It can read, write, and run code on your machine — like having a developer sitting at your computer.

Desktop Apps (Easiest Start):

  • →
    Claude Desktop — Use the "Projects" feature to load your docs, then let Claude work directly in a project folder on your machine.
  • →
    Codex Desktop — OpenAI's desktop agent. Point it at a directory and it builds, tests, and iterates autonomously.
  • →
    Antigravity Desktop — Local-first agentic environment. Runs on your hardware with full filesystem access.

Terminal / CLI (Maximum Control):

If you're comfortable with a terminal, you can run agents directly from the command line. This gives you the most transparency into what the AI is doing.

  • →
    Codex CLI — codex "build the backend per my spec docs"
  • →
    Hermes — Self-hosted agent with OpenRouter backend. Full control over models and data.

How to work agentically:

  1. Create a project folder on your machine: mkdir aao-mvp && cd aao-mvp
  2. Save your 4 core documents (or links to them) inside the folder.
  3. Open your chosen desktop app or terminal agent and point it at this folder.
  4. Feed it the prompts below one at a time. The agent will read your docs, write files, run builds, and fix its own errors.
  5. Review its work between steps. Accept what looks right, ask it to revise what doesn't.

The prompts below were written for browser-based tools, but they work identically with any agentic tool — just paste them into the agent's chat or terminal.

2. The Execution Loop

Step A: Establish the Brain (Database & Scope)

This forces the AI to read your documents and build the underlying database without getting distracted by future feature ideas.

I am building the MVP for a platform called AdoptAnOrganizer (AAO). I have 4 core documents outlining the platform.

Here are the links to my context:
1. Concept: https://docs.google.com/document/d/1sbywuqqkFXU2QENCxKfK839ggsAvnh_5Bt8iWFBDdcs/edit
2. Specs: https://docs.google.com/document/d/1hYDbaVWLAyqT_nBUWGRhsO64OFrFKMpaHrymyYThWHU/edit
3. Architecture: https://docs.google.com/document/d/1s7tCbooeSYnH6_JhzLRMn0_Pqw5gh6cKQizUok-Y9No/edit
4. Design: https://docs.google.com/document/d/1_nrEvJPnQATPQK_00ezUwtklthM9CZhi2_34AB0WBM4/edit

Task 1: Read these documents. Enforce a strict feature freeze. We are ONLY building three things:
1. Organizer Trust Verification
2. Housing/Couch Donations
3. Matching Funds Allocation ($800-$1250 tiers)

Task 2: Build the database schema (Users, Roles, Housing Offers, Fund Matches) based on the "Social Movement Platform V2" shared-database architecture concept. 
Build the backend first. Do not build the UI yet.

Step B: Build the Trust Engine

The most important part of the app is psychological safety for donors and hosts.

The backend looks good. Now, let's build the frontend UI for the **Organizer Trust Verification** flow.

Create a clean, minimalist interface. I need:
1. A view for an aspiring organizer to submit their verification details.
2. A public-facing profile view where supporters can clearly see that verification status.

Reference the first 22 pages of the Design document to ensure the UI feels highly secure, legible, and trustworthy. Let me know when this is ready so I can test it in the preview window.

Step C: The Housing Board

Allows hosts to securely offer their space to verified organizers.

Next, build the **Housing/Couch Donation** view. 

Requirements:
- A Host must be able to list a temporary space.
- This listing system must link directly to the verified organizer profiles we just built. 
- A Host must be able to see the Organizer's verification status before accepting.
- Hide exact addresses for privacy until a match is confirmed.

Implement this flow and update the UI.

Step D: The Money Matches

The final core pillar for wealthy progressives to distribute funds.

Finally, implement the **Matching Funds Workflow**.

Requirements:
- Create a dashboard for a 'Funder' user role.
- They need to see a queue of verified organizers who have met their initial community support goals.
- The interface must clearly display the required matching funds tier ($800 to $1,250) based on the organizer's city tier.
- Add a simple "Approve Match" workflow.

Your Project's Brain: NotebookLM

Before you write any code, you need a thinking partner. Google NotebookLM is a free AI tool designed to ingest your project documents and become an absolute expert on your vision.

How to set it up:

  1. Go to NotebookLM and create a new notebook called "AdoptAnOrganizer".
  2. Upload all four of your core reference documents linked above.
  3. Use it as your sounding board: If you get stuck, aren't sure how a feature should work, or need to summarize the requirements for the coding agent, ask NotebookLM. It will answer using only your uploaded documents, ensuring you stay perfectly aligned with your original goals.

Other Essential Tools for the Unknown

When you aren't sure what you need yet, these tools help bridge the gap between an idea and an execution:

  • ▹
    v0.dev (Visualizing interfaces): If you are struggling to picture what the Trust Verification dashboard should look like, type your idea into v0. It generates clean, modern UI designs instantly. You can then show that design to your coding agent to copy.
  • ▹
    Claude (The Debugger): If your coding agent gets confused by a massive error and the "Emergency Fix" prompt isn't working, paste the error into Claude. It is incredible at explaining complex code breaks in plain English so you can direct your agent on how to fix it.
  • ▹
    Excalidraw (Mapping it out): A perfectly minimalist digital whiteboard. When you need to visually map out how a donor connects to an organizer before you prompt the AI, sketch the flow here first.

⚠️ Emergency Fixes

If the AI breaks the app or gives you an error screen, do not panic. Just paste this into the chat:

The app broke and is showing an error. Please undo your last change, analyze why it failed, and try a safer approach to implement the feature.
html>w({ behavior: 'smooth', block: 'start' }); tocLinks.forEach(l => l.classList.remove('active')); link.classList.add('active'); } }); }); html>