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.
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
- Signal
Each tool keeps its own copy of the design.
- Insight
Drift starts when consumers own separate models.
- Options
Sync several models; or one model with many consumers.
- Decision
One canonical document; editor, AI, prototype runtime and React compiler all derive from it.
- Trade-off
Higher upfront architecture cost before visible features.
- Outcome
A clear foundation documented in the System Architecture specification.
Decision 02
Honest status labels
- Signal
A visible UI is easy to mistake for a finished capability.
- Insight
Credibility depends on separating built from planned.
- Options
Marketing-style feature list; or explicit status per capability.
- Decision
Shared status vocabulary on the wiki and this page.
- Trade-off
Less impressive at a glance, more trustworthy on inspection.
- 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.
- Implemented
Editor shell: layers, canvas, properties
Available in the live prototype.
- In progress
Design tokens in the inspector
Visible in the editor; mapping to CSS being completed.
- Specified
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.
- Planned
Prototype runtime with state
See Prototyping Engine.
- Planned
React and CSS export
See React Compiler and Export.
- Limited
Import from other tools
Fidelity reports specified; import coverage not yet proven.
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.