Apexian Lab

Internal control plane · Right&Above

Describe the app. Approve the plan. Ship the assembly.

Application Assembly Pipeline is how we build software here. A request in chat becomes an implementation plan a person signs off on; the app is then assembled from a registry of human-reviewed modules, and AI agents write only the parts that are genuinely new.

Stages before code is written
0
Critics in the loop
0
Stages that wait for a person
0
Plans shipped without sign-off
0

01 Why a pipeline

Generating an app is easy.
Trusting it is the hard part.

Ask a model for a SaaS and you get something that runs on the demo and frightens you in production. Three problems show up every time — the pipeline exists to remove all three.

Prompt straight to code
  • Security-critical code is improvised every timeLogin, sessions, token lifetimes, payment webhooks — the model writes them from scratch on each project, with no memory of how it solved the same thing last month. These are exactly the places where a subtle mistake is expensive.
  • Every app is a one-offDifferent folder layouts, different event names, different config handling. Nothing transfers between projects.
  • Nobody signs anythingCode appears before a human has agreed what should be built — review happens after the fact, if at all.
Assembled by pipeline
  • Risky parts are reused, not writtenSign-in, payments, subscriptions and transactional mail come from versioned modules with a fixed contract and a human reviewer behind them.
  • One shape for every appSame monorepo layout, same CQRS event contracts, same encrypted config store, same audit surface — in every application it produces.
  • The plan is the gateThe run halts at approval. What gets built is agreed in writing before a single file is generated.

02 The conveyor

Seven stages,
two of them wait for a person.

Every stage is a saga state routed by a state machine and queued through Redis; workers execute it and stream progress back to the chat. Session state lives in PostgreSQL, so a run resumes exactly where it stopped. Four of the stages hand their output to a critic before the run is allowed to move on.

  1. 01
    Intent INTENT

    The chat request is resolved into a concrete application intent — domain, actors, surfaces — until the stage reports itself ready.

    critic INTENT_REVIEWlight
  2. 02
    Discovery DISCOVERY

    The registry is searched for trusted modules that already cover parts of the intent. The critic verifies every candidate against the real registry, so nothing imaginary survives into the plan.

    critic DISCOVERY_REVIEWlight
  3. 03
    Module selection MODULE_SELECTION ◆ waits for a person

    A wizard: you tick which discovered modules to wire in and fill each one's required variables, screen by screen. Config is encrypted per session and module before it is stored. The saga does not auto-advance — it sits here until you submit.

  4. 04
    Planning PLANNING

    The plan is drafted around the fixed module set, not around what the model feels like reusing. The policy critic then checks it — deterministic rules plus an LLM pass; on a failing verdict planning is re-run with the critic's feedback until it clears.

    critic PLAN_POLICYstandard · blocks
  5. 05
    Plan approval PLAN_APPROVAL ◆ waits for a person

    The last stop before anything is written. A human reads the implementation guide and approves or rejects it.

  6. 06
    Code generation CODE_GENERATION

    Not one big generation call — a scaffold, a decomposition into tasks, then a tight per-task loop of write and review.

    1. BOOTSTRAPDeterministic shell, no agent: clone the template, install, git init, write the agent briefing, commit the scaffold.
    2. DECOMPOSERReads the approved plan and the scaffolded workspace and produces an ordered task list with acceptance criteria and a dependency graph.
    3. PRODUCER ⇄ REVIEW_CRITICPer task: the producer writes only inside that task's file scope, the critic reads the resulting diff and verdicts it against an explicit checklist. A failing verdict comes back as feedback and the producer fixes on top of its own work — attempts, feedback and the commit SHA are all stored per task.
  7. 07
    Release RELEASE

    Three deterministic sub-steps — RELEASE_BUILD, RELEASE_DEPLOY, RELEASE_PROBE: a clean rebuild, a push into the runtime, then a health probe against the deployed app. If the clean rebuild fails, the run bounces back once into code generation with a release-fix task instead of shipping.

Application Assembly Pipeline plan · awaiting approval

you A fullstack app with signup, login, sign-out and password reset. React front end, Nest API, cookie sessions.

Reusing trusted modules

  • auth-passwordnest · react · core Matches the requested signup/login forms and the password-reset flow, and ships both the NestJS server module and the headless React hooks. Handles password and session flow through pluggable storage and hashing abstractions.
  • communication-emailnest · core Does not implement auth itself, but delivers the password-reset mail that auth-password deliberately leaves to the host application.

Steps

  1. Scaffold the fullstack workspace — one Nx application at the workspace root, so the Nest API and the React front end share a single scaffold.
  2. Wire auth-password — forRoot() on the Nest side, host adapters for the user store and hashing, headless hooks on the front end.
  3. Verify locally — run the workspace, open the React app at /, exercise signup, login, sign-out and reset against the API at /api, with cookie persistence across reloads.
Waiting for a human to approve the plan ApproveReject
A shortened plan from a real run. Reuse is resolved before anything is written — the agent only generates what the registry does not already cover.
appassemblypipeline.rightandabove.com
The pipeline UI showing a generated plan with reused trusted modules and steps
The same thing in the actual tool.

03 Trusted Modules Registry

The parts nobody should
be rewriting per project.

Sign-in, payments, subscriptions, transactional mail and shared domain logic live in a registry as reviewed, versioned modules. The pipeline reaches for these first, and only generates what is genuinely new.

Registry versioned npm packages
  • Authentication
  • Payments
  • Subscriptions
  • Communication
  • Domain logic
  • 3packages per module — core, nest, react
  • 1manifest per module: reserved routes, events, config schema
  • 60+modules the registry is being built out toward

Each module carries a machine-readable briefing for the agent that installs it, and a checker enforces package boundaries, naming and secret handling before anything can be published.

  • A contract, not a convention Every public name in a module derives from one MODULE_ID — DI tokens, route prefix, Redux slice, event names. Two modules physically cannot collide on a symbol space.
  • Headless by rule core may not import NestJS or React; react may not import a UI library. The check runs before publish, so an app can restyle a module without forking it.
  • Secrets handled once Module config is captured against a declared schema and encrypted per session and module (HKDF-SHA256 → AES-256-GCM). Secret values are masked in every echo path.

04 Built on

Built on technology
your team already knows.

Nothing exotic in the stack — so the applications it produces can be handed to in-house developers without a migration project first.

Control plane An Nx monorepo: NestJS backend with CQRS, a React + Vite chat UI, and shared contracts in a common library, so both sides always agree on the shape of the data.
Async execution Pipeline steps are queued through Redis and BullMQ and run on workers, so nothing long-running sits on an HTTP request. Progress is streamed to the UI in realtime.
State PostgreSQL holds session and orchestration state plus the registry itself, so a run survives a restart and every module version is a row you can query.
Model access A provider abstraction sits in front of the LLM calls, so the pipeline is not welded to one vendor and can point at a self-hosted model where the data requires it.

Want this pointed
at your backlog?

The pipeline is internal to Right&Above — we run it, you get the application. Talk to us about what you'd put through it.