An AI-native software factory for cloud-hosted Go + SolidJS apps.

Production harness — plans, module specs, 45 Cursor rules, drift CI, integration test harness — plus a runnable starter app and GCP deploy scripts.

Live example: golid.ai — marketing site built with this factory; clone the repo for the harness and template app.

Factory · Quick Start · Fork · Why Golid · Deploy · Docs

Agents and humans share the same production contract — not prompt memory, not ad-hoc CI.

1. Classify & plan — workflow-routing picks risk tier (T0–T3). Write slices in docs/plans/ under planning-standards guardrails: verify schema and file claims against migrations and source; acceptance criteria per slice. New modules: plan-feature. Calibration: golden-slices.

2. Execute slices — slice-and-ship per slice: implement → test → spec/OpenAPI sync → audit-bugs pre-merge gate → commit. For multi-slice plans, invoke plan-execution-loop to orchestrate subagents: implement → audit (≥90/100) → fix → re-audit before the next slice. Archive completed plans under docs/plans/archive/.

vs blank repo + AI: OpenAPI + module specs + drift CI (not prompt memory) · planning-standards → slice-and-ship / plan-execution-loop · path-filtered CI + E2E + Codecov 80% gate · make rename rebrands the whole factory.

Full map: Organism Pattern · Plans · routing eval

Starter modules the factory extends — use make new-module or follow example-module.md.

Also included: OpenAPI 3.1 + TypeScript codegen, sqlc queries, golang-migrate (with down migrations), CSRF + dual-tier rate limiting, scaffold generator, domain-safe rename tool, GCP deploy/teardown scripts.

Prerequisites: Docker 24+, Node.js 24+, Go 1.26+

git clone https://github.com/golid-ai/golid.git my-project && cd my-project
# Open in VS Code/Cursor → "Reopen in Container"

Migrations and seed data run automatically (entrypoint.dev.sh). Backend starts on 8080. Frontend starts as a VS Code task — open the Terminal tab and wait until the frontend dev server prints its local URL before opening http://localhost:3000.

git clone https://github.com/golid-ai/golid.git my-project && cd my-project
make setup

# First run only — migrate + seed the dev database
export DATABASE_URL=postgres://dev:dev@localhost:5432/golid?sslmode=disable
make migrate-up seed

docker compose up          # DB + backend on :8080
cd frontend && npm run dev # frontend on :3000

Test accounts (after seed): admin@example.com / Password123! (admin) · user@example.com / Password123! (user)

Guides: Quick Start · Start Here · Forking? make rename · Upgrading? CHANGELOG (0.3.x breaking changes in 0.3.0)

golid/
├── backend/
│   ├── cmd/server/main.go       # Bootstrap, shutdown, background jobs
│   ├── internal/
│   │   ├── wire/                # BuildServices, BuildHandlers, RegisterRoutes
│   │   ├── service/             # Business logic (auth, user, feature, sse, email)
│   │   ├── handler/             # HTTP handlers
│   │   ├── middleware/          # JWT, CSRF, rate limiting, security
│   │   ├── pagination/          # Query normalization
│   │   ├── retry/               # Exponential backoff for fire-and-forget
│   │   └── apperror/            # Typed error responses
│   ├── migrations/              # SQL migration pairs (up + down)
│   ├── openapi.yaml             # REST API contract (OpenAPI 3.1)
│   └── seeds/                   # Development seed data
├── frontend/
│   └── src/
│       ├── components/          # 70+ components (atoms/molecules/organisms)
│       ├── lib/                 # api.ts, auth.ts, constants, validation
│       └── routes/
│           ├── (public)/        # login, signup, forgot-password, verify-email
│           └── (private)/       # dashboard, settings, component showcase
├── docs/
│   ├── modules/                 # Auth, users, feature specs (+ drift CI)
│   ├── plans/                   # Feature plans (active + archive/)
│   ├── architecture.md          # Layers, auth, SSE, wire
│   └── patterns/                # Stack quick references (Go, SolidJS, …)
├── .cursor/rules/               # 45 AI coding rules
├── config/                      # Environment files
├── scripts/                     # Deploy, drift checks, init-test-db, teardown
└── infra/                       # Cloud Run, Cloud Build configs

# First run: make setup && migrate-up seed (see Quick Start)
make dev                           # DB + backend (docker compose up)
cd frontend && npm run dev         # Frontend dev server (port 3000)
make test                          # Backend + frontend unit tests
make check                         # lint + test + build (local CI parity)

export TEST_DATABASE_URL='postgres://dev:dev@localhost:5432/golid_test?sslmode=disable'
scripts/init-test-db.sh
cd backend && TEST_MIGRATIONS_PATH="$(pwd)/migrations" \
  go test -tags integration ./internal/handler/... ./internal/service/... -race
make new-module name=notes         # Scaffold CRUD module
make rename name=myapp module=github.com/user/myapp/backend domain=myapp.com
make help                          # All Makefile targets

./scripts/deploy.sh                # Deploy to QA (Cloud Run)
./scripts/deploy.sh check          # Validate config before deploy

Integration test setup: CLI Reference (init-test-db.sh, TEST_DATABASE_URL).

Opt-in complexity: docker compose up works with zero Redis, Mailgun, or OTEL. Set one env var per module when you need it — see Opt-In Modules below.

docker compose --profile production up adds Redis + worker (see CHANGELOG).

Handlers → Middleware → Services → PostgreSQL. Wiring lives in internal/wire/ (BuildServices, BuildHandlers, RegisterRoutes); business logic in internal/service/<pkg>/. Frontend uses SolidStart SSR with file-based routing.

API surface today: /api/v1 (versioning middleware + migration path in api-versioning.md).

Full breakdown: architecture.md — auth flow, SSE ticket exchange, shutdown order, observability.

git clone https://github.com/YOUR_USER/my-app.git && cd my-app
make rename name=myapp module=github.com/YOUR_USER/my-app/backend domain=myapp.com
git diff && make check

The rename tool updates 20+ file categories (imports, Docker, CI, Cursor rules, branding, OpenAPI) with domain-safe replacements. Details: cmd/rename.

./scripts/deploy.sh              # QA (default)
./scripts/deploy.sh prod         # Production (confirmation gate)
./scripts/deploy.sh qa api       # Backend only
./scripts/teardown.sh            # Teardown QA resources

scripts/README.md · deployment-options.md (Fly.io, Railway, Render, bare metal)

Cursor rules: 45 rules in .cursor/rules/ — full index in cursor-rules.md. Factory workflow: workflow-routing → planning-standards → slice-and-ship / plan-execution-loop; pre-merge audit-bugs before declaring slices done. Split examples: solidjs-pages + solidjs-data-fetching, go-service + go-service-errors.

MIT. Some frontend dependencies (AG Grid Community, Observable Plot, Three.js) have their own licenses — review frontend/package.json before commercial use.

Docker or DevContainer won't start? Docker Desktop → Troubleshoot → Clean / Purge data, then retry.

See CONTRIBUTING.md.