Product design and UX for AI
Flows that show what the AI did, how sure it is and how to fix it, designed with the people who will use them.
Discipline09 · Software Engineering
In shortUpdated 30 Oct 2026 · Labs 24 FDE Squad
AI software development at Labs 24, in short
AI software development is building the full product around an AI model: the web and mobile apps people use, the screens where they review and approve AI output, sign-in and roles, APIs, tests and the release pipeline. Labs 24 does it with forward deployed engineers who sit with the users first, so the software fits the way the work is really done.
- Builds
- Web apps, mobile apps, review and approval screens, admin consoles, internal tools, APIs and SDKs
- Approach
- Watch the users, prototype, ship one thin slice to real users, then widen it
- Quality
- Code review, automated tests, typed APIs, accessibility checks and CI/CD on every change
- Ownership
- All code in the client's repository, with documentation and full IP transfer
- Stack
- TypeScript, React, Next.js, React Native, Flutter, Node.js, Python, FastAPI, Postgres, Playwright, GitHub Actions
- Also
- Modernising older systems so AI features can be added safely
01 / What it means
A demo shows the model works. A product shows people can use it.
Most AI pilots stall after the demo. Not because the model fails, but because there is no screen to check its work, no sign-in, no way to fix a wrong answer and nothing that survives bad input. That part is software engineering.
Built beside the people who will use itAI demo
- Works on the five examples it was shown
- One shared login, or none
- No way to correct a wrong answer
- Lives on one engineer's laptop
AI product
- Handles messy, missing and unexpected input
- Roles, SSO and an audit trail
- Review screens where people approve or fix output
- Tests and a release pipeline on every change
- Code and docs your own team can run
02 / Capabilities
AI software development capabilities.
Eight parts of the product we own end to end, from the first sketch to the code your team inherits.
Web applications
Fast, accessible web apps for customers and staff, with streaming AI responses and clear loading and error states.
Mobile apps
iOS and Android apps for field teams and customers: camera capture, offline mode, push notifications and on-device checks.
Review and approval screens
Human-in-the-loop queues where people check, edit and approve AI output, with every decision feeding back into evals.
Internal tools and admin consoles
Consoles for managers and IT: roles, settings, prompts, usage and cost, so the business runs the system without engineers.
APIs and SDKs
Documented, versioned APIs and webhooks so other systems and partners can use the AI safely.
Testing and quality engineering
Unit, integration and end-to-end tests, plus accessibility and performance checks that run on every change.
Modernising existing software
Untangling older systems behind clean interfaces, so AI features can be added without risking what already works.
03 / Demo to product
What separates an AI demo from an AI product.
A demo ticks three boxes. A product people rely on ticks all twelve. Tick the boxes to see how far a typical pilot really is from launch.
The demo
People and access
Real-world input
Run it
Readiness
25%
DemoPilotBetaProduct
Demo: works on the happy path
9 gaps left. These are what a forward deployed squad builds.
04 / What we build
The software around your AI.
Every AI system needs places for people to use it, check it and manage it. These are the ones we build most often.
| Surface | Who uses it | What it does | Built with |
|---|---|---|---|
| Review queue | Operations team | Check, edit and approve AI output before it goes out | React, Next.js |
| Field app | Drivers, field staff | Capture photos and documents, work offline, get alerts | React Native, Flutter |
| Admin console | Managers, IT | Roles, settings, prompts, usage and cost | Next.js, Postgres |
| Customer app | Your customers | Self-service, chat, status and history | Next.js, WhatsApp |
| API and SDK | Partners, developers | Use the AI from other systems, with keys and limits | REST, webhooks, TypeScript |
Engineering standards on every build
Code review
- Every change reviewed by a second engineer
- Small, readable pull requests
Tests
- Unit, integration and end-to-end
- AI evals beside the code tests
CI/CD
- Automatic checks on every change
- One-click rollback
Typed APIs
- TypeScript end to end
- OpenAPI contracts
Accessibility
- WCAG 2.2 AA as the target
- Keyboard and screen reader checks
Docs
- Setup, architecture and runbooks
- Written for your team, not ours
05 / How it ships
Watch, shape, ship a slice, harden.
We build the smallest useful version first and put it in front of real users, then widen it. Every Friday you see working software, not slides.
Shipped with the team that will own itStep 01 · Watch
Sit with the users
Engineers shadow the people who do the work and map where the AI helps and where it gets in the way.
- User journeys
- Pain points
- Success measures
Step 02 · Shape
Prototype the flow
A clickable prototype tested with real users, plus the design system and API contracts the build will follow.
- Clickable prototype
- Design system
- API contracts
Step 03 · Ship a slice
One slice, real users
The thinnest end-to-end version goes live for a small group of real users, with tests and monitoring from the start.
- Live slice
- Friday demo
- Feedback loop
Step 04 · Harden
Widen and hand over
More users, more edge cases, full test coverage and documentation, then a handover your team can run with.
- Full rollout
- Runbooks and docs
- Handover session
06 / Stack
The software stack we build on.
Mainstream, well-supported tools, so your team can hire for them and keep building after handover.
Web and mobile
TypeScriptReactNext.jsTailwindReact NativeFlutterFigma
Services and data
Node.jsPythonFastAPIPostgresNeonRedisOpenAPI
Quality and delivery
PlaywrightVitestGitHub ActionsDockerSentryFeature flags
Queues, workflows and the services behind these screens are covered in Backend Engineering.
07 / In production
AI products in production.
Under NDA, so clients stay unnamed. Each one runs on the client's own infrastructure with full IP transfer.
Driver app with document capture
A mobile app that reads delivery paperwork from a photo, works offline and sends unclear cases to a review queue.
Mobile and review queue
Clinic front-desk console
Staff see AI-drafted replies and bookings in one screen, approve or edit them, and every change is logged.
Human in the loop
Merchant self-service portal
Merchants upload catalogues, AI cleans and tags them, and merchants approve the result before it goes live.
Self-service portal
08 / The squad around it
Software engineering is where the squad's work meets the user.
Every other discipline ends up on a screen, an app or an API. This is the team that builds them.
01
Agent Engineering
Agents whose work people review here.
02LLM Engineering
The models behind every feature.
04Evals & Reliability
User corrections become test cases.
05Production & Cloud
Where the apps run.
06Integration
The systems the screens read and write.
08Backend Engineering
Services and queues behind the screens.
09 / FAQ
AI software development FAQ.
What is AI software development?
AI software development is building the full product around an AI model: the web and mobile apps people use, the screens where they review and approve AI output, sign-in and roles, APIs, automated tests and the release pipeline. The model is one part; the software decides whether people can actually rely on it.
Why do AI pilots fail to reach production?
Most stall for software reasons, not model reasons: no screen to check or fix the AI's output, no sign-in or roles, no handling for messy input, no tests and no release pipeline. Labs 24 builds those pieces so the pilot becomes a product people use.
What does an AI software development company build?
Labs 24 builds web applications, iOS and Android apps, human-in-the-loop review and approval screens, internal tools and admin consoles, APIs and SDKs, and the tests and CI/CD around them, with forward deployed engineers who work beside the users.
Do you build mobile apps with AI features?
Yes. Labs 24 builds iOS and Android apps with React Native or Flutter, including camera and document capture, offline mode, push notifications and review flows for cases the AI is unsure about.
What is a human-in-the-loop interface?
It is a screen where people check, edit and approve what the AI produced before it takes effect. Good ones show what the AI did, how confident it is and why, make corrections quick, and feed every correction back into the evaluation set.
What tech stack does Labs 24 use for AI products?
Usually TypeScript, React and Next.js for web, React Native or Flutter for mobile, Node.js or Python with FastAPI for services, Postgres for data, and Playwright, GitHub Actions and Sentry for quality and delivery. The stack bends to what the client's team already runs.
Who owns the code?
The client does. All code lives in the client's repository from the first commit, with documentation, runbooks and full IP transfer, so their own team can keep building after handover.
What are the steps in an AI software development engagement?
Labs 24 watches how people do the work, shapes the flow in a clickable prototype tested with real users, ships one thin end-to-end slice to real users, then widens it, hardens it with tests and documentation, and hands over.
Can you add AI to our existing software?
Yes. Labs 24 puts clean interfaces around the parts of the existing system the AI needs, adds the new features behind feature flags, and modernises step by step so what already works keeps working.