Start / 01Traced
Robin Miklinski — systems & applied AI
I build software that works.
For years I built systems to manage my own overthinking. It became the thing I do best: I notice where something is working harder than it needs to, and I rebuild it so it doesn't — more and more with AI.
01
How I actually work
02
AI you can trust
03
One system, not ten
04
Built to last
- Look one problem, examined
- Explore the ways it could work
- Cut everything that adds no value
- Ship the one lean version
Before I built systems for anyone else, I built them for myself.
Question
Why does so much wasted effort survive? Because no one's questioned it in years — the manual step everyone accepts, the report nobody reads, the workflow still shaped by a tool you stopped using.
System
- See it
- Find where a process, product or workflow wastes time, money or attention.
- Rethink it
- Design the simpler version; use AI where it genuinely earns its place.
- Build it
- I'm hands-on. I ship the working system, not a slide deck.
- Prove it
- Leave the reasoning visible, so the result can be trusted rather than taken on faith.
This shows up as consulting and automation work, or as a senior operator inside a team — product, operations, systems. Same skill either way.
Decisions
- Question the default. Most inefficiency is just an unexamined habit.
- Simpler beats clever. The best system quietly disappears.
- AI where it earns its place. Not as decoration.
- Build it, don't deck it. Hands on the code, not just the slides.
Proof
Before anyone paid me to do it: an automated music pipeline, an agentic workspace I run my whole operation from, and a command-center that keeps the overthinking out.
Real, mine, inspectable — the same instinct pointed at my own life first.
Outcome
The offer, without the jargon: I see how things could work better, and I build the system that gets them there. If something you run feels heavier than it should, that's usually where I start.
A demo is easy. I build the version that's safe to act on.
Question
A convincing answer out of a model is the easy part now — it's no longer rare. The hard part is making it safe to act on when it's confident and wrong, unsupported by the evidence, or deciding something it shouldn't. That's the part the market is short of.
System
- Propose, don't execute
- Anything that affects someone outside the system is drafted for a human to approve — never sent automatically.
- Escalate by default
- When the input is unusual, sensitive or out of scope — or the model errors — it hands off instead of guessing.
- Provenance on every output
- Each result records what produced it: model, version, cost, the evidence it used. Nothing is taken on trust.
- Evidence beside the answer
- The generated interpretation sits next to its source, with the trust boundary shown, not hidden.
Decisions
- A confident wrong answer is the failure mode. Design for it before the happy path.
- Human-in-the-loop is the product. A fast proposal to approve in seconds, not unattended autonomy.
- Authority is earned. I demoted a classifier of my own to "suggestion only" when it wasn't reliable enough.
- Cost and behaviour are inputs — including what the software does when the model is uncertain or wrong.
Proof
My own systems, running: an agentic workspace I operate from every day, where the AI drafts and I confirm; a draft-only assistant pattern that structurally cannot send, only propose; and a classifier I trusted enough to strip of its authority when it fell short.
Real, mine, inspectable — the reliability layer is the thing I actually build.
Outcome
The model treated as one component, wrapped in the evidence, boundaries and human control that separate a compelling prototype from software you can run an operation on.
Your tools, files and email in one place you run from.
Question
Most small operations run on a pile of tools that don't talk to each other. Everyone can already point to where the money leaks — the thing done but never recorded, the request answered too late to matter, the version that was already out of date. How do you turn that sprawl into one system people act from, without hiding the real complexity?
System
- One source of truth
- The system holds the record — not the file store. Everything else reads from it.
- Every change logged
- Who, what, when — recorded in the same breath it's made. The trail settles the argument later.
- AI drafts, a person confirms
- No silent automatic decisions on anything that costs money.
- A "what needs me today" view
- What's at risk, what you're waiting on, what's yours to move — ordered by action, not by feature.
Decisions
- Derive, don't ask twice. A total, a due date, a variance — computed, never re-entered by hand where it can drift.
- Never guess the "latest". A confident wrong pick costs real money; making it a logged human act is the safety.
- Read first, write late. Connect to the tools people already use to read from them well before writing back.
- Boring on purpose. Every clever moving part is a future failure at 3am.
Proof
An inspectable synthetic model — invented sources, records and scenarios, all synthetic — showing messy inputs resolving into one audited record and a three-state view (hold / review / act) you can trace from raw input to recommended action and back to the change that caused it.
Outcome
The pattern I use to replace tool-sprawl with a single dependable system of record. Built entirely with synthetic data — it stands in for no client and claims no result. What it shows is the method: make the operation legible, keep every change accountable, put a person in front of anything that matters.
Ambitious software, on any screen, made to keep working.
Question
Working and lasting are different things. Plenty of software looks right in the demo, then breaks on a phone, slows down under load, or loses the plot as the team grows. The job is taking something ambitious all the way — from a rough idea to software that works on every screen and still works a year later.
System
- Shape it, then build it
- Product thinking, architecture and code as one job, not a hand-off, so the idea survives to production.
- One standard everywhere
- Web, mobile and back end held to the same bar. Full parity on mobile, not a cut-down version.
- The system enforces the rules
- What must stay true is checked automatically. A regression fails the build, not a user.
- Close to the code
- I set direction and still open the editor, so decisions match how the thing actually behaves.
Decisions
- I don't stop at a prototype. From the idea to the thing people actually use.
- Simpler beats clever. The best system gets out of the way.
- Every guard is a scar. I add a check because something broke once.
- Range is the point. Hard problems cross boundaries; I work across all of them.
Proof
My own published component library — accessible building blocks, automatic guards, a real release before anything ships. The same standard carried onto mobile. And this site: a live, accessible, fast piece of motion engineering you're reading right now. Fifteen years across defence, retail, collaboration software and global SaaS under it all.
Outcome
I take ambitious software the whole way — direction to code, web to mobile to back end — and build it to hold. No client named, no result invented.
Fifteen years of making complicated things simple.
Background
Fifteen years across defence, retail, collaboration software and global SaaS — always drawn to the same kind of problem: something complicated that everyone stopped questioning years ago. I find the simpler version underneath and build it.
I'm hands-on by choice. I still open the editor, still ship the thing myself, and still check that a system actually holds up rather than just looking like it does.
Outside work
I produce electronic music and DJ. Different medium, same instincts — signal flow, iteration, and knowing when something is actually finished.
What could work better?
What are you trying to make, improve or run with less friction?
Start a conversation →