# ToGO: Laravel's Artisan Workflow for Go + React, From togo new to Deploy

> One command writes the Go model, SQL, migration, GraphQL, REST and React page. A hands-on tour of ToGO: install, scaffold, generate, plugins, AI agents and deploy.

*2026-10-12T11:06:26Z*

I spent years in Laravel before moving most of my backend work to Go. Go gave me speed, types and simple deploys. What I missed was the workflow: `php artisan make:model`, migrations that just work, and one command that adds a whole feature end to end.

ToGO is what I built to get that workflow back. It's an open-source, API-first framework for Go on the backend and React on the frontend, with an artisan-style CLI that generates every layer of a feature at once. This post walks through it, from an empty folder to a deployed app.

## The idea in one command

```bash
togo make:resource Post title:string body:text:nullable published:bool
```

That one line writes the Go model, the SQL schema and queries (for sqlc), the Atlas migration schema, the GraphQL schema, a REST handler (Huma, with OpenAPI) and the React page with its API client. A manifest, `togo.resources.yaml`, is the source of truth, and the registries that wire routes and resolvers are regenerated from it, so the layers can't drift apart.

## 1. Install the CLI

```bash
curl -fsSL https://to-go.dev/install.sh | sh                  # Linux and macOS
irm https://to-go.dev/install.ps1 | iex                        # Windows
go install github.com/togo-framework/cli/cmd/togo@latest       # or with Go
```

The CLI upgrades itself with `togo upgrade`. `togo new` and the generators install any missing tools (Go, Node, sqlc, Atlas), and `togo doctor` checks or repairs them at any time.

## 2. Scaffold an app

```bash
togo new shop
```

The CLI asks for the frontend, the database and the features you want, such as auth, queue and storage. SQLite is the default today, so your first app doesn't need Docker. Postgres, Supabase, MySQL and MongoDB are one choice away (but read the Postgres note under "Honest limits" first). You get one repo with the Go API, the React UI, migrations and infra together.

## 3. Add a resource and run it

```bash
cd shop
togo make:resource Product name:string price:decimal in_stock:bool
togo generate      # sqlc → gqlgen → Atlas → OpenAPI
togo migrate
togo serve
```

The API runs on `:8080`, with GraphQL at `/graphql`, REST at `/api` and the OpenAPI docs at `/docs`. The web app runs on `:3000`.

Field types are `string, text, int, bool, float, decimal, uuid, time, date, json`, and `:nullable` makes a field optional. `--dry-run` previews what a generator will write. The model file is yours to edit, while the generated registries are rebuilt every time.

## 4. Everything else is a plugin

The core is a thin microkernel. Auth, dashboards, cache, queues, payments, analytics, audit logs, AI and more are plugins, and the marketplace lists more than 130 of them:

```bash
togo install togo-framework/auth
togo plugin:list
```

`togo install` runs `go get`, registers the plugin for auto-discovery and records it in `togo.yaml`. On the next `togo serve`, the kernel boots it. Writing your own plugin means implementing a small Go interface and registering it in `init()`.

## 5. Built for AI agents from day one

Every new app ships with a `.claude/` folder and a pre-wired MCP server, so Claude Code can drive the project. Two more pieces help:

- `togo install claude` adds the ToGO Claude Code plugin: `/togo:*` commands that wrap the CLI, a team of specialist agents (backend, frontend, database, devops, QA, security and more) and an auto-connected MCP.
- The public MCP server at [mcp.to-go.dev](https://mcp.to-go.dev) serves the docs and the plugin registry, so an agent can learn the framework and install plugins without you relaying answers. It's listed in the official MCP Registry.

The `web-mcp` plugin goes the other way: it turns *your* app into an authenticated MCP server, so Claude, Cursor or any MCP client can use your app's tools.

## 6. Deploy

For your own server, `togo deploy` builds locally, uploads the artifact with rsync and runs your restart command over SSH, configured in `togo.yaml` (with named targets for staging and production). For the cloud, `togo infra:init` writes a Dockerfile plus Terraform for Google Cloud Run, Fly.io or Docker, and `togo deploy` applies it.

## Honest limits

- **It's young.** ToGO is on 0.x versions and still changing fast, so expect breaking changes between minor releases. Pin your versions.
- **Postgres DDL is a known issue.** SQLite is the default today. If you pick Postgres, the resource generator still writes SQLite-flavoured `.sql` (the Atlas HCL is correct), so expect to fix that file by hand for now. Postgres DDL generation is being fixed. If you hit it, I'd like the issue.
- **The community is small.** Today you'll find more answers about Gin, Echo or Fiber. ToGO is a framework, not a router, so it's closer to "Laravel for Go" than to those, but that also means more opinions.
- **The toolchain has moving parts:** sqlc, Atlas, gqlgen and Node. The CLI installs them for you, but they're there.

I use ToGO for my own work. It runs the backend of the CMS behind this site and my other sites, and I build client products on it.

## Try it

- [Read the docs](/en/docs) · [browse the plugins](/en/plugins)
- [See the demo](https://demo.to-go.dev)
- [Star ToGO on GitHub](https://github.com/togo-framework/togo)

Building a product on Go and React and want help? I design and build products end to end. See [product engineering](https://fadymondy.com/en/services/product-engineering?utm_source=togo&utm_medium=referral&utm_campaign=togo-launch-oct26) or [get in touch](https://fadymondy.com/en/contact?utm_source=togo&utm_medium=referral&utm_campaign=togo-launch-oct26).

---

Source: https://to-go.dev/en/blog/togo-go-react-framework-artisan-cli