Inspiration
One product decision should not become four platform rewrites. Today a team can design an interface in a visual tool and generate code very fast, but the meaning behind the design is soon lost inside different files. A rule such as keeping the main action easy to reach on a small phone must then be rewritten for Web, React, Expo and SwiftUI.
I took inspiration from Figma and Paper because they make visual work feel direct and easy to understand. I wanted that same feeling in a system where product intent can also compile, run and prove itself. That is why I built IntentForm.
What it does
IntentForm keeps product intent as the source of truth. A brief becomes one validated Semantic Interface Graph that stores layout meaning, tokens, components, states, flows, accessibility intent and device behavior. The same graph creates deterministic output for Web, React, Expo and SwiftUI.
The product has three connected workspaces. Design lets you edit the product visually while keeping its semantic structure visible. Code shows readable platform output and connects each file to the graph nodes that created it. Verify checks responsive behavior, accessibility, Runtime Parity and native evidence against the exact graph fingerprint.
This matters because generated code is not proof that a product still follows the original decision. A valid graph, generated source, a successful build and correct runtime behavior are different levels of evidence. If the graph changes, old evidence becomes stale instead of silently proving a new build.
Agents can suggest a small semantic change without taking control of the whole project. A person can inspect the exact diff, approve or reject it, verify the result and restore an earlier version.
Try it
The hosted Judge Mode gives reviewers a guided four minute tour with a complete sample project. It needs no account, API key, credits or test credentials. Reviewers can inspect the intent, compare every platform output, review evidence and test a safe repair workflow.
Try the hosted version here: https://intentform-amber.vercel.app/studio?judge=1&step=design
IntentForm is also open source. You can clone the repository, host the full application yourself and run the included validation commands. The repository also includes the IntentForm MCP server, so an MCP client can inspect project truth and work with the same bounded semantic actions without rebuilding the product.
Source and setup instructions: https://github.com/metaforismo/IntentForm
How I built it
I built the whole project with Codex and GPT 5.6. I used Codex from the first idea to the final release for product planning, architecture, implementation, user experience, debugging, documentation, testing and release work.
I used several Codex threads at the same time. Some threads implemented features while others reviewed the interface, tested browser and native output, searched for edge cases or audited release quality. Codex helped me organise these threads, compare their findings and continue until the important checks passed.
Codex wrote and ran unit tests, browser tests, native checks and stress tests. The final release passes 551 unit tests, 29 production browser scenarios and a 10,000 node benchmark, together with type checks, production builds, native render checks and desktop package verification. I also used OpenAI ImageGen through Codex to create the IntentForm logo and visual assets.
Inside IntentForm, GPT 5.6 handles the work that needs judgment. It can understand an unclear product brief and propose a constrained repair. The parts that must remain repeatable are deterministic: schemas, validation, compilers, fingerprints, semantic diffs, evidence, history and rollback are controlled by code.
The main technologies are TypeScript, Next.js, React, Zod, Playwright, Electron, Expo tools and SwiftUI verification harnesses.
Challenges
The hardest challenge was keeping the same meaning across platforms with different layout, navigation, accessibility and safe area systems. It was not enough to make four screens that looked similar. Each output had to preserve the same product rule in a native way.
The second challenge was honest verification. I needed the product to say “not run”, “stale” or “failed” when proof was missing instead of presenting a green result too early. That made the system more complex, but it also made every result easier to trust.
The third challenge was using AI without hiding uncertainty. GPT 5.6 is strong at interpreting a brief and finding a useful repair, but the suggested change still needs a bounded diff, human approval and fresh evidence.
My contribution
I designed and built IntentForm independently, with Codex as my coding partner throughout the project. I defined the product direction and made the final architecture, design and release decisions. With Codex, I created the Semantic Interface Graph, the Design, Code and Verify workspaces, the four compilers, Judge Mode, the MCP server, the testing system, the documentation and the release workflow.
What I learned
I learned that AI is most useful when it works inside clear limits and can show its work. GPT 5.6 can understand intent and make a difficult judgment. Codex can plan, implement, test and review a large project. Deterministic systems can then make each result repeatable, inspectable and reversible.
I also learned that good results do not come from one perfect prompt. Codex and GPT 5.6 improved a lot when I gave them focused skills, strong references, small acceptance criteria and real test evidence. They still needed careful steering, review and repeated browser, native and stress testing. Parallel threads were very useful, but only when each thread had a clear scope and the final results were checked against the same product truth.
The biggest product lesson was that generated files should be treated as an output, not as the only source of truth. A semantic graph can connect the original decision, every generated target and the evidence that proves the current build. That connection is more valuable than generating code quickly and losing the reason behind it.
What is next
The next product step is full authentication and a clearer workspace for real teams. I also want to keep improving the visual interface, make complex states easier to read and reduce the amount of guidance needed for first time users.
After that I want richer layout controls, more component registration, a deterministic Compose compiler, automatic native previews and optional collaboration. The long term goal is to make product intent portable across tools and platforms without giving an agent unlimited control.
IntentForm does not translate pixels. It preserves product intent.
Built With
- codex
- electron
- expo.io
- gpt-5.6
- next.js
- openai-imagegen
- playwright
- react
- swiftui
- typescript
- vercel
- zod
