A Same-Day Waitlist Slice for AI-Generated MVPs

Solo founders ship faster when an AI coding agent is fenced to a waitlist slice, not a full SaaS. The first public artifact is a landing page, a durable email capture, and one honest loop. Checkout, multi-tenant admin, and webhook meshes stay out of the tree until someone actually joins.

Agents assume the opposite. A prompt that says "build my product" often returns payment clients, cloud queues, object storage, and three auth providers. That output looks serious. It also delays the only result that matters on day one: a working URL with a zero invoice.

This write-up gives a slice spec, a repository checker, and a no-network smoke test. The method is for indie hackers who will trade a narrow product for a same-day ship and will accept local storage limits. Current agent write-ups keep circling the same failure: the model invents architecture, then the founder inherits the bill and the debt. A waitlist slice cuts that path before files land.

The failure mode

Cheap generation does not make a cheap product. An agent that can emit files in seconds will still invent architecture that needs paid APIs, secret rotation, and a weekend of glue.

The leftovers are consistent across stacks. Payment SDKs appear before a single user. Transactional email vendors appear before a CSV export. Redis appears before a sqlite table of fifty rows. Those modules become technical debt the moment they land, because nobody will maintain a billing layer that has never charged a card.

A waitlist slice is a refusal of that debt. The POST must persist. Duplicate emails must fail closed. The founder must export the list without folklore. That is the whole product for the first ship.

Consider a later GitHub-ranking tool. Today it only collects emails of people who want the ranking. The agent is not allowed to clone an API client "for later". Unused clients are how cheap code turns into next week's outage. The founder ships a URL instead of a platform diagram.

The slice spec

Keep the contract in the repository. The agent reads it. The checker enforces it. Human review still happens, but mechanical rejects catch expensive assumptions first.

{
  "name": "waitlist-slice",
  "ship_today": true,
  "routes": {
    "allow": [
      "GET /",
      "POST /waitlist",
      "GET /health",
      "GET /export.csv"
    ],
    "deny_prefixes": ["/billing", "/webhooks", "/admin/users", "/v1/"]
  },
  "storage": {
    "allow": ["sqlite", "local-json"],
    "deny": ["postgres", "redis", "s3", "dynamodb"]
  },
  "packages": {
    "deny": [
      "stripe",
      "boto3",
      "@aws-sdk/client-s3",
      "openai",
      "mailgun.js",
      "@sendgrid/mail",
      "pg",
      "ioredis"
    ]
  },
  "env": {
    "allow": ["PORT", "DATABASE_PATH", "EXPORT_TOKEN"]
  },
  "behavior": {
    "duplicate_email": "reject-with-409",
    "export": "csv-behind-token",
    "network_in_tests": false
  }
}

Save the file as slice.spec.json at the repository root. The file is the product boundary. Chat messages that contradict it lose.

A proposed system prompt, not a captured production log, can stay this short:

Implement only slice.spec.json.
Do not add packages, env keys, or routes outside the allow lists.
If a feature needs Stripe, S3, Redis, or Postgres, refuse and keep sqlite.
Return a file list and the command to run check_slice.py.

Checker script

The checker is boring on purpose. It walks manifests and source files, then fails the run when a deny rule matches. Treat it as a proposed gate a founder can copy, not as a benchmark or a production incident report.

#!/usr/bin/env python3
"""Fail the build when an AI scaffold leaves the waitlist slice."""
from pathlib import Path
import json
import sys

ROOT = Path(".")
SPEC = json.loads(Path("slice.spec.json").read_text(encoding="utf-8"))
MANIFESTS = ["package.json", "requirements.txt", "pyproject.toml", "go.mod"]
SOURCE_GLOBS = ["**/*.py", "**/*.ts", "**/*.js", "**/*.go"]
SKIP_PARTS = {".git", "node_modules", "dist", "venv", "__pycache__"}


def read_text(path: Path) -> str:
    try:
        return path.read_text(encoding="utf-8", errors="ignore")
    except OSError:
        return ""


def iter_sources():
    out = []
    for pattern in SOURCE_GLOBS:
        for path in ROOT.glob(pattern):
            if SKIP_PARTS.intersection(path.parts):
                continue
            if path.is_file():
                out.append(path)
    return out


def fail(msg: str) -> None:
    print(f"SLICE FAIL: {msg}", file=sys.stderr)
    raise SystemExit(1)


def check_packages() -> None:
    deny = [p.lower() for p in SPEC["packages"]["deny"]]
    blob = "\n".join(read_text(ROOT / name) for name in MANIFESTS).lower()
    for pkg in deny:
        if pkg in blob:
            fail(f"denied package in manifest: {pkg}")
    joined = "\n".join(read_text(p) for p in iter_sources()).lower()
    for pkg in deny:
        if pkg in joined:
            fail(f"denied package in source: {pkg}")


def check_env() -> None:
    allow = set(SPEC["env"]["allow"])
    env_example = read_text(ROOT / ".env.example")
    keys = set()
    for line in env_example.splitlines():
        if not line or line.startswith("#") or "=" not in line:
            continue
        keys.add(line.split("=", 1)[0].strip())
    extra = keys - allow
    if extra:
        fail(f"env keys outside allowlist: {sorted(extra)}")


def check_routes() -> None:
    deny = SPEC["routes"]["deny_prefixes"]
    text = "\n".join(read_text(p) for p in iter_sources())
    for prefix in deny:
        if prefix in text:
            fail(f"denied route prefix present: {prefix}")


def main() -> None:
    if not Path("slice.spec.json").exists():
        fail("missing slice.spec.json")
    check_packages()
    check_env()
    check_routes()
    print("SLICE OK")


if __name__ == "__main__":
    main()

Invoke it before any deploy command:

python3 check_slice.py

A typical failure looks like this:

SLICE FAIL: denied package in manifest: stripe

The next step is deletion, not configuration. Remove the package, remove the checkout folder the agent added, and run the checker again. Green output means the tree still looks like a waitlist, not like a billing platform.

No-network smoke test

Generation often hides a paid call behind a helper with a friendly name. The smoke test keeps storage local and, where the OS allows it, blocks outbound network for the process.

# test_smoke.py — proposed local gate, not a measured production suite
import os
import sqlite3
from pathlib import Path

os.environ.setdefault("DATABASE_PATH", "./tmp-waitlist.db")
os.environ.setdefault("EXPORT_TOKEN", "test-token")


def test_sqlite_roundtrip(tmp_path, monkeypatch):
    db = tmp_path / "w.db"
    monkeypatch.setenv("DATABASE_PATH", str(db))
    conn = sqlite3.connect(db)
    conn.execute(
        "CREATE TABLE waitlist (email TEXT PRIMARY KEY, created_at TEXT NOT NULL)"
    )
    conn.execute("INSERT INTO waitlist VALUES ('[e-mail]', '2026-09-07')")
    conn.commit()
    row = conn.execute("SELECT email FROM waitlist").fetchone()
    assert row[0] == "[e-mail]"
    conn.close()


def test_spec_present():
    assert Path("slice.spec.json").exists()

Label any HTTP assertion as a sketch until the app exists. The sqlite roundtrip is the real gate. Storage stays on disk. The agent does not get to "just use Postgres".

A stricter Linux variant wraps the tests:

unshare -n python3 -m pytest test_smoke.py -q
python3 check_slice.py

If the suite needs the public internet, the slice is already too wide. Paid SaaS has crept in through a client that only fails after launch.

Numbered generation loop

1. Write slice.spec.json before any prompt. Freeze routes, storage, packages, and env keys in that file. Do not negotiate those limits inside a chat thread.
2. Paste the spec into the agent context as a hard contract. State that new packages, env keys, and route prefixes are defects, not improvements.
3. Generate only the waitlist loop. Landing copy, form POST, sqlite insert, duplicate 409, token-gated CSV. Stop there.
4. Run the checker and the smoke test. Delete files that exist only to satisfy an imagined future tenant.
5. Put the app on compute the founder already has at no extra invoice. Do not add a second vendor to "make it production".
6. Publish the URL. Collect emails. Ignore billing generation until the list is real.

The loop is meant to finish in one sitting. Scope that does not fit the spec waits for a later week. Shipping today is the point. A prettier admin is not.

Where a free coding server fits

Disclosure: This article was prepared as part of MonkeyCode's product outreach.

MonkeyCode fits this workflow when the founder wants free model access and a free server option for the generation step instead of standing up local inference hardware. The slice spec, the checker, and the smoke test stay the same. The host is interchangeable.

Free access does not remove the deny list. An unconstrained model will still invent checkout. The value is a zero-invoice coding box for a constrained loop, not a larger product surface. Founders who want to run the same loop on that free server can keep slice.spec.json as the source of truth.

Decision table

Pressure	Waitlist slice	Full SaaS scaffold
Same-day public URL	Fits	Rarely fits
Invoice on day one	None from this method	Likely from invented vendors
Auth	None, or a single export token	Often a full identity provider
Storage	sqlite or a JSON file	Postgres, Redis, object storage
Honest next step	Talk to the first fifty emails	Debug webhooks that nobody calls

Stay on the left column until the waitlist itself becomes the bottleneck. The table is a planning tool. It is not a claim about any vendor's uptime or token allotment.

Limits

The checker is string-based. A renamed import or a vendored SDK can slip through. Diff review still matters.

The slice is not a security audit. A CSV behind a static token is enough for a founder laptop. It is not enough for regulated personal data or a shared production cluster.

Free model access and a free server option are availability claims for getting started. They are not an SLA, a quota, or a permanence guarantee. Re-evaluate the host when the product outgrows a waitlist.

Generated landing copy can still be wrong when the stack is cheap. The method blocks paid architecture. It does not block a weak offer.

unshare -n is Linux-specific. macOS and Windows founders should rely on the package deny list and sqlite tests instead of network namespaces. String matching will not catch a hand-rolled HTTP client that posts to a paid API. That case needs a human reading the diff.

Who should not use this

Skip the waitlist slice if the product already charges money, stores medical or payment data, or needs multi-tenant isolation. Those cases need real vendors and a slower review.

Skip it if nobody will run the checker before push. A spec that never executes is commentary.

Skip it if the founder needs the agent to invent architecture from a blank page. This workflow assumes the architecture is already chosen: one process, local storage, no outbound SaaS.

Indie hackers who will accept a narrow loop can ship today. Everyone else should keep the checker idea and write a different spec.