I don’t hand over slides. I build the thing — deployed, testable.
Five projects. Each one answers the same question in a different domain: where does a person stay in the loop, and where has an agent earned the right to act alone? Three of them are running. Two are concepts, and they are labelled as concepts.
Someone reads the product once, writes it up, and the write-up starts going stale the same week. That is what accessibility work usually looks like. An agent could run continuously instead — but only across the part of WCAG that is actually machine-decidable. Drawing that line is the whole design problem, so I drew it before building anything: all 55 criteria, classified by what an agent can be trusted to decide.
WCAG 2.2 at levels A and AA is 55 success criteria. They are usually treated as one undifferentiated checklist, which is what makes accessibility feel like an unbounded chore.
They are not one kind of thing. Some — colour contrast, name-role-value, page language — are fully decidable by a machine. Some can be detected but not judged: a tool can find an image with no alt text, but it cannot tell you whether the alt text that is there is any good. And some are pure judgement: meaningful sequence, consistent identification, error suggestion.
An agent built without that distinction will mark a page as passing when it is not — and a false pass is worse than no audit at all, because a gap eventually gets found while a false pass just gets trusted.
Sole author of the concept and of the artefact below. This is my own work, unshipped.
The coverage matrix is the deliverable I would take into a build. It defines the agent's permission boundary before a line of the agent exists.
Owns judgement and intent.
The matrix is the contract.
Runs continuously, inside the boundary.
WCAG 2.2, levels A and AA. Filter, search and sort it.
Those three figures are out of 56 classified paths, not 55 criteria. Where the honest answer depends on the situation, a criterion is classified once per scenario and therefore appears in more than one class.
Showing 55 of 55 criteria.
55 of 55 classifications reviewed.
| Why | |||
|---|---|---|---|
| Non-text Content | A | Detecting a missing alt attribute is trivial. Judging whether the alt text conveys the same purpose is not. | |
| Audio-only and Video-only (Prerecorded) | A | The presence of an alternative can be checked. Its equivalence cannot. | |
| Captions (Prerecorded) | A | A caption track's presence and timing are checkable. Accuracy needs a person. | |
| Audio Description or Media Alternative (Prerecorded) | A | Requires watching the content and deciding what visual information a listener loses. | |
| Captions (Live) | AA | Live output cannot be evaluated before it exists. | |
| Audio Description (Prerecorded) | AA | Requires judging what a sighted viewer receives that a listener does not. |
How the classification becomes a permission boundary.
The coverage matrix is the input, not documentation about the input. Each of the 55 criteria carries its permission class, and that class is what the factory reads.
One narrow agent is generated per criterion from a shared template: a detector, a patcher, and an evidence writer. A criterion classified manual gets a detector and a router — no patcher is generated at all.
The agents run per commit rather than per quarter. Each one has a single testable definition of correct, so a regression points at one agent instead of at accessibility in general.
Not every accessibility issue should be fixed by an agent. Some fixes are mechanical. Others need someone who understands what the page is for. So the agent’s permissions depend on the kind of issue, not on how confident it feels about one.
The highest authority this agent has stops before the merge. There is no class that lets it change the product on its own.
And this isn’t an instruction the agent is asked to follow. The class decides what gets built: an agent for a manual criterion is generated with a detector and a router and no patcher at all, so there is no code path that could mark it passed. A capability that needs judgement is never handed over in the first place.
Classify conservatively. When a criterion is arguable, it drops to manual.
An Agent Factory of narrow, single-criterion agents rather than one general accessibility agent.
The agent confidently changes something that needed context, and the page ends up less accessible than it was.
Ten minutes before a class, an instructor is still assembling the set. Ninety seconds into it, they are riding it live, with a room watching. Generating a good playlist for indoor cycling turned out to be straightforward. Serving the same person in both of those states — authoring and operating — did not.
Indoor Cycling Stuttgart runs strength rides: music mapped to a ride structure, with cadence, intensity blocks and leadership cues. Building one by hand is an hour of work.
The operating conditions are the real constraint. Instructors finish a set minutes before a class, in a studio, on a phone, with a room filling up. Then the class starts and the context inverts: they are no longer editing, they are executing, in front of twenty people, with no attention to spare.
A single interface that serves both states serves neither.
Product design and build. Sole designer and engineer.
Responsible for the generation model, the studio interface, the Ride Mode split, and the deployment you can open below.
Stays the author.
Two seams, not one.
Proposes structure, keeps time, commits nothing.
Two modes, and what each one puts within reach.
An instructor has two jobs that never happen at the same time: building a session, and running it in front of a room. So the app has two modes, and they don’t have the same powers.
| Capability | Authoring | Ride |
|---|---|---|
| View | Available | Available |
| Navigate | Available | Available |
| Modify | Available | not offered |
| Delete | Available | not offered |
A confirmation dialog still allows an unsafe action. It just adds a step in front of it. In Ride Mode, editing isn’t hidden behind a warning — the mode doesn’t put it in reach at all.
The system can suggest changes to a session. Nothing goes in until the instructor accepts it.
The read-only Ride Mode deployment, embedded.
The demo is a full application. It is loaded on request rather than on page load, so embedding it does not cost this page the performance it claims. It opens in read-only Ride Mode.
This is the real deployment, not a recording. Ride Mode has no write capability, which is what makes it safe to hand to a stranger. The accessibility of the embedded application is outside this page’s control — if the frame does not load, use the direct link.
Ride Mode is strictly read-only. No edit, no save, no delete — the mode doesn't put them in reach.
Accept that cost rather than softening the boundary.
Mid-ride, under load, the instructor taps the wrong thing and changes the session.
A system that serves people should get better the longer it runs. This one isn't allowed to know who anyone is — no profiles, no identifiable personal data. That leaves two questions open, and they are the whole design: how does it learn anything at all, and who decides what it learns?
What a place like this sells is specificity — a particular register, a particular set of things it would and would not say. That register is the asset, and it is the first thing a language model erodes. An assistant trained toward helpfulness drifts toward the mean of everything ever written in the field. The drift is slow, individually invisible, and nobody notices until the place no longer sounds like itself.
Reviewing every response would catch it, and would also destroy the speed that makes the assistant worth having. Reviewing nothing lets it compound.
So it never asks the team to write anything down while they are working. It learns from four quiet signals: what people ask for, which anticipations get accepted, which get declined, and how the rhythm shifts by suite and by time of day. The one active input window is the briefing before the shift, when nobody is with anyone yet.
Two loops carry that. In the request loop, something is asked, the system prepares, the team acts — fast, and in the moment. In the calibration loop, the CodeKeeper looks at patterns and drift over a longer stretch and decides what the system should do differently. It is slow, and it sits outside the request path.
Sole author. This is a governance model, not a shipped product.
The contribution is the third option between per-request review and no review at all.
Keeps the moments that carry the reputation.
Outside the request path, inside the calibration path.
Absorbs volume.
Where the CodeKeeper sits, and where it deliberately does not.
Someone asks for something. Thousands of times a day.
The system responds inside the register it currently holds.
The person being served has it before they notice waiting.
Closes on the person being served, with no human anywhere in it.
A slice of what actually went out — never a single response. At that resolution every answer looks fine.
Drift only has a shape at volume. One reply is never wrong enough to notice; two hundred are.
The register moves back before the gap compounds. Nobody waited for this.
The correction lands in the system above, then the loop samples again. It never touches a live request.
The one gate between what the system observed and what it does next.
Nothing moves from data into behaviour on its own. Every proposed change reaches the CodeKeeper as three things, and the answer is explicit — there is no default.
The calibration log keeps every one of those answers, so any change in the system’s behaviour can be traced back to the observation behind it and the person who accepted it.
System and CodeKeeper calibrate each other. The decisions stay with the person.
When several sites run the same system, they share patterns and never personal data.
Where the pattern applies: anywhere people can’t document while they work, and a learning system still has to hold a standard.
The CodeKeeper sits outside the request loop and calibrates in batch, not per response.
Name it as a role a person holds, not as an automated eval.
The system learns something that fits the data and is wrong for the place.
Every variant of a product image used to cost another location, another crew and another day. Northlight replaces that with a Node.js pipeline on fal.ai, Blender scenes as geometric reference, and a structured split between cheap probing and expensive production. For a large class of product imagery, the shoot stops being necessary.
Brand and product imagery is produced through shoots: location, crew, set, schedule. Every variant — another angle, another colourway, another season — costs another setup.
Generative models can produce the image. What they cannot do unsupervised is produce the same product, at the same angle, under the same light, two hundred times. Consistency is the entire job, and it is the thing prompting is worst at.
The design work, then, is subtractive: deciding how much of the model's freedom to remove.
Built the system. Pipeline architecture, the Blender reference method, and the probe/production structure.
Working and in use — the twelve frames below are real output from it, not mock-ups.
Art direction, upstream.
The Blender scene is the contract.
Generates at two tiers.
What the reference fixes, and what the model is left free to vary.
Generative models are good at variation and bad at holding still. So everything that makes the product recognisable is fixed by a 3D reference before the model is asked for anything. Autonomy is only useful inside a space someone deliberately limited.
| Human locked | AI exploration |
|---|---|
| Camera | Surface |
| Framing | Material response |
| Proportion | Atmosphere |
| Light direction | Grain |
The boundary is geometric, so it can be checked rather than argued about: the geometry either matches the reference or it doesn’t.
Checked is not the same as enforced. Nothing in the pipeline refuses a render that skipped the probe pass, and under time pressure that is exactly where it gives.
Twelve production frames. Pick one to see it large.
One product, one geometry, twelve rooms. Every frame here would have been a separate shoot — a separate location, set, crew and day. None of them was photographed.
Constrain every generation with an explicit 3D reference instead of prompting for composition.
Split every job into a probe pass and a production pass.
Designing a slide master that carries a brand is straightforward. The one I built shipped clean, looked correct, and was wrong in 48 of its 115 text roles — every box measured against a line height that no real font produces. Nothing appeared broken, which is exactly why it would have survived. What the system is built around now is the measurement that catches that.
A template does not hold a brand. PowerPoint hands every user a surface and a set of handles, and the drift starts on the second deck: a headline nudged down two points so a sentence fits, a colour picked out of an older file, a margin set by eye. Nobody breaks the system deliberately. It erodes.
So the slide stops being a surface someone arranges and becomes an artefact the brand definition compiles. One definition holds colour, type scale, grid and lockups. Twenty-nine layouts read from it. No layout carries a value of its own, and type sizes are fixed — nothing scales to fit, because auto-fitting text is the reason deck families come apart. Each slide finds its own size, and after three editors the series is gone.
That decision is the whole system, and it is the one that failed quietly. Line spacing was expressed as a percentage — of the font's line height, not of the type size, which is what the layouts had assumed. Inter Tight carries 1.21 em, a serif more like 1.30. Every box in the set was therefore around twelve percent too tight for what it was meant to hold, and six roles could not fit a single line of their own style. The text did not clip. It grew into its neighbour.
Fixing the six visible cases would have been the wrong repair. Line spacing is now absolute: type size times factor, resolved before the file exists and independent of which font the recipient has installed. Every box holds its designed line count again, and not one box was enlarged. The price is real and worth stating — absolute spacing ignores font metrics, so a face with unusually tall ascenders will set tight. That is a visible error rather than a counted one, which makes it the better of the two.
Sole author. The brand definition, both stages of the pipeline, and the measurement underneath them.
Delivered and in use. The artefacts below are rendered from that build with an invented brand substituted for the client's — the geometry is untouched, only colour and typeface change.
Owns the definition and the words.
One file is the contract.
Builds the master, then sets content against it.
All 26 content layouts out of one definition, with the measured type scale beside them.
Neutral blind content. Two roles are set exactly on their measured budget, so the limit is visible rather than claimed.
Fix every type size and remove auto-fit entirely.
Express line spacing as an absolute value in points instead of a percentage.
Repair the cause rather than the six roles anyone could see.
Keep the generator and the deck that consumes it in separate repositories.
In closing
A deck can describe an interaction model. It cannot be operated. Everything on this page that claims to work can be used right now — filter the matrix, load the live product, open any frame in the series. Nothing is a screenshot of something that exists elsewhere.
The same standard applies to what isn't finished. Two of these five are concepts. They say so at the top, not in a footnote.
On my own, I hold the whole chain — framing the problem, designing the system, building it. In my professional work, I design complex B2B and enterprise products together with product, engineering, business and international delivery teams. Both are how I work: taking an unclear idea to something you can use, and developing complex products inside an organisation where that chain is shared.