Skip to content
AI-native design tools · 0-to-1 Shipped · enterprise

DesignForge AI · Independent product

Exploring one editable source for design, prototypes and code.

DesignForge AI is an early-stage product I initiated and am building. It tests whether design, design systems, prototyping and code handoff can work from one structured document, with AI that edits real objects through the same path as people.

0-to-1 AI product Architecture Design systems
DesignForge AI editor featuring canvas, live component tree, and token inspection.
DesignForge AI editor featuring canvas, live component tree, and token inspection.

Executive snapshot

Product
DesignForge AI
Stage
Early development · live prototype
My role
Founder; product, design and architecture lead
Research status
Hypotheses; no customer research run yet
Focus
Document model, tokens, deterministic AI edits
Docs
Public implementation wiki (11 pages)

01 · The stakes

A hypothesis, not a finding.

A product moves through requirements, structure, design-system rules, prototypes and engineering handoff. When those live in separate tools, teams re-create the same intent several times.

No customer interviews or usability studies have been run yet. These are problems to test. The question guiding the work: how might we connect creating, governing, prototyping and building, without asking designers to hand control of their files or decisions to AI?

02 · My leadership contribution

Define the product thesis, architecture and roadmap, and build the first working prototype.

Team & collaboration model
Independent build; I own product, design and architecture decisions.
Key decision
Every consumer of the design (canvas, inspector, AI, prototype, code export) reads one canonical document.
Stakeholder challenge
Documented decisions publicly in the wiki so future collaborators can review them.
Operating rhythm
Status for every capability tracked as Implemented, In progress, Specified, Planned or Limited.

03 · Research & insight

What we learned before we designed.

Structure, not pixels

Objects have stable identities and hierarchy, so the design is a data tree that tools and AI can reason about.

AI through the same door

Manual and AI edits go through one command and transaction path, so every AI change is reviewable and undoable.

Fidelity must be visible

Import gaps are reported, never silently flattened.

04 · Decision stories

The calls that shaped the product.

Each decision follows the same path: signal, insight, options, decision, trade-off, outcome.

Decision 01

One canonical document

  1. Signal

    Each tool keeps its own copy of the design.

  2. Insight

    Drift starts when consumers own separate models.

  3. Options

    Sync several models; or one model with many consumers.

  4. Decision

    One canonical document; editor, AI, prototype runtime and React compiler all derive from it.

  5. Trade-off

    Higher upfront architecture cost before visible features.

  6. Outcome

    A clear foundation documented in the System Architecture specification.

Decision 02

Honest status labels

  1. Signal

    A visible UI is easy to mistake for a finished capability.

  2. Insight

    Credibility depends on separating built from planned.

  3. Options

    Marketing-style feature list; or explicit status per capability.

  4. Decision

    Shared status vocabulary on the wiki and this page.

  5. Trade-off

    Less impressive at a glance, more trustworthy on inspection.

  6. Outcome

    Readers can see exactly what exists today.

05 · System view

Proposed architecture

All parts of the product are consumers of one document model.

Canonical document

Pages, layers, components, variables, interactions and assets.

Editor and inspector

Layers tree, canvas and contextual properties.

AI engine

Plans and proposes scoped edits to real objects.

Prototype runtime

Real state, data and conditions.

React compiler

Deterministic React and CSS output.

Local-first storage

Versioned project files and assets.

The current build

The live prototype shows the editor: layers, canvas and a properties panel with design tokens.

  • Layers tree and canvas
  • Token-aware properties panel
  • Specifications for AI, runtime and export

06 · What exists today

Built, specified and planned — kept separate.

A visible screen is not proof a capability works. Each item carries one status, matching the public wiki.

  • Editor shell: layers, canvas, properties

    Available in the live prototype.

    Implemented
  • Design tokens in the inspector

    Visible in the editor; mapping to CSS being completed.

    In progress
  • Canonical document model

    Defined in the System Architecture and Design Engine pages.

    Specified
  • AI edits through the command path

    Defined in the AI Engine page; not claimed as working.

    Specified
  • Prototype runtime with state

    See Prototyping Engine.

    Planned
  • React and CSS export

    See React Compiler and Export.

    Planned
  • Import from other tools

    Fidelity reports specified; import coverage not yet proven.

    Limited

Go deeper in the wiki

A summary of each specification page, so you can explore the thinking here and open the full page when you want detail.

Wiki · 01 of 11

Wiki home

The wiki is an implementation blueprint, not a claim that everything is shipped. It defines the product, one central architecture rule and a shared status vocabulary.

  • Core capabilities: design editor, infinite canvas, AI design engine, advanced prototyping, design-to-code compiler, local-first projects, extensible ecosystem.
  • Central rule: every feature reads and writes one canonical editable document.
  • Status vocabulary: Implemented means available and covered by tests; a visible UI alone is not proof.

07 · Reflection

What I'd do differently at the next scale.

The next step is validation: interviews with design-system teams to test whether the fragmentation problem is as costly as the thesis assumes.

I am keeping a public decision log so the reasoning behind each choice can be reviewed.