The Factory Awakens: From Vision to Plan

The Ultimate Test

My hybrid software factory, combining deterministic generators with targeted LLM agents, was working beautifully on small-scale tasks. It was faster, cheaper, and produced far more consistent code than my previous "all-LLM" approach. But the real test of a factory isn't whether it can build a single part; it's whether it can run an entire assembly line.

I decided to put it to the ultimate test: could I use the factory to build a brand-new application from scratch, starting with nothing more than a high-level vision?

My vision was simple: a new service to solve a common business problem, complete with a backend API to support its core functions. This was my raw material.

The Document Cascade

Instead of sitting down to write a PRD or draw architecture diagrams myself, I fed my vision document to the first stage of my factory: a specialized "Documentation Agent." Its job was to orchestrate a cascade of document generation, transforming a high-level concept into a detailed, actionable plan.

Step 1: Generating the Product Requirements Document (PRD)

The agent's first task was to act as a product manager. It took my vision and expanded it into a formal PRD, complete with user personas, feature breakdowns, and non-functional requirements. It inferred the need for user authentication, data pagination, and basic data validation. The result was a comprehensive document that looked like it had been written by a seasoned PM.

Step 2: Generating the Architecture Document

Once the PRD was complete, the agent moved on to the role of a solutions architect. It analyzed the PRD's requirements and generated a high-level Architecture Document. This document made key technical decisions: it would be a serverless application using AWS Lambda, DynamoDB for storage, and an API Gateway for the front door.

Crucially, this document also included the formal generative domain language definitions that serve as the master blueprint:

• Smithy definitions for the service's API - all resources, operations, and contracts.
• Capacitor schemas for the data models - tables, fields, relationships, and indexes optimized for time-travel across databases.
• Flux components for the UI layer - cross-platform interface definitions ready to generate for web and mobile.

Step 3: Generating the Development Plan

With the architecture and the PRD in hand, the agent's final transformation was into a project manager. It synthesized both documents to create a detailed, step-by-step Development Plan. It broke down the work into logical, implementable chunks.

But it didn't just write a plan. It automatically filed each of those chunks as a new ticket in my project management tool, Linear. My project board, which had been empty moments before, was suddenly populated with a perfectly ordered backlog of stories, each with a clear title, a detailed description referencing the PRD, and the relevant technical specifications from the architecture document.

The factory had awakened. In the space of about thirty minutes, it had taken my fuzzy vision and transformed it into a concrete, organized, and ready-to-execute engineering plan. The assembly line was primed, and the raw materials were in place.

In the next, final article of this series, I'll describe what happened when I pressed "go," and how my software factory built a working, tested MVP while I sat back and watched a movie.