The Complete Software Factory: Generative Domain Languages for Every Layer

The Evolution of the Factory

My software factory, as described in the "Movie Night MVP," started with a single breakthrough: using Smithy to generate API boilerplate deterministically while LLMs handled the creative business logic. That hybrid approach was transformative, but it was just the beginning.

A factory is only as efficient as its most manual process. After automating the API layer, I kept asking myself: "What other repetitive, deterministic work am I still doing by hand?" The answer led me to expand the factory into a complete, three-layer ecosystem.

The Three Generative Domain Languages

Today, my software factory is built on three generative domain languages, each eliminating boilerplate in its domain:

1. Smithy: The API Contract Layer

Smithy defines service interfaces in a protocol-agnostic way. A single Smithy definition generates:

• HTTP server stubs with operation handlers
• Request/response serialization for REST, GraphQL, or gRPC
• Type-safe client libraries in multiple languages
• API documentation and OpenAPI specs

Smithy ensures perfect consistency across every service in the factory. All APIs follow the same patterns because they're generated from the same source of truth.

2. Capacitor: The Data Persistence Layer

Capacitor is my universal data modeling language—what I call the "flux capacitor" for data that can travel across time and databases. A single Capacitor schema generates:

• Database DDL for SQL databases (PostgreSQL, MySQL)
• Table configurations for NoSQL databases (DynamoDB, MongoDB)
• Migration scripts that evolve schemas over time
• Type-safe data access clients with full IDE support

Capacitor's philosophy: "Where your data is going, it doesn't need proprietary schemas." Define your data model once, and Capacitor generates everything needed to persist it anywhere—SQL today, NoSQL tomorrow, without rewriting business logic.

Here's a simple Capacitor schema:

model Bookmark {
  id: UUID @primary
  createdAt: Timestamp @default(now())
  url: String @required
  title: String @required
  tags: List<Tag>
}

model Tag {
  id: UUID @primary
  name: String @unique @required
  bookmarks: List<Bookmark>
}

From this, Capacitor generates type-safe clients:

// Generated by Capacitor
const bookmark = await capacitor.bookmark.create({
  url: "https://example.com",
  title: "Example",
  tags: [{ name: "tutorial" }]
});

3. Flux: The User Interface Layer

Flux is my AI-first universal UI modeling language. It's designed to be easily generated by LLM coding agents while remaining perfectly human-readable. A single Flux component definition generates:

• React components with hooks
• Vue 3 composition API components
• SwiftUI views for iOS/macOS
• Jetpack Compose for Android
• React Native for cross-platform mobile

Flux completes the trifecta. With Flux, I can define a UI component once and have it rendered natively across every platform, with full type safety connecting to the Smithy APIs and Capacitor data models.

Here's a Flux component:

component BookmarkCard {
  props: {
    bookmark: Bookmark  // Type from Capacitor schema
    onDelete: Handler
  }

  layout: VStack {
    spacing: 16
    padding: 20

    children: [
      Text {
        text: props.bookmark.title
        style: "headline"
      },
      Text {
        text: props.bookmark.url
        style: "caption"
        color: "muted"
      },
      Button {
        label: "Delete"
        onClick: props.onDelete
      }
    ]
  }
}

The Complete Assembly Line

With all three languages integrated, my factory's assembly line now looks like this:

1. Documentation Agent generates the PRD, Architecture Document, and Development Plan (unchanged from before).

2. The Architecture Document now includes three definitions:

   • Smithy specs for the service APIs
   • Capacitor schemas for the data models
   • Flux components for the UI layer

3. The Build Process runs three generators in parallel:

   • Smithy generates all API boilerplate
   • Capacitor generates all database schemas and clients
   • Flux generates all UI components for target platforms

4. The Coding Agent writes minimal glue code:

   • Wire the Smithy operation to the Capacitor client
   • Connect the Flux components to the Smithy endpoints
   • Implement the actual business logic that makes this service unique

The Impact: True Full-Stack Generation

The addition of Capacitor and Flux has been transformative:

• Consistency Everywhere: APIs, data access, and UI components all follow the same patterns across services because they're generated from universal definitions.

• Database Freedom: I can start with PostgreSQL for rapid prototyping and switch to DynamoDB for production without touching business logic. Capacitor handles the translation.

• True Cross-Platform UIs: The same Flux definition powers the web app (React), the admin panel (Vue), the iOS app (SwiftUI), and the Android app (Jetpack Compose). No more maintaining parallel codebases.

• Massive Token Savings: LLMs now generate only the business logic. All the boilerplate—tens of thousands of lines across API, data, and UI layers—costs zero tokens.

• Speed: I can prototype a full-stack feature in minutes. Define the Smithy operation, Capacitor schema, and Flux component. Hit build. The factory handles the rest.

The Philosophy: Separation of Concerns

The power of this factory comes from a clear separation of concerns:

• Generative Domain Languages define WHAT: the contracts, data models, and interfaces.
• Deterministic Generators define HOW: the framework-specific, database-specific, platform-specific implementations.
• LLMs define WHY: the business logic that makes this application unique and valuable.

This isn't the "no-code" dream. It's something better: a low-ceremony, high-leverage development experience that lets humans focus on creativity and product vision while machines handle the repetitive, error-prone work.

The journey started with skepticism about AI-generated code. It moved through the frustration of manual patching and token-burning LLM committees. It arrived at a powerful hybrid approach using Smithy. And now, with Capacitor and Flux completing the ecosystem, I have a true software factory—one that generates complete, production-ready applications from high-level definitions, spanning APIs, databases, and user interfaces across every platform.

Where we're going, we don't need boilerplate.