Build your first app in 5 minutes.
Human is a single Go binary. Install it, add it to your PATH, and verify.
$ go install github.com/barun-bash/human/cmd/human@v0.4.2 $ export PATH="$PATH:$(go env GOPATH)/bin" $ human version
Go 1.25+ is required. Get it from go.dev/dl. To make the PATH change permanent, add the export line to your ~/.zshrc (macOS) or ~/.bashrc (Linux).
Create a file called app.human with the following content. This is a complete, buildable application — an app declaration, one data model, one page, and a build block.
app TaskFlow is a web application data Task: has a title which is text has a status which is either "pending" or "done" has a due date page Dashboard: show a list of tasks sorted by due date each task shows its title, status, and due date clicking a task toggles its status there is a form to create a Task build with: frontend using React with TypeScript backend using Node with Express database using PostgreSQL
This 15-line file declares a web app called TaskFlow with a Task model (three fields), a Dashboard page that lists and creates tasks, and a build target of React + Node + PostgreSQL. That is enough for the compiler to generate a full-stack project.
Run human check to validate your file, then human build to compile it into a full project.
$ human check app.human Checking app.human... Parsed: 1 app, 1 data, 1 page, 0 apis Validation passed. 0 errors, 0 warnings. $ human build app.human Building TaskFlow... Frontend: React + TypeScript 7 files Backend: Node + Express 8 files Database: PostgreSQL 2 files Docker: Dockerfile + Compose 5 files Quality: Tests + Reports 11 files Scaffold: Config + Scripts 7 files Build complete. 40+ files generated in .human/output/
The compiler parsed your English, built an intermediate representation (Intent IR), ran semantic analysis, and then passed that IR through 10+ code generators. Each generator reads the same IR and produces framework-specific output. The result is a complete, deployable project — from a 15-line input.
Look inside the .human/output/ directory. Here is what the compiler produced from your 15-line file.
.human/output/ frontend/ # React + TypeScript src/ types.ts # TypeScript interfaces from your data models api-client.ts # Typed API client with fetch calls pages/ # Dashboard.tsx with state, handlers, rendering components/ # Reusable UI components App.tsx # Router and app shell backend/ # Node + Express server.ts # Express server with middleware routes/ # Route handlers with validation models/ # Prisma schema from your data declarations auth/ # Authentication middleware database/ # PostgreSQL migration.sql # CREATE TABLE statements seed.sql # Sample data infra/ # Docker + CI/CD Dockerfile # Multi-stage builds docker-compose.yml .github/ # GitHub Actions workflows quality/ # Tests + Reports *.test.ts # Unit tests for every component and route security-report.md security-tests.sh # Runtime security probes (curl-based) build-report.md
Every directory is a real, working part of your application. The frontend has proper TypeScript types derived from your data model. The backend has validated route handlers. The database has migration SQL. The quality directory has tests that actually run. You can cd .human/output && bash start.sh to launch it.
Now let's make it real. Add a User data model with an encrypted password and a relationship to Task. Insert this between the app declaration and the Task model.
data User: has a name which is text has an email which is unique email has a password which is encrypted text has many Task
Then add a relationship line to the Task model:
data Task: belongs to a User # new line has a title which is text has a status which is either "pending" or "done" has a due date
The unique modifier on email creates a database constraint. The encrypted modifier on password means the compiler generates bcrypt hashing — passwords are never stored in plain text. The has many / belongs to pair creates a foreign key relationship. The compiler generates migrations, ORM models, and TypeScript types for both entities.
Add a backend endpoint that creates tasks with validation. Insert this after the page declaration.
api CreateTask: requires authentication accepts title and due date check that title is not empty check that due date is in the future create a Task for the current user respond with the created task
The compiler generates a POST route handler with input validation, authentication middleware, a database insert, and a JSON response. Each check that becomes a validation rule that returns a clear 400 error on failure. The requires authentication line adds JWT middleware to this endpoint automatically.
Your API requires authentication, so you need to declare how authentication works. Add this after the API declaration.
authentication:
method JWT tokens that expire in 7 days
passwords are hashed with bcryptTwo lines. The compiler generates JWT token creation, verification middleware, token refresh logic, and bcrypt password hashing with secure defaults. If you had declared requires authentication on an API without this block, the compiler would fail with a helpful error telling you exactly what to add.
Rebuild to see the expanded output. Then use the CLI tools to explore what you've built.
$ human build app.human Building TaskFlow... Frontend: React + TypeScript 7 files Backend: Node + Express 13 files Database: PostgreSQL 2 files Docker: Dockerfile + Compose 5 files Quality: Tests + Reports 11 files Scaffold: Config + Scripts 7 files Build complete. 45+ files generated in .human/output/
Try the built-in tools:
# Explain any concept $ human explain authentication # Shows: JWT, bcrypt, OAuth patterns with examples # Auto-fix common issues $ human fix app.human # Import from OpenAPI spec $ human import openapi spec.json # Git workflow $ human feature user-auth $ human feature finish # Launch the interactive REPL $ human human> /open app.human human> /build human> /explain data human> /exit
human explain is a built-in reference for any language concept. human fix auto-corrects common issues. The REPL is an interactive environment with 30+ commands, tab completion, and command history — you can edit, build, and explore without leaving it. See the CLI Guide for the full command reference.
Here is the complete file you've built through this tutorial. This single file produces a full-stack, tested, deployable task manager.
app TaskFlow is a web application data User: has a name which is text has an email which is unique email has a password which is encrypted text has many Task data Task: belongs to a User has a title which is text has a status which is either "pending" or "done" has a due date page Dashboard: show a list of tasks sorted by due date each task shows its title, status, and due date clicking a task toggles its status there is a form to create a Task api CreateTask: requires authentication accepts title and due date check that title is not empty check that due date is in the future create a Task for the current user respond with the created task authentication: method JWT tokens that expire in 7 days passwords are hashed with bcrypt build with: frontend using React with TypeScript backend using Node with Express database using PostgreSQL deploy to Docker
$ human build app.human # Compile to full-stack project $ cd .human/output && bash start.sh # Run it
You've built a full-stack app. Here is where to go from here.