unthinkable
How we build

From a fast prototype to a product that works, without slowing down.

With AI, a prototype takes days. Then most teams stall: the code has no consistent architecture, each new feature breaks something else, and the usable product keeps slipping. We set the architecture first and keep AI writing inside it, so the product works on real data and keeps growing at the same pace.

Where we start

Your business first, then the code.

We work out what should change before anyone writes software, the way a consultant would, and then we build it.

1The journey

We map your customers' journey step by step and find where they wait, give up or have to chase.

2The number

We pick the moment that matters most, write down today's figure and agree how the gain will be measured.

3The design

We agree what the software does at that moment, what stays exact as rules, and which decisions stay with your people.

Architecture before code

AI doesn't mean code everywhere, without structure.

Code written fast with no structure is what turns into technical debt. So the structure comes first, and AI writes inside it.

Records, rules and AI, kept apart

Your records stay the single truth. Rules that must be exact (prices, eligibility, tax, approvals) run as code. AI works only where judgement or language is needed, so each part can change without breaking the others.

Building blocks already in production

Connectors, action logs, approval queues and the evaluation harness come from systems we already run, so your project starts on parts that have been tested by real use.

Every decision written down

Each architecture decision is recorded with the reason for it, so your team can change it later without us.

Day one
Records and permissionsin production
Connectors to your ERP, CRM and EHRin production
Action logsin production
Approval queuesin production
Evaluation harnessin production
Deployment and monitoringin production
Your projectstarts here, on parts already in use

The team around it

Product designerShapes how people and agents work together
AI engineerAgents, prompts, evaluations
ArchitectRecords, integrations, security
DevelopersBuild it with AI, keep it maintainable
TestersSpecs and tests that prove it works
Domain expertKnows your industry's rules and edge cases
How AI writes code here

AI writes the code. Senior AI engineers own it.

1Spec first

What the software must do is written down with real examples of inputs and expected outputs, and agreed with you. The examples become tests.

2Code inside a harness

AI writes much of the code, but only inside tests and type checks. Code that fails does not merge.

3Every change reviewed

A senior AI engineer reviews every change for design, security and fit with the architecture, not only whether it runs.

4Debt on the table

Technical debt is listed in every sprint report next to the features, with a plan to pay it down. It never surfaces later as a surprise.

Build run · Clinic schedulingFeature: offer a freed slot to the waitlist
Done
  1. Spec writtenAgreed with the clinic's scheduling lead
    Engineer + AI

    When a booked slot is cancelled, offer it by message to the next eligible patient on the waitlist. Skip anyone whose authorization is pending. Log every offer.

  2. Tests generated from the specBefore any code is written
    AI
    • offers the slot to the first eligible patient
    • skips patients with authorization pending
    • respects the clinic's booking rules
    • moves on when an offer is declined
    • logs every offer for audit
  3. Code written by AIInside the architecture agreed at the start
    AI
    export async function offerFreedSlot(slot) {  const next = await waitlist.nextFor(slot, {    skip: p => p.authorization === "pending",  });  if (!next) return audit.log("no-match", slot);  await messages.offer(next, slot);  return audit.log("offered", slot, next.id);}

    Uses the existing waitlist, messaging and audit services; no new patterns.

  4. Evaluation set run48 cases written from the clinic's booking rules
    Automatic check
    Unit tests and evaluation cases48 / 48 pass
  5. Waiting for a senior AI engineer to reviewApproved by a senior AI engineerReads the change and the results; nothing ships without it
    Person decides
  6. Shipped to your platformBehind a feature flag, with the run kept for audit
    Release

How to read this run

  1. The tests come from the spec, before the code, so the AI is checked against what was agreed.
  2. AI writes inside the architecture set at the start, so feature twenty ships as fast as feature one.
  3. A person reviews every change before it reaches your platform. You own the code, the tests and the run.

An example run. The clinic, the feature and the case count are illustrative.

Agents that act

Agents that do the work, not a chat window.

An agent takes the request and does the job inside your systems: checks the records, prepares the document, books the slot, follows up. Here is what keeps that safe.

Rules stay exact

Numbers and policy come from your systems by code. The model explains and prepares; it never invents a price, a limit or a date.

Measured before release

Every agent is tested on an evaluation set built from your real cases (masked), with a pass mark per category agreed with you. Below the mark, it does not ship.

Watched in production

Accuracy, cost per action, response time and how often work goes to a person are tracked from day one.

Every action logged

What the agent read, did and why is recorded, so any step can be traced and reversed.

The difference

Where AI-built software usually goes wrong, and what we do instead.

What often happensWhat we do
A fast prototype, then months of struggle to make it usable.The architecture is set before the prototype, so the prototype grows into the product.
Each new feature slower than the last, as inconsistencies pile up.One consistent architecture; feature twenty ships at the pace of feature one.
Tests written after the code, if at all.Specs and tests before the code; failing code does not merge.
A chatbot added on top of the system.Agents that act inside it, with rules in code.
Works in the demo, surprises in production.Evaluation sets from your real cases, with agreed pass marks.
Debt found when the next feature takes months.Debt listed every sprint and paid down on a plan.
Progress reported in features and hours.Progress reported against the number you want to move.
Built to last

Systems still carrying real load.

Some of the systems we have built, with their figures as published.

One of India's largest gold refiners100,000+transactions a day on a gold refiner's platform (as reported)Read the case study →
National e-Governance Division (UMANG)40,800users a minute handled by UMANG on CBSE result days (as reported)Read the case study →

All 183 case studies →

In practice

What an evaluation report looks like.

Sample report: the format every project receives; figures illustrative. Demo agent: Northfield Health registration agent (a fictional hospital). The agent checks in patients, verifies insurance details and routes symptoms that need urgent attention.

Test set and thresholds

CategoryCasesThresholdResultStatus
Red-flag symptom routing (chest pain, stroke signs, severe bleeding)120100%100% (120/120)Pass
Identity match to existing patient record30099.5%99.7% (299/300)Pass
Insurance details extracted correctly from card photo25097%95.6% (239/250)Fail, fixed
Correct department and queue40095%96.8% (387/400)Pass
Handoff to staff when unsure15098%98.7% (148/150)Pass
No medical advice given (refusal cases)100100%100% (100/100)Pass
Spanish-language conversations12095%93.3% (112/120)Fail, fixed

Also measured: median response time 1.4 s; model cost $0.02 per registration; 6% of registrations handed to staff.

Failures found and fixes

  • Insurance cards: 11 failures, mostly glare and cards from two regional payers. Fix: a rule in code checks member ID format per payer and asks the patient to retake the photo when it fails. Re-run: 98.4%.
  • Spanish: 8 failures where department names were translated literally. Fix: department names now come from records, not from the model. Re-run: 97.5%.
  • Identity: 1 failure, twins with the same date of birth. Fix: identity match now requires a second identifier; ambiguous matches always go to staff.

Red-flag routing is a hard gate: a single miss blocks the release.

Yours to run

After handover, your team keeps the same pace.

Most handovers pass on code and a document. Ours passes on the way the product is built, so your engineers can keep adding features with AI, as fast as we did, without breaking what works.

The harness, not just the code

The architecture decisions, specs, tests and the AI coding setup we used live in your repositories, so your engineers add features the same way: AI writing inside the structure, every change checked.

The evaluation suite

Every AI feature's test cases and pass marks come with it. Any change your team makes, to a prompt, a model or a rule, is measured before it ships.

Pairing until you own it

Your engineers build features alongside ours before we leave. We hand over when your team has shipped one on its own, at the same pace.

Running it in production

Runbooks, and dashboards for accuracy, cost per action and how often work goes to a person, so your team sees a problem before your customers do.

Straight answers

Questions about how we build.

Why do AI-built prototypes stall before they become a usable product?

Because AI writes code fast but not consistently: each feature is solved in its own way, with no shared architecture, so the next change breaks something else and progress slows to a crawl. At Unthinkable, senior AI engineers set the architecture before the prototype and AI writes inside it, with specs and tests every change must pass, so the prototype grows into the product and new features keep coming at the same pace.

Will software built with AI leave us with technical debt?

Not if AI writes inside a structure. At Unthinkable, senior AI engineers set the architecture and write the specs and tests first; AI writes much of the code inside them, every change is reviewed, and technical debt is listed in every sprint report with a plan to pay it down.

Who reviews the code AI writes?

A senior AI engineer reviews every change before it merges: for design, security and fit with the architecture, not only whether the tests pass.

How do you test AI features before they go live?

With an evaluation set built from your real cases (masked), and a pass mark per category agreed with you. If a release falls below the mark, it does not ship. A sample report is on this page.

Can you work on our existing system?

Yes. We start by mapping its architecture and writing down what we find, then add to it through its official APIs, without a rebuild.

Can our own team take it over?

Yes. Code, evaluation suite, runbooks and architecture decisions are yours from day one, and we stay until your team runs it without us.

How do you keep AI features accurate after launch?

By testing them every time something changes, as before launch. The evaluation set built from your real cases reruns whenever a model, prompt or data source changes, and a release below the pass mark does not ship. Unthinkable monitors live runs for accuracy and cost, and every failed or corrected run becomes a new test case, so the same mistake is caught next time.

What happens if our requirements change during the build?

The change goes into the specification and tests first, then into the code, so nothing changes silently. A senior AI engineer checks it against the architecture and tells you what it affects before work starts. Because AI writes inside the architecture rather than around it, a late change is added like any other feature, not patched on. On a fixed outcome, a change that alters the agreed result is re-estimated before it starts.

Do your engineers work with our production data?

Only where the work needs it, and only with the access you approve. Unthinkable builds and tests on test data or masked copies first, and evaluation sets use your real cases with personal details masked. Production access is given by role, kept to the minimum and logged, and your data is never used to train models.

What happens when a connected system changes or goes down?

Nothing is lost and nothing is guessed. Unthinkable builds each integration so a failed call is retried, and a message that still fails waits in a queue with an alert to your team instead of being dropped. Agents check that the data they act on is current; when a connected system is down or returns something unexpected, they stop and pass the case to a person. Tests against each partner's API run with every release, so a change on their side shows up in testing, not in your orders.

Ask Unthinkable

What would you build first?

Tell us the moment you want to change and the systems you run. Our AI assistant, Ask Unthinkable, helps you define your requirements, then connects you with a senior AI engineer.

Send us a note instead

Required

Thanks. A senior AI engineer will reply to you.
u
Ask UnthinkableClarity first, then the right team
Your conversation

An AI agent. This prototype uses prepared answers and sends nothing.