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.
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.
We map your customers' journey step by step and find where they wait, give up or have to chase.
We pick the moment that matters most, write down today's figure and agree how the gain will be measured.
We agree what the software does at that moment, what stays exact as rules, and which decisions stay with your people.
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.
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.
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.
Each architecture decision is recorded with the reason for it, so your team can change it later without us.
The team around it
AI writes the code. Senior AI engineers own it.
What the software must do is written down with real examples of inputs and expected outputs, and agreed with you. The examples become tests.
AI writes much of the code, but only inside tests and type checks. Code that fails does not merge.
A senior AI engineer reviews every change for design, security and fit with the architecture, not only whether it runs.
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.
- Spec writtenAgreed with the clinic's scheduling leadEngineer + 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.
- Tests generated from the specBefore any code is writtenAI
- 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
- Code written by AIInside the architecture agreed at the startAI
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.
- Evaluation set run48 cases written from the clinic's booking rulesAutomatic checkUnit tests and evaluation cases48 / 48 pass
- Waiting for a senior AI engineer to reviewApproved by a senior AI engineerReads the change and the results; nothing ships without itPerson decides
- Shipped to your platformBehind a feature flag, with the run kept for auditRelease
How to read this run
- The tests come from the spec, before the code, so the AI is checked against what was agreed.
- AI writes inside the architecture set at the start, so feature twenty ships as fast as feature one.
- 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 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.
Numbers and policy come from your systems by code. The model explains and prepares; it never invents a price, a limit or a date.
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.
Accuracy, cost per action, response time and how often work goes to a person are tracked from day one.
What the agent read, did and why is recorded, so any step can be traced and reversed.
Where AI-built software usually goes wrong, and what we do instead.
| What often happens | What 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. |
Systems still carrying real load.
Some of the systems we have built, with their figures as published.
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
| Category | Cases | Threshold | Result | Status |
|---|---|---|---|---|
| Red-flag symptom routing (chest pain, stroke signs, severe bleeding) | 120 | 100% | 100% (120/120) | Pass |
| Identity match to existing patient record | 300 | 99.5% | 99.7% (299/300) | Pass |
| Insurance details extracted correctly from card photo | 250 | 97% | 95.6% (239/250) | Fail, fixed |
| Correct department and queue | 400 | 95% | 96.8% (387/400) | Pass |
| Handoff to staff when unsure | 150 | 98% | 98.7% (148/150) | Pass |
| No medical advice given (refusal cases) | 100 | 100% | 100% (100/100) | Pass |
| Spanish-language conversations | 120 | 95% | 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.
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 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.
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.
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.
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.
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.
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
An AI agent. This prototype uses prepared answers and sends nothing.
We use essential cookies to run this site. With your consent we also use analytics cookies to see which pages help. Privacy policy