web / API service

🏭 Prototype → MVP → Production live

Run a web/API product through 5 quality gates: idea → spec → prototype → MVP → hardening → production

▸ 01 Stage 1 · Idea → One-page spec live

Turn the idea into a testable one-page spec: problem, user, success metric, one runnable scope slice, explicit non-goals.

Gates

  • One-page spec exists: problem, target user, single success metric
  • Scope is cut to ONE runnable vertical slice (no 'and then everything')
  • Non-goals are written down and agreed with yourself
  • The slice has a definition of done you can check in a day

Catalog skills

Prompts

Prompt: 01-idea-to-spec~177 words

# Idea → One-page Spec

Turn the idea below into a one-page spec a single engineer can start tomorrow.

When to use

  • Stage 1 of any conveyor, before writing a single line of code
  • Any time the scope of an ongoing project quietly grows

Prompt

You are a product engineer. Convert the idea below into a one-page spec.
Rules:
- Cut scope aggressively: exactly ONE runnable vertical slice.
- No feature without a measurable success metric. Unmeasurable wishes go to Non-goals.
- The slice must have a Definition of Done checkable in one working day.
- Output exactly these sections, nothing else:
  1. Problem (2 sentences, who hurts and why)
  2. Target user (one persona)
  3. Success metric (one number with a deadline)
  4. The one slice (steps a user takes, first to last)
  5. Non-goals (at least 3 explicit rejections)
  6. Definition of done (checkbox list)

Idea: <PASTE YOUR IDEA>

Gate this satisfies

Stage 1 · gates 1-4: spec exists, scope cut to one slice, non-goals written, DoD checkable.

Artifacts

  • docs/spec.md (one page, versioned in the repo)
  • Repo skeleton with README stub

▸ 02 Stage 2 · Prototype (throwaway is allowed) live

One happy path runs locally end-to-end. Ugly code is fine; the point is to kill or confirm the idea, not to keep the code.

Gates

  • The happy path runs locally with one documented command
  • One end-to-end smoke test proves the slice works
  • A decision is recorded: continue, pivot, or kill
  • Nothing from the prototype is promised to anyone yet

Catalog skills

Prompts

Prompt: 02-skeleton-and-smoke~164 words

# Skeleton + One-command Smoke Test

Generate a throwaway prototype: the smallest project that runs the slice locally with one command and proves it with a smoke script.

When to use

  • Stage 2 of any conveyor: the prototype loop
  • Deciding whether an idea lives or dies before investing

Prompt

You are a pragmatic engineer. Create a THROWAWAY prototype (ugly code is fine) for the spec below.
Requirements:
- One command boots everything locally: `docker compose up` (or equivalent)
- One happy path works end-to-end
- A smoke script `scripts/smoke.sh` exits 0 when the slice works, 1 when it does not
- No auth, no polish, no extra features — the slice only
- A DECISION.md file: "continue / pivot / kill" plus the reason

Output: the full file tree with file contents, then the two commands to run.
Spec: <PASTE THE SPEC>

Gate this satisfies

Stage 2 · gates 1-3: one-command local run, E2E smoke, recorded decision.

Artifacts

  • docker-compose.yml that boots the slice
  • A smoke script with exit code 0/1

▸ 03 Stage 3 · MVP (deployed, tested, CI-gated) live

The slice becomes a deployed MVP: real data model, auth, CI pipeline, and a public URL a user can actually hit.

Gates

  • CI runs lint + tests + build on every push and blocks on red
  • Real data model with migrations (no hand-edited databases)
  • Auth exists; secrets are in a manager, not in code
  • A public URL serves the MVP behind HTTPS

Catalog skills

Prompts

Prompt: 03-mvp-cut-and-ci~170 words

# MVP Scope + CI Pipeline

Upgrade the prototype into a deployed MVP: real data model, auth, CI gates, public URL.

When to use

  • Stage 3 of any conveyor, when the prototype decision was "continue"
  • Any project that runs manually but should run in CI

Prompt

You are a senior engineer. Upgrade this prototype into an MVP with these gates:
1. Real data model with migrations (no hand-edited databases)
2. Auth: working session or token flow; secrets in a manager, never in code
3. CI pipeline on every push: lint -> tests -> build -> deploy; red blocks merge
4. A public HTTPS URL serving the MVP, plus a documented ROLLBACK command
Keep the prototype's scope. Add NOTHING that is not in the spec.
Output: a numbered task list (each task < 2h), the CI file, and the deploy config.
Prototype: <PASTE THE REPO TREE>

Gate this satisfies

Stage 3 · gates 1-4: CI blocks red, migrations, auth + managed secrets, public URL.

Artifacts

  • CI pipeline file (build → test → deploy)
  • Deployed MVP URL + rollback command

▸ 04 Stage 4 · Hardening (security, observability, backups) live

Assume the MVP is now worth attacking and worth losing: close OWASP basics, add metrics/logs/alerts, and prove backups restore.

Gates

  • OWASP top-10 checklist reviewed; auth and input validation hardened
  • Metrics, logs and one alert per error class are collected
  • A backup restore has been performed from zero, not assumed
  • A load test result is recorded against an SLO target

Catalog skills

Prompts

Prompt: 04-security-and-observability~145 words

# Hardening: Security + Observability + Backups

Assume the MVP is now worth attacking and worth losing. Produce the hardening plan.

When to use

  • Stage 4 of any conveyor, right after the MVP is public

Prompt

You are an SRE/security engineer. Harden this MVP:
1. OWASP top-10 checklist against the actual stack; top 5 risks with fixes
2. Input validation and auth hardening (rate limits, session policy)
3. Observability: exactly 4 golden metrics, structured logs, one alert per error class
4. Backups: schedule + a restore drill plan that starts from zero
5. A load test against the SLO target (name the tool and the target)
Output: checklist ordered by risk, each item < 1h of work.
MVP stack: <PASTE THE STACK>

Gate this satisfies

Stage 4 · gates 1-4: OWASP reviewed, metrics/logs/alerts, restore drill, load test vs SLO.

Artifacts

  • Observability stack files (metrics/logs/alerts)
  • Backup + restore script with a recorded restore drill

▸ 05 Stage 5 · Production (GitOps, canary, SLO, on-call) live

The product is operated, not just hosted: declarative delivery, progressive rollout with automatic rollback, an SLO with error budget, and a runbook you can follow at 3 AM.

Gates

  • Delivery is declarative: the cluster state matches the repo (GitOps)
  • A canary rollout with automatic rollback has survived a drill
  • An SLO with an error budget is published and alerting
  • A 3 AM runbook exists and has been followed once

Catalog skills

Prompts

Prompt: 05-gitops-canary-slo~143 words

# GitOps Delivery + Canary + SLO

Turn "hosted" into "operated": declarative delivery, progressive rollout, an SLO with an error budget, and a 3 AM runbook.

When to use

  • Stage 5 of any conveyor, when the MVP is stable under load

Prompt

You are a platform engineer. Make this MVP operable:
1. GitOps: repo structure (ApplicationSet) driving the cluster; cluster state == repo state
2. Canary: progressive rollout with automatic rollback on error-metric regression; include a rollback drill
3. SLO: one user-facing SLI, target, error budget, and the burn-rate alert
4. Runbook: a 3 AM checklist (symptom -> diagnosis command -> action -> verification), tested once
Output: repo tree, rollout manifest, SLO definition, runbook.
Stack: <PASTE THE STACK AND CLUSTER>

Gate this satisfies

Stage 5 · gates 1-4: GitOps state, canary drill, SLO + budget, tested runbook.

Artifacts

  • GitOps repo (ApplicationSet) driving the cluster
  • SLO dashboard + 3 AM runbook

Source: conveyors/prototype-to-production.json · prompts