Development Roadmap

Build the first programming language designed for humans, not computers.

52-week plan across 14 phases.

Originally planned as 52 weeks. Phases 1–12 completed in 4 days with AI-assisted multi-agent development.

1
Weeks 1 - 4

Foundation Complete

Parse a .human file and prove the grammar works.

Week 1-2: Lexer + Token System
  • Define all token types
  • Build lexer that tokenizes .human files
  • Handle indentation-based scoping
  • Handle section headers (—— name ——)
  • Handle strings, numbers, identifiers
  • Handle keywords (case-insensitive)
  • Handle comments (#)
  • Write comprehensive lexer tests
  • Test with sample .human files
Week 3-4: Parser + AST
  • Define all AST node types
  • Build recursive descent parser
  • Parse: app declaration
  • Parse: data declarations (fields, types, relationships)
  • Parse: page declarations (display, interaction, conditions)
  • Parse: api declarations (input, validation, logic, response)
  • Parse: theme declaration
  • Parse: security declaration
  • Parse: database declaration
  • Error recovery (skip to next declaration on error)
  • Human-readable error messages
  • Write comprehensive parser tests
Can parse a complete .human file into an AST
2
Weeks 5 - 6

Intent IR Complete

Transform AST into framework-agnostic representation.

  • Define IR node types (Application, Data, Page, API, etc.)
  • Build AST → IR transformer
  • Serialize IR to YAML
  • Serialize IR to JSON
  • Deserialize IR from YAML/JSON
  • Validate IR completeness (every reference resolves)
  • Write IR tests
  • Document IR schema
.human file → AST → Intent IR (YAML) works end-to-end
3
Weeks 7 - 10

First Code Generator — React + TypeScript Complete

Generate a working React project from Intent IR.

Week 7-8: Project Scaffolding
  • Generate package.json with correct dependencies
  • Generate tsconfig.json
  • Generate project structure (src/, pages/, components/, etc.)
  • Generate routing from page declarations
  • Generate data types from data declarations
  • Generate theme/styling from theme declaration (Tailwind)
Week 9-10: Component + Page Generation
  • Generate React components from component declarations
  • Generate pages from page declarations
  • Generate data fetching (hooks, API calls)
  • Generate forms from input statements
  • Generate lists, cards, tables from display statements
  • Generate event handlers from interaction statements
  • Generate conditional rendering from condition statements
  • Generate loading and error states
.human file → React + TypeScript project (7 files generated)
4
Weeks 11 - 14

First Backend Generator — Node + Express Complete

Generate a working backend from Intent IR.

  • Generate Express server setup
  • Generate API routes from api declarations
  • Generate input validation from check statements
  • Generate data models (Prisma)
  • Generate database migrations (PostgreSQL)
  • Generate authentication middleware (JWT)
  • Generate authorization middleware (from policies)
  • Generate error handling
  • Connect frontend to backend (API client generation)
Full-stack app from .human files (13 backend files generated)
5
Weeks 15 - 18

Quality Engine Complete

Mandatory quality guarantees.

Week 15-16: Auto Test Generation
  • Generate unit tests for every API (Jest/Vitest)
  • Generate unit tests for every component (React Testing Library)
  • Generate edge case tests from field types
  • Generate integration tests for API flows
  • Auto-execute generated tests
  • Coverage tracking and threshold enforcement
Week 17: Security Audit
  • Dependency vulnerability scanning
  • Input sanitization verification
  • Auth/authz coverage check
  • Secret detection in generated code
  • Security report generation (security-report.md)
  • Live security scanning (stretch goal)
Week 18: Code Quality + QA Trail
  • Linting of generated code (ESLint config)
  • Lint report generation (lint-report.md)
  • Build report generation (build-report.md)
  • Duplication detection
  • Performance pattern detection
  • QA test plan generation
  • Traceability matrix generation
Nothing builds without passing all quality checks
6
Weeks 19 - 20

CLI + Developer Experience Complete

Polished command-line interface.

  • human init — interactive project creation
  • human build — compile to target
  • human run — development server
  • human check — validate .human files
  • human test — run generated tests
  • human audit — run security audit
  • human deploy — deploy to target (Docker, Terraform/AWS/GCP)
  • human eject — export as standalone project
  • Colored terminal output with 6 themes
  • Progress indicators (spinners, progress boxes)
  • Watch mode (human build --watch)
  • Interactive REPL with 38 commands
  • Readline with tab completion and command history
  • AI-assisted commands (/ask, /edit, /suggest)
  • Self-update via GitHub releases (/update)
  • Build metadata embedding via ldflags
Complete developer experience from init to deploy, plus interactive REPL
7
Weeks 21 - 24

Design Import Complete

Figma and image files as input.

  • Figma component classifier (4-tier heuristics)
  • Data model inference from design
  • Human code generator from design
  • LLM prompt for Figma interpretation
  • Figma API JSON parser (real API integration)
  • CLI human design command
  • Image analysis for screenshots/JPEGs (LLM vision)
  • Style extraction (colors, fonts, spacing)
  • Asset extraction (images, icons)
  • Component map caching (deterministic after first import)
Figma file + English → working React components
8
Weeks 25 - 26

Multi-Framework Output Complete

Prove the IR is truly framework-agnostic.

  • Vue 3 + TypeScript code generator (pages, components, router, Pinia stores)
  • Angular 17+ standalone code generator (components, services, routing, signals)
  • Svelte 5 + SvelteKit code generator (pages, components, stores)
  • Python (FastAPI) backend generator (SQLAlchemy, Alembic, auth)
  • Go (Gin) backend generator (GORM, handlers, auth middleware)
  • Same .human file targets all 4 frontend + 3 backend frameworks
  • Storybook 8 story generation with relational mock data
  • Document how to build a code generator plugin
One .human source → 4 frontend + 3 backend framework outputs
9
Weeks 27 - 30

DevOps Generation Complete

CI/CD, Docker, deployment from English.

  • Generate GitHub Actions workflows from pipeline declarations
  • Generate framework-aware Dockerfiles and docker-compose
  • Generate Terraform for cloud deployment (AWS ECS/RDS, GCP Cloud Run/SQL)
  • Generate environment configurations (.env.example, .dockerignore)
  • Project scaffolder (package.json workspaces, tsconfigs, vite config, README, start.sh)
  • Monitoring configuration (Prometheus rules + Grafana dashboards)
  • Git workflow commands (human feature, human release, etc.)
Complete application lifecycle from .human files
10
Weeks 31 - 34

Architecture Support Complete

Monolith, microservices, serverless from one keyword.

  • Monolith output (single project)
  • Microservices output (multi-service Docker Compose, gateway)
  • Serverless output (Terraform Lambda/Cloud Functions)
  • Event-driven output (with message broker config)
  • Service-to-service communication generation
Architecture as a first-class language feature
11
Weeks 35 - 38

LLM Connector Complete

Optional AI enhancement.

  • LLM connector interface (provider-agnostic)
  • Anthropic Claude integration
  • OpenAI integration
  • Ollama (local) integration
  • MCP server with 6 tools (human_build, human_validate, human_ir, human_examples, human_spec, human_read_file)
  • LLM system prompt for .human generation
  • Smart interpretation (freeform → structured .human)
  • Conversational editing mode
  • Pattern suggestions
AI-enhanced editing while maintaining deterministic compilation
12
Weeks 39 - 42

Third-Party Integrations Complete

First-class integration support.

  • Integration declaration parser (integrate with X: syntax)
  • Built-in: Stripe (payments, refunds)
  • Built-in: SendGrid / email (transactional emails)
  • Built-in: AWS S3 / file storage
  • Built-in: OAuth providers (Google, GitHub)
  • Built-in: Slack (messaging, notifications)
  • Typed service files, env vars, and dependencies per integration
  • OpenAPI/Swagger spec import
  • Integration test generation (mocked)
Third-party APIs usable in English
13
Weeks 43 - 46

Plugin Ecosystem Started

Community can extend the language.

  • Plugin interface specification
  • Plugin loading system
  • Plugin discovery and installation
  • Plugin template / generator
  • Documentation for plugin authors
  • First community plugin examples
Open ecosystem for new targets and integrations
14
Weeks 47 - 52

Polish + Launch In Progress

Ready for public release.

  • Project website (6 pages: landing, getting started, language spec, roadmap, manifesto, contributing)
  • Tutorial: “Build your first app in Human”
  • 13 example applications (taskflow, blog, ecommerce, saas, api-only, test-app, recipes, projects, events, fitness, inventory, figma-demo, timekeeper-signin)
  • Performance optimization
  • Semantic error messages with codes and fix suggestions (17 errors, 10 warnings)
  • Installation scripts (install.sh, Homebrew formula, GoReleaser cross-platform binaries)
  • VS Code extension (syntax highlighting, snippets, bracket matching)
  • Landing page and branding
  • Open source release on GitHub
  • Language specification derived from compiler source
  • LLM system prompt for .human file generation
v1.0 public launch

Current Output

Running human build app.human produces 100+ files across 16 generators:

Generator Files Output
React / Vue / Angular / Svelte 7-12 Types, API client, pages, components, router, entry files
Node / Python / Go Backend 8-13 ORM schema, auth middleware, route handlers, server, error handling
Docker + Compose 5-7 Dockerfiles (frontend + backend), docker-compose.yml, .env.example, .dockerignore, start.sh
PostgreSQL 2 Migration SQL, seed data
Terraform 3-5 AWS ECS/RDS or GCP Cloud Run/SQL, variables, outputs
CI/CD 1-2 GitHub Actions workflows
Monitoring 3-4 Prometheus config, Grafana dashboard, metrics endpoint
Storybook 3-5 Story files, preview config, main config
Design Systems 2-3 Theme config, CSS variables, provider wrapper
Quality Engine 11 Test files, security-report.md, lint-report.md, build-report.md, qa-test-plan.md, traceability-matrix.md, performance-report.md
Scaffold 7 package.json files, tsconfigs, vite config, README, start.sh

Success Metrics

Metric Target Status
Parse a .human file Phase 1 Done
Framework-agnostic IR Phase 2 Done
Generate a running React app Phase 3 Done
Full-stack app from English Phase 4 Done
Quality guarantees enforced Phase 5 Done
CLI developer experience Phase 6 Done
Design-to-code pipeline Phase 7 Done
Multi-framework output (4 frontend + 3 backend) Phase 8 Done
DevOps generation (Docker, CI/CD, Terraform) Phase 9 Done
Architecture support (monolith, microservices, serverless) Phase 10 Done
LLM connector (Anthropic, OpenAI, Ollama) Phase 11 Done
Third-party integrations (Stripe, SendGrid, S3, OAuth, Slack) Phase 12 Done
Plugin ecosystem Phase 13 Started
Public launch Phase 14 In Progress

Principles Throughout

  1. 1
    Every phase produces something that works. No phase is “just infrastructure.”
  2. 2
    Test everything. The compiler for a quality-enforced language must itself be well-tested.
  3. 3
    Error messages are a feature. Every error helps the developer fix the problem.
  4. 4
    Determinism is sacred. Same input, same output, always.
  5. 5
    Ship examples. Every feature comes with a .human example that demonstrates it.