The System

ASDO — Autonomous Software Development Organization

Autonomous software development with AI agents

→ 🚀 Quick Start Guide | Get building in 2 minutes

Build production-ready software with 19 specialized AI agents across 5 departments, all working under your strategic guidance.

🛠️ Capabilities & Technology Support

Architecture Patterns

Build Speeds

Key Technology Support

📋 Complete Technology Stack

Frontend Technologies

Next.js 14+ (App Router, TypeScript, Tailwind CSS)
React 18+ (Vite, TypeScript, Component libraries)
Vue 3+ (Nuxt, Composition API, TypeScript)
SvelteKit (TypeScript, Reactive patterns)

Backend Technologies

Next.js API Routes (TypeScript, Middleware, CORS)
FastAPI (Python, Async, Auto-documentation)
Express.js (Node.js, TypeScript, RESTful)
NestJS (Enterprise, Decorators, Dependency injection)
Django (Python, Batteries-included, Admin panel)

Database Support

PostgreSQL (Prisma ORM, ACID compliance, JSON support)
MySQL (PlanetScale, Branching, Connection pooling)
SQLite (Drizzle ORM, Embedded, File-based)
Supabase (PostgreSQL + Auth + Real-time)
MongoDB (NoSQL, Flexible schema, Aggregations)

Authentication

NextAuth.js (OAuth providers, Session management, JWT)
Clerk (Managed auth, Drop-in UI, Organizations)
Lucia (Type-safe, Lightweight, Custom sessions)
Firebase Auth (Google ecosystem, Mobile integration)

Deployment Platforms

Vercel (Frontend, Edge functions, Global CDN)
Railway (Backend, Databases, Environment management)
Fly.io (Global deployment, Docker, Persistent volumes)
Netlify (JAMstack, Build plugins, Form handling)
Cloudflare Pages (Edge computing, Workers, Analytics)
Render (Full-stack, Background jobs, Cron jobs)

Infrastructure & DevOps

Terraform (Infrastructure as Code, Multi-cloud, State management)
GitHub Actions (CI/CD, Automated testing, Deployments)
Docker (Containerization, Multi-stage builds, Compose)
Monitoring (Observability, Alerting, Performance tracking)

🚀 What is The System?

The System is an agentic framework that simulates a complete software development organization. It orchestrates 19 specialized AI agents across 5 departments to take your idea from concept to production—with you as the founder making key decisions at human-in-the-loop (HITL) gates.

The Complete Software Company

💡 Your Idea
     ↓
🏢 The System (ASDO)
     ├── 📐 Architecture Department → System design & technical decisions
     ├── 📦 Product Department → MVP definition & business strategy
     ├── 💻 Development Department → Implementation & quality assurance
     ├── 🚀 Release Department → Documentation, security & deployment
     └── 🌐 Operations Department → Monitoring & live operations
     ↓
🚀 Production-Ready Software

Why Choose The System?

Traditional Development	The System (ASDO)
You write all the code	Agents write code, you review and approve
Context switching between tasks	Specialized agents handle each domain expertly
Forgetting architectural decisions	Decisions documented in ADRs and project files
Inconsistent code quality	QA engineer reviews every component systematically
Manual deployment setup	DevOps agent generates Infrastructure as Code
You make every micro-decision	You make strategic decisions at HITL gates

⚡ Quick Start

🎯 Fastest Way: Use GitHub Template (2 minutes)

Recommended for new users - Get a complete AI development team instantly

Click "Use this template" at the top of this repository
Name your new repository and create it
Clone and start building:

# Clone your new repository
git clone https://github.com/YOUR_USERNAME/YOUR_REPOSITORY_NAME.git
cd YOUR_REPOSITORY_NAME

# Verify installation
./scripts/verify-the-system.sh

# Start Claude Code and create your first project
claude
> /ts-new-project my-blog
> "Simple blog website with posts and comments"

# Let AI build it autonomously
> /ts-turbo my-blog "blog with posts, comments, and basic admin"

Result: Complete production app in ~15-20 minutes with frontend, backend, database, tests, and docs!

🔧 Alternative: Submodule Installation

Click to expand submodule installation method

Prerequisites:

Claude Code - AI development environment
Git and Node.js 18+

# Create your project directory
mkdir my-project && cd my-project
git init

# Add The System as a submodule
git submodule add https://github.com/vedanta/the-system.git .the-system
git submodule update --init --recursive

# Create symbolic links
ln -s .the-system/.claude .claude
ln -s .the-system/CLAUDE.md CLAUDE.md

# Create essential directories
mkdir -p input output

# Verify installation
.the-system/scripts/verify-the-system.sh
git add . && git commit -m "Add The System framework"

# Launch Claude Code and start building
claude
> /ts-new-project my-app
> /ts-approve architecture-start

🚀 What You Get

After setup, you have 19 AI agents ready to build complete applications:

🏗️ Architecture - System design and tech selection
📦 Product - MVP planning and user stories
💻 Development - Full-stack coding with tests
🚀 Release - Documentation, CI/CD, and deployment
🌐 Go Live - Production deployment to 13+ platforms

Next: Try the 5-minute tutorial below!

⚡ Build Presets - Configure Speed vs Quality

Configure the balance of speed vs. quality for your project needs:

Three Build Modes

# 🚀 PROTOTYPE (3-5 min) - Fast iteration, demos, proof-of-concepts
/ts-turbo demo-app "simple todo app prototype" --build=prototype
/ts-turbo demo-app --idea=ideas/prototype.txt --build=prototype

# 📦 MVP (15-20 min) - Production launches, professional quality
/ts-turbo blog-site "blog with user accounts and comments" --build=mvp
/ts-turbo blog-site --idea=ideas/mvp-blog.md --build=mvp

# 🏢 PRODUCTION (45-60 min) - Enterprise-grade, full compliance
/ts-turbo business-app "inventory management system" --build=production
/ts-turbo business-app --idea=ideas/production-app.json --build=production

Keyword Detection

The system automatically detects your intent from keywords:

Prototype triggers: "rapid", "demo", "prototype", "quick test", "POC"
Production triggers: "enterprise", "mission-critical", "compliant", "scalable"

Performance: Prototype builds are up to 20x faster than full production builds!

👉 Complete Build Presets Guide → 👉 Quick Reference →

🏗️ The Five-Stage Workflow

Stage	Department	Focus	Duration	Key Output
Stage 1	📐 Architecture	System Design	2-5 min	Tech stack & architecture decisions
Stage 2	📦 Product	Business Strategy	3-8 min	MVP definition & user stories
Stage 3	💻 Development	Implementation	10-30 min	Working database, backend, frontend
Stage 4	🚀 Release	Deployment	5-15 min	Documentation, security, infrastructure
Stage 5	🌐 Operations	Go Live	5-10 min	Live deployment & monitoring

Standard Workflow (Supervised)

# 1. Start project and define architecture
/ts-new-project my-app
/ts-approve architecture-start
/ts-architect

# 2. Plan product and get green light
/ts-product → /ts-plan → /ts-analyze
/ts-approve green-light 🚦

# 3. Build and test all components
/ts-develop → /ts-test-plan
/ts-build database|backend|frontend
/ts-integrate → /ts-signoff
/ts-approve development

# 4. Release and deploy
/ts-docs → /ts-security → /ts-release
/ts-deploy staging → /ts-verify staging
/ts-deploy production → /ts-verify production
/ts-approve launch 🚀

# 5. Go live (optional quick deploy)
/ts-push vercel|railway|neon
/ts-monitor → /ts-alerts

Turbo Mode (Autonomous)

For rapid prototyping, bypass all approval gates:

# With quoted idea
/ts-turbo my-portfolio "Personal portfolio website with contact form"

# With idea from file
/ts-turbo my-blog --idea=ideas/simple-blog.txt
/ts-turbo my-inventory --idea=ideas/inventory-tracker.json  # JSON can include build flags

⚡ Turbo Mode runs Stages 1-4 automatically with build presets for speed control and file-based ideas for organized workflows.

👉 Complete Workflow Guide →

🎮 Essential Commands

Project Management

/ts-new-project <name> - Start a new project (interactive)
/ts-new-project <name> --idea=file - Start project from idea file
/ts-status - Check current project status
/ts-brief - Get executive summary
/ts-ask "<question>" - Ask the Founder-Advisor

Quick Development

/ts-turbo <name> "<idea>" --build=prototype - Fast prototyping (3-5 min)
/ts-turbo <name> --idea=file --build=mvp - Production-ready from file (15-20 min)
/ts-turbo-quick <name> --idea=file - Silent turbo mode from file

Stage Commands

/ts-architect - Design system architecture
/ts-product - Define MVP and user stories
/ts-build <layer> - Build database/backend/frontend
/ts-deploy <env> - Deploy to environment
/ts-push <target> - Quick deploy to managed platforms

Utilities & Help

/ts-fix - Automatic error diagnosis and fixing
/ts-validate - Run build verification
/ts-health - Health check all services
/ts-help [command] - Interactive help and command discovery
/ts-quickref - Quick reference with workflow patterns
<any-command> --help - Quick usage for any command

👉 Complete Commands Reference →

🚦 Human-in-the-Loop Control

You maintain strategic control at 8 critical decision points:

Architecture Start → Begin system design
Architecture Lock → Finalize technical decisions
🚦 Green Light → Authorize development start
Development Done → Code complete, ready for release
Release Ready → Release package approved
Staging Verified → Staging deployment successful
Production Ready → Production deployment approved
🚀 Launch → Go live to users!

Gate Philosophy: You make strategic decisions while agents handle execution.

👉 Complete HITL Gates Guide →

🌐 Quick Deploy Options

Skip Infrastructure as Code and deploy directly to managed platforms:

Popular Combinations

# Frontend + Backend + Database (full stack)
/ts-push vercel     # Frontend to Vercel
/ts-push railway    # Backend to Railway
/ts-push neon       # Database to Neon
/ts-domain vercel myapp.com  # Custom domain

# Alternative stacks
/ts-push netlify    # Frontend alternative
/ts-push fly        # Backend alternative
/ts-push supabase   # Database with auth

🎉 Production ready in under 10 minutes!

👉 Complete Deploy Guide →

📚 Documentation

Getting Started

USER-GUIDE.md - Complete reference and workflows
QUICKSTART.md - 5-minute onboarding guide
Architecture Tutorial - Hands-on architecture design
Build Presets Tutorial - Speed optimization guide

Reference Documentation

Agent Reference - All 19 agents and capabilities
Command Reference - All 48 commands with examples
Configuration Guide - Customization options
Workflow Guide - Step-by-step processes

Generate Fresh Docs

/ts-self-document  # Creates up-to-date documentation

🎯 Example Projects

Quick Prototypes (3-5 minutes)

/ts-turbo todo-demo "simple todo app prototype" --build=prototype
/ts-turbo blog-demo "personal blog demo" --build=prototype

Production MVPs (15-20 minutes)

/ts-turbo recipe-site "recipe sharing website with ratings" --build=mvp
/ts-turbo photo-gallery "photo gallery with user uploads" --build=mvp

Business Applications (45-60 minutes)

/ts-turbo employee-directory "company staff directory with search" --build=production
/ts-turbo event-manager "conference booking system" --build=production

👉 More Examples →

💡 Philosophy

The System is built on these principles:

🎯 You are the Founder — AI agents work for you, not the other way around
🚦 Human-in-the-Loop — Critical decisions require your approval
🎯 Specialized Agents — Each agent has deep expertise in their domain
📝 Living Documentation — The project file is always the source of truth
⚙️ Flexible Workflow — Skip stages, customize processes, add your own agents
🚀 Production-Ready Output — Generated code follows best practices

🆘 Getting Help

Within The System

# Interactive help and discovery
/ts-help                     # Browse all commands by category
/ts-help <command>           # Detailed help for specific command
/ts-help --stage development # Commands for current stage
/ts-quickref                 # Compact quick reference
<any-command> --help         # Quick usage (e.g. /ts-turbo --help)

# Project assistance
/ts-ask "How do I add authentication to my app?"
/ts-brief                    # Project summary
/ts-status                   # Current status

Community & Support

📚 Documentation: USER-GUIDE.md and docs/user/
🐛 GitHub Issues: Report bugs and request features
🔧 Verification: Run ./scripts/verify-the-system.sh for diagnostics
📖 Self-Help: Use /ts-self-document for fresh documentation

🚀 Quick Reference Card

┌─────────────────────────────────────────────────────────────────┐
│                    THE SYSTEM - QUICK REFERENCE                 │
├─────────────────────────────────────────────────────────────────┤
│                                                                 │
│ 🏗️  START         /ts-new-project <name>                        │
│                                                                 │
│ 📐  ARCHITECTURE  /ts-assess | /ts-architect                    │
│                   /ts-approve architecture-lock                 │
│                                                                 │
│ 📦  PRODUCT       /ts-product → /ts-plan → /ts-analyze          │
│                   /ts-approve green-light 🚦                   │
│                                                                 │
│ 💻  DEVELOPMENT   /ts-build database|backend|frontend           │
│                   /ts-integrate → /ts-signoff                   │
│                   /ts-approve development                       │
│                                                                 │
│ 🚀  RELEASE       /ts-docs → /ts-security → /ts-release         │
│                   /ts-infra → /ts-pipeline → /ts-deploy         │
│                   /ts-approve launch 🚀                         │
│                                                                 │
│ 🌐  QUICK DEPLOY  /ts-push vercel|railway|neon                  │
│                   /ts-monitor → /ts-alerts                      │
│                                                                 │
│ ⚡  TURBO MODES   /ts-turbo <name> "<idea>" --build=prototype   │
│                   /ts-turbo <name> --idea=file --build=mvp     │
│                   /ts-turbo-quick <name> --idea=file           │
│                                                                 │
│ 🔧  UTILITIES     /ts-fix | /ts-validate | /ts-status | /ts-ask │
│                                                                 │
│ 🆘  HELP          /ts-help | /ts-help <cmd> | /ts-quickref     │
│                                                                 │
└─────────────────────────────────────────────────────────────────┘

🤝 Contributing

We welcome contributions to The System! To maintain code quality and consistency:

Branch Naming Convention (New Standards)

Use short, descriptive branch names with prefixes:

feat/auth        # New features (max 20 chars total)
fix/badges       # Bug fixes
docs/api         # Documentation updates
chore/cleanup    # Maintenance tasks

Quick Contribution Flow

git checkout main && git pull
git checkout -b feat/your-feature
# Make your changes
git push -u origin feat/your-feature
# Create PR, then after merge:
git branch -d feat/your-feature

Before Submitting PRs

✅ Run ./scripts/verify-the-system.sh
✅ Test changes thoroughly
✅ Update documentation if needed
✅ Follow existing patterns

📋 See CONTRIBUTING.md for complete guidelines

📄 License

LGPL-3.0 - Use commercially, modify freely, keep The System improvements open source.

📄 Full License | 🔗 Contributing Guidelines | 📋 CLA

Ready to build production software?

📚 Complete User Guide • 🚀 5-Minute Quickstart • 📋 Changelog • 🐛 Issues

Name		Name	Last commit message	Last commit date
Latest commit History 97 Commits
.claude		.claude
.github		.github
diagrams		diagrams
docs		docs
images		images
scripts		scripts
tests		tests
.env.example		.env.example
.gitignore		.gitignore
CHANGELOG.md		CHANGELOG.md
CLA.md		CLA.md
CLAUDE.md		CLAUDE.md
COMMAND-REFERENCE.md		COMMAND-REFERENCE.md
CONTRIBUTING.md		CONTRIBUTING.md
LICENSE		LICENSE
QUICKSTART.md		QUICKSTART.md
README.md		README.md
TEMPLATE_README.md		TEMPLATE_README.md
USER-GUIDE.md		USER-GUIDE.md
VERSION		VERSION
version.json		version.json

License

vedanta/the-system

Folders and files

Latest commit

History

Repository files navigation