Decode — compose intent. AI writes the code.
A next-generation visual programming environment. You author architecture, oracles, and provenance on a graph — AI generates each modular implementation.
Private beta — limited seats for teams who want to shape the product. Read the essay →
Our thesis
Code is cheap. Confidence is the scarce asset.
AI shattered the old assumption that code is the precious heirloom. The real asset is everything that lets you delete an entire implementation without fear — contracts, behavioural checks, invariants, and the reasoning behind every change.
Chat bolted onto an IDE
Architecture lives on a whiteboard. Specs drift. The “why” vanishes inside a closed chat tab. Code still does every job at once.
Oracle-first visual programming
You compose boundaries, flows, and evaluations. AI fills in the implementation. Delete a module — the oracle survives; regenerating it is one click.
The durable layer
Oracles — the single source of truth above the code.
Systems built for the next decade need explicit judges of correctness that do not refer back to yesterday’s implementation. In Decode, those oracles are first-class objects on the canvas — not a wiki nobody opens, not a Miro board that goes stale.
- Contracts — shapes and obligations at every boundary
- System design — concepts, intent, and how data and events flow
- Behavioural checks — given this input, expect this output
- Invariants — what must never break, encoded where you can see them
- Live signals — production metrics that tell you whether reality matches intent
The code is just the output — disposable and regenerable when stale.
Rigor lives in the oracle. The implementation is allowed to die.
Not just what changed — why it changed, who approved it, and what still holds.
Provenance is the new version control
Track the why, not only the what.
Traditional version control records file diffs. Regenerative development needs decision lineage: which oracle shifted, which agent regenerated a grain, which evaluation passed, and why a human conserved a slow-moving boundary instead of rewriting it.
In Decode, that reasoning lives on the visual graph — above the implementation — instead of disappearing into an unread chat thread. Manual edits without provenance break the chain; intentional changes become part of the system’s memory.
Teams that cling to code as identity will feel this as loss. Teams that relocate rigor from implementation to specification will feel it as liberation.
Compartmentalized regeneration
Delete a module. Regenerate it. Move on.
Not every layer should change at the same pace. Fast grains — adapters, glue, internal logic — regenerate as the oracle evolves. Slow layers — public APIs, behavioural promises, interfaces users depend on — change deliberately, with judgement.
When each module is specified so it does not need the rest of the system as context, AI can regenerate it cheaply and reliably. A well-defined contract at the boundary is enough. Deleting a module becomes boring — because the oracle survives, and rebuilding it takes the same effort it took to remove it.
That is the programming surface adults need now: describe architecture and behaviour visually, the way you would on a whiteboard — and let AI handle the materialization of code.
Fast layers regenerate freely. Slow layers move with care.
What Decode is built around
Architecture, oracles, and provenance — code as output.
Not another AI sidebar on a text editor. A programming surface designed for regenerative software.
Visual architecture canvas
Compose boundaries, flows, and modules the way you would on a whiteboard — the graph is the primary surface, not a diagram of the code.
Oracles & evaluations
Contracts, invariants, and behavioural checks as first-class objects — the judges of correctness that survive any reimplementation.
AI-generated modules
Each component carries a durable description. AI materializes the implementation — modular, inspectable when needed, regenerable when stale.
Provenance lineage
Version control extended beyond diffs — capture why a decision was made, which agent regenerated a grain, and what still holds.
Selective regeneration
Fast layers regenerate freely; conservation layers — public contracts and behavioural promises — change slowly, on purpose.
Free forever
The base product is free for anyone and will remain free forever. Only our cloud and interoperability services require a Pro subscription.
Decode is being built with 🧡 in India by ARPM, a team of Architects, Planners, Computational Designers and Technologists — working on this problem long before AI made the old assumptions impossible to ignore.