You provide the concept and a git repository once. The pipeline runs end to end — every specialist, every stage — until the audit is done and the code is pushed live.
Solution Creator is not a coding assistant. It is a structured pipeline where specialized sub-systems handle each phase of a build — concept, process, architecture, design, visual design, construction, audit, and deployment — in sequence. You provide the concept and the git repository at the start. Everything else runs. You return at the audit.
Every software solution requires the same three things to exist. Solution Creator connects them into a single coordinated pipeline, with a meta-orchestrator above all three.
A clear understanding of the real-world workflow being automated — what the software actually does and why.
An intelligent agent layer that supports the process — specialists, boundaries, handoffs, and shared memory.
Deployed, live code that implements the process and the agent layer — audited before it goes live.
You provide the concept and the git repository once, at the start. From there, the pipeline runs end to end without asking — every specialist, every stage — until the audit report is ready. You read it. If it passes, the code is pushed to your repository and the software goes live.
Audit Agent verifies every module in the build against the architecture spec. Flags missing pieces, rule violations, and anything that would fail in production. You read the report. It is the single decision point before deployment.
Everything built goes to the repository you provided at the start. Clean, complete, ready to deploy.
Coolify reads from your repository automatically. You add the environment variables once — database connection, API keys, domain. The software goes live.
Each sub-system owns a defined phase of the pipeline. The meta-orchestrator coordinates between them — it routes, it never processes. Specialists run as subagents with clean contexts between gates.
Runs a structured two-batch interview: first establishes essence (goals, users, outcomes), second captures texture (design ethos, tone, principles). Then researches competitors and the domain's visual conventions before producing the brief all downstream stages build from.
Extracts and maps the real-world workflow behind the concept. Identifies stages, players, friction points, and the boundary between procedural work and decisions that require human judgment. The map is the foundation for the ICM architecture.
Designs the multi-agent AI layer using Interpretable Context Methodology. Defines specialists and their boundaries, shared infrastructure (catalog, config, database, SOPs), master record schema, and the handoff data contracts between every specialist in the chain.
Translates the ICM architecture into a UI/UX specification. Defines views, user flows, role-based access, and interaction patterns before the software architecture is locked. This is a pre-architecture concern, not a build-time one.
Commits to one named visual direction — not a mood board, a decision. Derives a complete token system: color palette, type scale, spacing, shape, depth, motion. Produces a project-specific banned list to prevent generic AI defaults from appearing in the build.
Operates in two shells. The outer shell architects the system before any code is written. The inner shell builds every module and route against the approved architecture spec and deployment config. Deploys directly to live — never localhost.
Runs after the inner shell builds and before any deployment. Checks the build against the architecture spec — missing modules, rule violations, deployment config completeness. Flags gaps before they reach production. No stake in the build it reviews.
The pipeline is designed to minimize the human time required. You are not a task manager here — you are a decision maker at two specific moments. Everything between those moments runs without you.
You describe what you want to build in one line. The Concept Developer interviews you in two structured batches to develop that into a complete brief covering goals, users, outcomes, and design ethos. You also provide the git repository URL where the built code will be pushed. That is the entirety of your setup work.
After the full pipeline has run — concept development, process mapping, architecture, design, visual design, build plan, and build — the Audit Agent verifies every module against the spec and produces a report. You read it. If the build passes, the code is pushed to your git repository and you set the environment variables in Coolify. The software is live.
Everything between those two moments — every spec, every decision, every line of code — runs without asking. That is the point.
All builds target live deployment environments from the first file written. The deployment config must exist before any code starts. Local environments diverge from production. Testing locally gives false confidence. The cost of setting up real infrastructure once is lower than the cost of debugging environment-specific failures later.
The deployment_config.md — repo URL, VPS app names, database connection, environment variables, domain — must be complete and confirmed before the inner shell writes a single line. Code written for the wrong environment is not deployable code. Configuration is not a detail; it is the foundation.
Every session, every agent, every decision is logged to project_record.md (phase and gates), dev_record.md (append-only build history), and connection_map.json (live topology). Without a persistent, machine-readable record, every session starts from zero. The record is the continuity.
Process Codifier, ICM Builder, and Software Creator are not merged or flattened. They live as independent sub-systems with their own methodologies and evolve independently. The meta-orchestrator handles coordination; sub-systems handle execution.
Every downstream stage was inheriting a one-line concept and guessing the rest. The guesses compounded. A researched, gated brief at the front means Process Codifier extracts the right workflow, ICM Builder optimizes for the right goals, and Visual Designer designs from a stated ethos instead of inventing one.
When no agent owns aesthetics, the build defaults to the generic AI look — rounded cards, soft shadows, Inter, indigo. The Visual Designer makes the visual direction a gated, reviewable decision. The banned list it produces binds the Software Creator's UI work. Without this stage, nobody decides the look.
Inner shell agents build sequentially. Errors compound. A dedicated audit pass before deployment catches systemic gaps — missing modules, rule violations, config inconsistencies — before they reach production. The audit agent has no stake in the build it reviews.
Every project lives in _projects/{project-name}/ — the complete record of what was built, why, and how to change it.
Athletic OS is the first project built end-to-end through Solution Creator. A single-user, self-hosted training instrument — lifts, bouldering, runs, weight — with a closed-loop weekly AI coaching cycle. Below is how it appears in the Solution Creator dashboard.