Claude writes the app.
Unstackr makes it operable.

Point Unstackr at the code Claude produced. It reads the output, lifts out the fields, rules, calculations and integrations, and rebuilds them as editable objects on the Unstackr design surface - then deploys the result as a governed application your team can manage and update. Go back and forth between Unstackr and Claude.

Bring your code output
Claude output export function Intake() { const [dob, setDob] = … if (age < 18) show( 'guardian_consent') const total = base * rate validate(sin, /^\d{9}$/) await fetch(POSTAL_API) <input name="cell_phone" required maxLength={10}/> <select name="province">… onSubmit={postToCrm} } one artifact nothing addressable Unstackr objects Pages and controls cell_phone · date_of_birth · province Business rules show guardian_consent when age < 18 Calculate and validate total = base × rate · SIN format Data source mappings PostalCodeLookup · CRM · Stripe Deployed web and mobile app — versioned, integrated, editable status: live
Fig. 1 — From a single generated artifact to addressable, editable objects
What we solve for

Running and maintaining Claude code is made possible with Unstackr

A model can produce a working intake application in an afternoon. What arrives is a codebase, and a codebase is only useful to the people who can build, host, secure and change it. For most teams, the prototype stalls exactly where the real work starts.

 
 
01

Only the model can change it

Every amendment goes back through a prompt. Business owners can't touch a field label, a threshold or a dropdown list without a developer in the loop.

02

The rules are buried again

Eligibility thresholds and calculations end up inside functions and conditionals. You've swapped logic locked in a PDF for logic locked in a file - same problem, newer syntax.

03

No path to production

Hosting, accessibility, authentication, retention, audit trails and language support are all still ahead of you, and none of them come out of the model.

04

It stands apart from the estate

One generated app doesn't share connectors, rules or a data layer with the forms around it. Build ten and you've built ten more silos.

What comes out of the code

Every part of the output becomes something you can open and edit.

 

Unstackr parses the generated application and materialises each construct as a first-class object in App Manager. Nothing is re-implemented by hand and nothing stays trapped in a function body - the logic keeps a link back to the source it came from.

 
In the generated code
Becomes in Unstackr
Maintained in
<form> markup and components
Pages and controls on the design surface Textbox, dropdown, checkbox, radio, table, signature, file upload
Designer
name, type, required, maxLength, placeholder
Control properties Tag, type, hint, placeholder, data type, data format, required, secured
Properties panel
conditionals, show/hide, enable/disable
Named business rules on a visual canvas Readable by an analyst, changed without touching code
Business Rules
calculations and validators
Calculate and validate expressions bound to the field Each one owned by the control it acts on
Properties panel
fetch, SQL queries, SDK calls
Registered data sources with response, select and success handling Defined once, reusable across every app in the space
Data Management
request and response payload shapes
Field-level mappings between sources and page controls Saved as a template and applied to the next app
Easy Mapping
submit handlers and local state
Managed submissions and a governed data store Review, export and downstream delivery included
Submissions
hard-coded interface strings
Translatable entries for every language you deliver Bilingual and multilingual output from one source
Translate
After intake

The generated Claude app arrives as an editable application.

Same design surface, same rules engine, same integration layer the rest of your form estate already runs on. There is no separate “AI project” to look after.

 

Fields become controls. Every input in the generated code lands on the page as a typed control with its own properties - tag, data type, format, required, secured - alongside the standard palette, drawings, data and advanced elements.

Calls become connections. Each API, database or service call in the output is registered as a data source and wired to the controls it feeds, in both directions, with response and success handling defined in the same view.

How it works

From generated Claude output to a running service.

 
01

Generate your Claude code

Hand Unstackr the application Claude produced - a repository, a folder, or a single generated file. No scaffolding or restructuring first.

02

Extract the logic

The agents read the code and build a model of it: every field, condition, calculation, validation, service call and string, each linked back to where it came from.

03

Rebuild as objects

The model is written into App Manager as pages, controls, properties, business rules and data mappings. High-risk logic is flagged for a person to confirm.

04

Deploy and operate

Publish as a responsive web and native mobile app on your tenancy, then keep changing it in the tool - new fields, new rules, new integrations, no regeneration.

What the platform adds

Everything the model doesn't hand you.

Generated code stops at the demo. These are the parts an application needs before it can carry real submissions from real people - and they come with the platform rather than the prompt.

  • Conditions, branching and cross-field logic as named rules an analyst can read, test and change.

  • Databases, web services, APIs and file drops defined once in the space and shared by every application in it.

  • One build renders as a responsive web app and in the native iOS and Android app, with offline capture and sync.

  • Output is WCAG 2.0 AA compliant HTML5 rather than something to remediate after the fact.

  • Translate every label, hint and message from one source and follow the user's language preference.

  • Mark sensitive inputs as secured and control who can design, submit and administer through space administration.

  • Completed data is stored, searchable and routable, with print and Download PDF output where a document is still required.

  • Changes are released individually against a versioned platform, with an audit trail on what the agents decided and what a person approved.

  • SaaS, PaaS or fully on-premises, on the cloud provider of your choice, under ISO 27001:2022 certified operations.

A generated app that behaves like an owned asset.

  • An editable asset, not a dead export

    After intake, every field, rule, mapping and workflow is a live object held in one place. Most AI output is a one-shot you can't maintain. This is the starting point you build on.

  • The logic is visible again

    Thresholds, calculations and eligibility conditions are lifted out of the source and written as named rules with a link back to the line they came from. The people who own the process can read them.

  • It joins the estate it belongs to

    Generated apps land in the same space as your converted PDF and XFA forms, sharing connectors, rules and one data layer - instead of adding another isolated system.

  • Prototypes stop being throwaway

    The fast version a team built to prove an idea becomes the version that ships. No rebuild by a delivery team, no second implementation of logic that already works.

Try it on your own code

Provide the app Claude built for you and we will operationalize it in minutes.

Bring a generated intake or assessment app and we'll run it through intake live - fields, rules, calculations and integrations recovered in front of you - then show it deployed and editable in App Manager.

Request a demo