The apps actors use on screen are not the real apps.
They are replicas built by hand for each scene.
UiFilm makes them real.
Designed and built by one person, with AI.
An industry without a method.
Working on film sets, I've seen the same problem over and over: on-screen fiction. It creates friction from pre-production through post-production, and every phase has its own. Every production, a bottleneck.
At its core, it's a method problem. There is no shared system: every freelancer brings their own tools, and every art department has to learn them. Every production starts from scratch.
I own the entire cycle at once: research, product architecture, flows, the design of the dashboard and the actor's app, the design system, the code, and the launch.
I built it with Claude Code as the main agent and DeepSeek TUI in the terminal for some custom screens, through agentic engineering, not vibe coding: AI implements; architecture, quality and what ships to production are my responsibility. An external engineer reviewed the architecture and security.
Context engineering: before each task, the AI reads what's relevant (the feature spec, the architecture, the licensing or privacy rules), each document covering one thing, with exact data.
Human oversight (human-in-the-loop): I check that it has understood the use case before it proposes anything, and there are rules it never breaks, like never changing any configuration without confirmation. Every decision is written down, with flows mapped in a Mermaid product map, and each agent logs its own status, so we know who did what. No session starts from zero.
A web dashboard, a real-time server, two native apps and 20 screen types, built on React, TypeScript, Node.js, SQLite and Capacitor. Used on 13 shoots in 8 months, on top-tier productions for Netflix, HBO Max, Prime Video and the BBC.
We recently became two: a partner provides remote on-set support. Everything that used to live in one person's head is now written down, and we both work from the same context.
No
public data,
so: conversations.
There was no public data on how screens are made for film and TV. The industry is small and the processes are handcrafted: each production handles them its own way, with no shared documentation.
Qualitative user research: interviews with working professionals across several departments. Art department as the direct potential customer. Directing, script supervision and post-production as those who feel the problem across the board.
In synthesis, I grouped the findings by type of pain, project phase and affected department. That separated two dimensions of the problem: the recurring pain of the potential customer and the cross-functional pain that confirms the scope.
Where the two overlapped defined the priority use case for the MVP: messaging apps. High frequency, high friction, impact across multiple departments.
When I started, the competitive benchmark turned up no direct references. The space was practically empty.
Today there's Film Phones, with a different approach: pre-programmed sequences triggered over Bluetooth. UiFilm starts from another premise: live control in real time.
Knowing where each one stands defines how the product is positioned.
Only what's essential.
UiFilm is establishing itself in the Spanish film and TV industry: 13 shoots in 8 months, productions for Netflix, HBO Max, Prime Video and the BBC, and its own business model, with per-production packages and a watermarked trial mode.
Getting here was a product decision. The initial vision tried to cover everything and required a development team before proving anything. I chose a different model: build the product with AI-assisted development and validate it on real shoots from day one. AI didn't replace a team: it made the product viable.
That model demands rigorous prioritization. Research defined the core, messaging apps, where the actor has to read, type and react on camera. Everything else was added when a shoot justified it: today there are 20 screen types.
The core is designed to scale: each character has two names, the one the actor plays in the scene and the one of the contact they're talking to, and everything configured is a single source of truth read simultaneously by the preview, the live control and the on-set phone.
Nothing gets built without a spec first (spec-driven). AI implements; decisions, review and accountability are human, and an external engineer reviewed the architecture and security. When the product needed a second person, she joined an already documented system, with her own workstream and approval required on shared code.
A screen directed live.
Other tools trigger pre-programmed sequences. In UiFilm, someone on the crew plays the other side of the conversation live, from a laptop or a tablet. If the actor improvises, so does the screen.
The dashboard and the on-set phone talk over a real-time channel (Socket.io), with under 200 ms response time. The phone is always a native iOS and Android app, built with Capacitor with the web inside: it updates without going through the app stores and rolls back to the previous version on its own if something fails. The hard part wasn't the code, but getting the AI to understand the use case: every delay shows on camera.
Both sides connected in real time. That's UiFilm.
What
the shoot
teaches.
Every shoot works as a usability test in real conditions: it brings a complex problem, and the answer is always a simpler flow for whoever is on set. Since I design and build it myself, what I learn reaches the product with no handoff to development.
Time and battery are adjusted from the on-set phone itself: only the props person is needed, and the shoot doesn't wait for whoever prepared the sequence.
The change travels as a separate override that doesn't overwrite the dashboard settings, is flagged, and can be reverted from there. It's a written rule the AI follows in every new feature: what the set changes never overwrites the dashboard.
A take is repeated many times, and not always from the beginning. The phone's menu has anchor points to start wherever the director asks.
In custom screens, each anchor can carry its own fictional time, with no timers: wherever you jump, the on-screen clock matches the scene.
The phone is handled by the art department, at the 1st AD's call, and the controls had to be out of everyone else's reach. They live behind a two-finger double tap.
The gesture passes four filters (two fingers at once, under 350 ms, under 20 px of movement, and two taps in a row) so it's never mistaken for a pinch or an actor's tap, and it works the same inside every custom screen.
Some sets have no coverage. The latest Android version downloads each sequence and runs it on the phone itself; when the signal returns, it syncs the settings without changing what the camera sees.
Before a single line of code there was a feasibility study, the discarded alternatives and the decisions, all in writing. It's in testing.
Any screen
the script
calls for.
Beyond chat, UiFilm produces custom screens for each script: maps, search engines, digital news, a file explorer with its own fictional operating system, a lighting panel for iPad. They are real websites, which is why the actor and the camera experience them as real apps.
All 20 run on the same engine, which sends them the sequence's time, date, battery and coverage, whether on a phone, a tablet or a computer. Some have AI built in, like a real-time voice translator built with the OpenAI API: it recognizes speech, translates and replies with a synthetic voice.
A new custom is a folder and a spec sheet: when it's published, the sequence creates itself, without touching shared code. That way two people can build screens at the same time.
Publishing is a push: GitHub Actions deploys automatically. Anything touching shared code doesn't ship on its own: it waits for my approval before going live. And custom screens are also a business decision: they reach productions that shoot with UiFilm without having to decide to try it.
A screen that gets filmed has its own rules. We learned them on set.
Every custom starts with the same questions: operating system, time, battery and coverage, and what happens screen by screen. Without those answers, building doesn't start: the spec comes before the code.
It's reviewed on the dashboard, inside a phone, and when it's assigned to the production company, its code and QR are generated. The crew opens it on the on-set phone, but can't edit it.
If a screen is filmed five times, all five have to look exactly the same. Nothing is random: everything that moves comes from a fixed seed. The time is never written into the screen; it comes from the sequence. No text goes below 12 px, because on camera it turns into grain.
These are the project's guardrails: written rules the AI follows in every new custom, so what's learned on one set doesn't depend on someone remembering it.
Screens are exported as vectors for VFX, in layers and with every block named. That's why they only use system fonts that don't get outlined on export: a variable font would reach post-production converted into shapes.
The vector file is exactly what was filmed: any touch-up is done on the original, not on a screenshot.
Every screen ships with its clearance report (map and font licenses, owned and production-company material, fictional elements) and with a usage license that never changes once issued and is verified on a public page that only shows non-sensitive data.
Privacy by design: before storing any new personal data or adding a vendor, the privacy rules are reviewed, terms acceptance is logged with its version, and activity logs are deleted after 12 months.
Some custom screens · try them
What powers
UiFilm
under the
hood.
Color for the set:
Dark by default, yellow where you need to look.
The system lives in code, as tokens. Claude Code is not allowed to use one-off values: every color, spacing and type style comes from the system. That's how every new screen stays consistent with the ones before.