An AI product that works without the AI · Arxion

Arxion reads construction drawings with AI and turns them into a priced bid. Subcontractors measure plans and price their work, general contractors package that work out to subs and award it. I joined as the solo designer for a fixed-scope sprint across four product areas, and the sprint’s most consequential decision had nothing to do with any of them. The product is unreleased; every screen here uses fictional demo data.

The decision the whole product hangs on

Early on we locked a principle with the client and then held it: manual first, AI as a layer. Every surface has to work with the AI switched off. Parsing, follow-ups and automated leveling plug into the same screens later, and none of them are load-bearing.

This is not caution about the technology. It is what the users are like. A subcontractor runs net margins of roughly 3.5 to 7 percent, so a takeoff error of 5 to 10 percent erases the profit on the job. And the industry benchmark is a 5:1 bid-to-win ratio, so the time each takeoff costs directly caps how many jobs a sub can chase. Those two numbers, from the research pass that opened the sprint, say the same thing: this user cannot afford to be wrong, and cannot afford to be slow. An AI that is usually right is a gift to someone who can check it and a trap for someone who cannot.

The AI says what it cannot see, before it runs

Running the AI is not a button. It opens a dialog that asks what you want estimated, with the object categories listed and selectable: doors, windows, walls, rooms. You scope the run.

Underneath the list sits the sentence I care most about in this product: MEP, fixtures and sitework are not detected by AI. Add them manually with the Measure tool. The interface names the model’s blind spots before it starts, in the same breath as pointing at the tool that covers them.

A dialog titled What would you like to estimate, listing doors, windows, walls and rooms as selectable categories, with a note that MEP, fixtures and sitework are not detected by AI — Scope the run, and read what it will not cover. The manual tool is named in the same sentence as the gap.

After detection, the real work starts

The AI finds objects. It does not know what they cost, and a detected door is worth nothing until it is matched to a priced item in the material library. That matching is where the user actually spends their time, so it is where most of the design went. Detection was the demo; assignment was the product.

The flow handles the whole spread of it: assign one detected door, assign all of them at once, assign scoped to just the ones currently selected, and re-assign when the first choice was wrong. Every one of those is a separate designed state, because in a real takeoff all four happen within a few minutes of each other.

The takeoff panel with detected doors grouped together and an assign action that maps all of them to a library item in one step — Detected objects on the left, priced library items on the right, and the bridge between them designed for one, for all, and for the correction afterwards.

When the library has no answer

The assignment flow has a state for finding nothing, and it does not dead-end. The empty result offers to create the item then and there, in a stacked form that returns you to the assignment you were in the middle of, with the new item already selected.

Where the AI was told to stop

Drawings-only bid packages guarantee non-comparable bids: one sub bids forty doors, another thirty-eight excluding hardware, a third buries doors inside “carpentry”. The tempting answer is to normalize automatically.

We shipped flag-only. The board marks the discrepancy and the general contractor judges it. Normalizing by hand, and then normalizing with AI, were both pushed to later releases.

Four areas, as the evidence

The principle above is only worth anything if it survives contact with real screens. It did, across all four.

The library, reorganized the way estimators think. It was structured by measurement method (Count, Linear, Area), which caused constant mistagging: area items stranded under the Linear tab. I restructured it category-first, validated against CSI MasterFormat, with measurement type demoted to an attribute and filter. Role scoping made one screen serve both audiences: a flooring sub sees a narrow priced library, a GC sees the full catalog unpriced.

Arxion library screen with collapsible category groups such as Drywall, Masonry, Plumbing and HVAC, each item tagged with a measurement type — Categories first, measurement type as a tag. All data shown is fictional demo content.

Reports that never hide the gap. Every line carries one of three explicit tiers: Priced, Assigned but not priced, and Unassigned, with a caveat line spelling out what the total excludes. On margins that thin, a silently dropped item erases the job’s profit.

Project report with summary tiles, per-plan cards and a category rollup where unpriced rows are flagged with a needs-price marker — Priced lines count, unpriced lines are flagged, unassigned objects are called out rather than silently dropped.

A tender, not a chat. Client feedback mid-sprint revealed the GC side was not primarily messaging: a GC runs a tender. I ran a focused discovery pass and designed a leveling board where trades are rows that fill in over time, from “not sent” through “ready to level” to “awarded”.

Bids and Leveling board with trades as rows, sub bids side by side, status per trade and a running awarded total — Each trade row advances through its own state; the board and the leveling sheet are one surface.

Flooring leveling modal comparing three subs per line item, with a flag noting one bid excludes subfloor prep — Per-line leveling with an explicit exclusion flag: the cheapest total is not the cheapest bid.

Communication in its place. An inbox where messages reach subs by email and their replies thread back into the project, so unregistered subs never block the tender.

Inbox with project-scoped threads and a banner noting the sub was reached by email and their replies appear in the thread — Email as transport, Arxion as destination: subs without accounts still land in the same thread.

Making the point of no return explicit

The first award model treated each per-trade award as final. That was wrong: GCs negotiate, split trades and change their minds. The correction made per-trade awards provisional and reversible, and concentrated the binding step in a single Finalize awards flow that notifies subs and issues subcontracts. Because the award control was one shared component, the change propagated through every board state at once.

Finalize awards modal with a three-step flow of review, issue subcontracts and done, summarizing awarded trades against the budget target — One deliberate, binding step. Everything before it can be undone; the modal says so.

The system underneath

Halfway through, the product had a visible symptom of an invisible problem. On one screen the active tab in the secondary navigation had a stubby underline, shorter than everywhere else. It looked like a rendering bug. It was a copy-paste bug: the navigation had been rebuilt by hand on each screen, and on that one the tab had been resized at some point and never put back.

So I made it a component and swapped it into all 19 board screens. The underline was correct everywhere in one pass, and it stays correct, because there is now only one of it. The same move fixed a class of problem I could not have found by looking: the copies had been quietly diverging for weeks, and nobody was going to audit 19 screens by eye.

The payoff shows up on every change after that. When the award control was renamed from “Notify & close” to “Award & notify”, it changed on every board state, drawer and modal at once, because they were all instances of the same button.

The secondary navigation component with its three tab variants, Plans and Takeoffs, Reports, and AI Parser Review, each shown in active and inactive states — The navigation as a variant set. One definition of the active tab, and therefore one underline, across every screen that uses it.

Risk that travels with the thing it describes

The leveling board flags bids that exclude scope. That warning started as a caveat line under the table, which is where warnings usually go and where they are usually missed.

I moved it into a caution badge attached to the sub’s chip, so it sits inside the bid it is about. Now the exclusion travels with that bid everywhere the bid appears: on the board, in the leveling drawer, in the comparison modal. The GC meets the warning at the moment they are comparing numbers, which is the only moment it changes a decision.

The bidding component set: sub chips, status badges, caution badges, buttons and a toast, each with its variants — The bidding atoms. The caution badge sits in the same set as the chip it attaches to, which is why a warning could be moved onto the bid without redrawing anything.

Menus that behave like what they are

The notification popup opened as a centred modal with a dimming scrim. That is the treatment for a decision. Checking notifications is a glance, so I made it a popover anchored under the bell, with no scrim and click-outside to dismiss. The page stays visible because you are looking at the page.

One more rule came out of the same pass: colour lives once. Each alert kept its coloured icon tile, which is what the eye scans for severity, and the badges beside them went neutral grey. A coloured icon next to a coloured badge is the same signal sent twice, and two signals of equal weight make neither of them a signal.

The dropdowns, the package switcher and the More menu all moved to the same popover treatment. That is what makes a product feel like one thing: the same kind of surface behaves the same way, so a user who learns one menu has learned all of them.

Handoff, and the site

Build-ready meant the file, not a slide deck: properties-based components wired across real screens, design-system tokens only, and Dev Mode annotations written once per concept. It also meant knowing when not to systematize. Fifteen kanban cards each carrying a unique plan-thumbnail SVG stayed as plain frames, because a component there would have cost more than it saved.

The last milestone was routed to the marketing site, and there the deliverable changed shape. The scope said one page, designed in Figma, built by their developer. What shipped was five pages, home, contractors, pricing, privacy and terms, designed, built and deployed by me, on the same tokens as the product.

Reflection

Most of what went well was something we decided not to build. Leveling for the wrong user. A second library for GCs. A fake-final award. Automatic normalization. Components for things that appeared once. The research paid for those calls early, which is what let four areas fit into one sprint.

The one I would defend hardest is making every screen work with the AI turned off. It reads like a hedge against a bad model, and it is closer to a description of the job. The AI reads a drawing in seconds. A subcontractor still has to stake their margin on the number that comes out, and that number is the thing they are actually buying.