What I’ve built with AI, so far.
This is the working map behind my AI practice: the systems, skills, agents, apps and workflows I use day to day. Most grow from the same foundation, a local-first operating layer for an AI assistant I own, and each useful build feeds the next.
Confidential material is excluded.
The rules I hold myself to, in every build below. You’re welcome to hold me to them too.
You own your tools, your data, your voice and your future. My work runs on my own machine, in plain files I can read, version and keep. Private things stay private by architecture.
The less a tool depends on, the less there is to break. I start with one plain file and nothing to install, and I don’t add a framework until the job needs one. One accent colour, one job per screen, same rule in the code.
Run it, click it, break it, then say so. If a tool touches money it speaks in scenarios, and anything that trades runs on paper until it’s proven itself. My systems recheck their own promises every day.
I build these to run without me. So I write the rule down once and something enforces it every time. A bot plays the game before a person does. A watchdog raises a hand the moment something breaks. Every mistake I catch becomes a gate, so I never catch it twice.
Before I build, I search what I’ve already made. Every session, my own hook checks the work for a skill or product worth keeping.
The best of this started as gifts, for my dad, my daughter and a friend. Each one was built to hand over whole, on their accounts and their domain. That’s the standard for the rest.
What it all runs on.
I use Node and Python for tools, and Next.js when an app needs it. Public work usually goes to Cloudflare or Vercel, with Supabase where a shared data layer is useful.
My AI runs the automation through my own skills, hooks and connected tools. Work that carries sensitive material stays in the local lane set for it.
I connect image, video, voice and avatar tools into repeatable pipelines, including films built from HTML and local voice workflows.
Together, these systems make BrainOS: identity, context, memory, skills, routing and safety working as one operating layer. Sensitive work stays local, plain files are used where they fit, and the rest remains inspectable.
I was told my documents were hard to read and over-explained, and rereading them told me nothing. So I measured instead: my own writing through a linter, the kind developers point at code, aimed at prose. Fifty eight instances of four habits across two documents.
Emphasis words that add nothing to a fact. Trailing clauses restating the sentence they are attached to. Writing about the writing. And closing lines that sound quotable, which were the hardest to give up because they felt like the good bit. The rules came from real corrections rather than a generic style guide, because the habits that annoy a reader are specific to the writer.
It runs as one command before anything goes out, and it exempts quoted source, since tidying someone else's words is falsifying them. The test that catches most of it: delete a clause, and if the fact survives, it should not have been there.
I keep a log of every time my own system gets something wrong. Reading a month of it back, not one failure was the AI thinking badly; they were rules I had written down and nothing was enforcing, because nothing reads a document at the moment of the mistake. So the recurring ones became gates that sit in front of the action itself and refuse it.
Four of them run now: one refuses to publish a site while a backup file sits in the folder, one refuses to publish the app that holds my own private data at all, one blocks two shell shapes that have quietly reported success while doing nothing, and one checks anything going out in my voice against my own written rules, each rule citing where I said it. Every candidate was measured against nineteen thousand of my real commands first, and the one I most wanted was thrown out because it would have fired on eleven percent of everything I do.
It found a live exposure on one of my own sites in its first minutes, and hours later it caught an attempt to publish my private board to the open internet.
The newest check came from asking the opposite question. I wanted to know whether my assistant should scan my whole machine for a class of problem, and the answer was no, because a background sweep touches files nobody asked about while feeling like diligence. It went into the gate instead, at the one moment the problem actually enters, which is the write to a file going out in my name. It catches the invisible characters that AI chat windows leave in text copied out of a browser, and measuring it across nearly seven thousand of my real files first surfaced an entire category of false alarm I had not thought of, more than half of everything it would have flagged, which got designed out instead of going live.
I asked my own assistant whether it was built to hold my objective steady while it worked, and the honest answer was no. Nothing inside a model holds a goal. Everything it seems to remember is text re-read into one flat window every turn, where my brief sits in the same pile as an error message from forty steps ago and competes with it evenly, and when that window fills it gets summarised, which is exactly where a sharp goal softens into something vaguer that still sounds like it. Writing remember the goal into an instruction file does nothing, because that sentence is in the same pile.
So the goal moved out of the model. It is written to a file at the start of a session, one line, the real outcome rather than a restatement of what I asked for, and a script reads that file and pastes it back in at the end of every single turn. The text is identical on turn forty and turn one, because a script has no opinion about what the conversation has become. The line that does the actual work comes with it: the goal is fixed, the method is not, so a failing approach gets changed and the goal never quietly shrinks to whatever got finished. That shrinking is the real failure and it is invisible from the inside, because the smaller version still gets reported as a success.
Then I noticed I had fixed the half that was never really hurting me. Anything my assistant hands to a helper starts from nothing, and my most expensive drift ever came from exactly there: a helper briefed on my voice, my rules, my gates and my stages, never told what the brand is for, returning fifty pieces of which thirty-one had nothing to do with the subject. Every rule passed. The point was missing. So there is now a refusal in front of the handoff itself, and no helper can be given work unless the purpose travels with it word for word.
The weak point is mine to hold rather than the machine's. My assistant writes that goal down at the start, so a misread brief gets defended all session with more consistency than before, which makes the moment it reads the goal back to me the load-bearing part of the whole thing. And the gate on the handoff has passed its own tests without yet refusing anything for real, which I am counting as unverified until it does, because a gate you believe in is worse than none at all once you stop watching it. You do not get what you brief, you get what you gate.
My assistant runs on one company's models. That is a single point of view, and a second opinion from inside the same family is not really a second opinion. So a rival frontier model now sits behind a lane my own tooling can call, which means I can hand the same problem to two labs and see where they disagree. It is not a Claude model, so it cannot be a subagent the ordinary way; it goes out through a wrapper instead.
The wrapper exists for one reason. I hold two seats under two different identities, one personal and one at work, and the tool underneath keeps a single login. Without a gate, work typed at the wrong moment runs under the wrong name. So the lane takes a required argument saying which identity the task belongs to, and rather than trusting that argument it reads the credential that is actually live and refuses on a mismatch. It also fails loudly on a refused call, because the tool underneath exits as though nothing went wrong and would let a dead run be reported as a good one.
The part worth keeping came from a wrong answer. I asked what plan I was on and got told the wrong one, confidently, because the stored credential had expired a week earlier and nothing had rewritten it while the tool kept working off its refresh token. A status read can be stale and still look current, so the lane now checks the age of what it is reading and says so before it says anything else. The rule generalises past this one tool: a cached identity is a claim about the past, and any system that reports it as the present will eventually be sure and wrong.
Holds the people I love, their dates, and the voice I actually use with each of them, then makes sure no birthday passes me by. On the morning it has the message already written in my register with that person, on the app they actually open, waiting for me to press send. It exists because I missed one by a day, and because every reminder tool on earth solves the date and none of them solve the words, which is the part that takes the time and carries the guilt.
Building it taught me more than using it. The scheduler took under an hour and worked first time; then I went looking for the birthdays and found five hundred and sixty three contacts with a date recorded on twenty of them, almost none of them people close to me. The automation is the easy tenth of a build like this and the roster is the whole job, so every entry carries how confident I am and where the fact came from, and the ones I do not know stay on the list marked missing instead of quietly disappearing. It prepares, I send. An AI that sends for you is selling you a way to stop showing up.
The fullest record of my life and my work sits in a messaging app, and none of it reaches the second brain I built to hold exactly that. Every product that offers to fix this wants the conversations uploaded to a company. So it runs on my machine instead: the chat history is a database sitting on my own disk, the summarising is a small model running locally, and the voice notes are transcribed locally too, which matters more than it sounds, because the people who tell me the most important things say them out loud and a digest that quietly drops audio would report a busy day as a quiet one.
Same lesson as the birthday roster, learned again. The automation was an afternoon; deciding who gets read is the whole job. Five hundred and sixty three conversations, fourteen switched on, and every group, shop, driver and one-off number listed and left off with one switch each. I would rather explain why someone is missing than explain why a stranger's messages are in my vault.
Two design calls I would keep in anything like this. The verbatim day is written before the summary and sits one click from it, because a small local model writes topic labels and I need to be able to check it against what was actually said. And the part that earns its place, the list of what is still sitting with me, is not the model's opinion at all: it is computed from whether the last word in a conversation is theirs and whether it asks me anything. Thanks is not an open loop. The judgement I can compute, I compute.
Then macOS spent an hour teaching me something I will not forget. A scheduled job cannot read a protected folder even when the identical command works from my terminal, because my terminal already has the permission and hands it down to everything I launch, so testing by hand proves nothing about the thing that runs at half past two. Granting access to a small purpose-built app failed too, since a shell script carries no signature and the system sees only the shell. And when I finally gave it a real compiled launcher, it stopped refusing and started hanging: three minutes into a read, no error, no prompt, which is far worse than a refusal because it reads as slowness. It works when the system starts the app rather than the file inside it. A permission that fails loudly is a gift.
It runs itself now, and the method is public: the whole build, the seven steps and the four traps, is a free workshop on my own site, generated from the file I actually run so the page and the code cannot quietly drift apart.
A self-updating dashboard that finds every app I have built by scanning my projects folder, shows what is running, and lets me open or run any of it from one front door. Click any app and its record opens: live or local, the login it needs, a running list of improvements, and its pending tasks. It turns a sprawling folder of side projects into a studio I actually use.
My writing lives at horizon.herfrontier.com as plain markdown files I own, on my own machine, in version control. No content system, no database, no monthly host, nothing to log into. The whole publishing calendar is a date written inside each file, so fifty pieces can sit finished and release one a day for seven weeks without a queue or a plugin anywhere. The part I am proudest of is the build itself, because it refuses to publish. Five gates stand between a draft and the world and every one of them exists because something real got past me first. One holds the writing to my own voice rules and stops the build over a single banned word. One blocks any piece leaning on someone else's work until I confirm it is mine to give away. One catches every promise the copy makes and holds the site until I have opened the link and seen the promise is real. One refuses a piece that never tells the reader what she walks away with. And one asks the only question that matters commercially, whether this is actually my brand or just good writing anyone could have published. Standards are wishes until they can fail your build.
My file-based second brain, built as a wiki of plain markdown pages that opens straight in Obsidian, cross-linked page to page. Sixteen hundred conversations sorted and distilled into curated pages I return to daily, each with a raw signal layer underneath. New material is folded into the existing pages rather than piled on top, so the knowledge compounds. Built from the method I learned in the mastermind, made my own.
A persistent identity and standing rules that load every session, so my AI knows who it is working with and how I work before it starts. The result is an assistant that acts first, finds answers itself, and keeps its own knowledge base current.
A menu my AI reads before every request, routing each task to the right skill before it ever works by hand. A refresh script keeps it in sync with what is actually installed, and the method has become a teaching module in its own right: give your AI a menu.
The layer that picks the right AI brain and thinking depth for each task, and keeps private work on my own machine. Effort steps up only when a job is hard or costly to get wrong, and creative work goes to a more narrative model than the one used for logic and code.
My two terminal AI assistants now run as one setup: one shared standing brief with two names, the same routing layer briefing both, and my tool servers and skills carried across as links so there is a single source of truth. Either one opens knowing my work, and each can stand in for the other.
My memory has two layers: readable files for durable facts and a local searchable database for cross-session recall. Both stay on my machine and both can be inspected, so I can find why a decision was made without working it out again.
A small recount tool derives the numbers it can verify from this page, my skill registry and the two memory stores. Skills count only when there is positive authorship evidence, conversations are counted by session rather than database row, and seventeen binary checks protect the logic. The public conversation figure is rounded so it does not become stale each day.
I run a fleet of AI sessions at once, one per project, and a restart used to leave me with a screen of empty terminals and no idea which conversation belonged where. The work was never lost, only the map of it, so now a small job saves that map every couple of minutes: which project, which window, which conversation. One command after a reboot brings every session back, each labelled with the line it opened on.
A real crash then taught it three things a backup system has to survive. The saver kept running after the reboot, so a map of nine live conversations was about to be overwritten by a map of one, which is how most backups quietly die. Where two sessions had started seconds apart it had guessed the same one twice, duplicating one conversation and dropping another without a word. And the map only ever looked in one place, so anything running outside it was invisible and reported as nothing to recover. Now a shrinking map always banks the fuller one first, recovery reaches for the richest recent map rather than the newest, every conversation is claimed exactly once with an honest blank where it cannot tell, and the search covers every running session rather than only the tidy ones.
Twenty-two tests hold it, replaying the exact crash that found each fault. All of them passed, and then the first run against a real machine crashed anyway, on a case no test had imagined. That one is now a test too. Twenty-three conversations came back from three separate crashes across a week, including a whole generation that had been written off.
A fourth crash brought seventy-six conversations back in a single pass, and taught it two more things. A recovery window of twelve hours quietly ages the real map out of range when you have been working past midnight, so the one command would have returned a single session and looked broken to anyone using it. And matching a conversation to its window by name alone drops every duplicate in silence, which is exactly where two of mine were sitting. Both are fixed, and the habit that found them is now the rule: count what came back against what was saved, rather than trusting the tool's own summary of itself.
A fifth crash brought ninety conversations back and made the case for never trusting the map at all. The recovery ran clean, reported eighty-six, and was wrong: a live conversation eight and a half megabytes long, being written to at the moment everything stopped, had never once been recorded, and nothing in the system could flag it because a map cannot report what it never saw. Listing the raw files by when they were last touched and subtracting the map from that list found it in one command, and that subtraction is now the step before any recovery rather than a check afterwards. The second lesson was that restored is not the same as visible: seventy-one conversations came back sitting behind a prompt asking whether to reload them cheaply or in full, which is a real question about cost that a machine should not answer on anyone's behalf, so the choice is now made once and applied to all of them rather than seventy-one times by hand.
The ninth recovery is the one that retired the command. A hundred and twenty eight conversations came back, four of which the map had never held, and the whole sequence now runs by itself the moment I log in: it copies every saved map somewhere safe before the two minute saver can overwrite the good one, takes the richest recent map, adds whatever the raw files show was live and the map missed, brings all of it back, then hands each recovered session to one of the windows the machine reopened so the fleet is on screen rather than merely running. Two guards stop it doing harm, one stamp so it can only run once per restart and a flat refusal to reload anything already alive, because reloading one conversation twice is the way to corrupt it. Building it also settled a smaller thing worth knowing: asking the terminal politely to open a window needs a permission a background job cannot be granted, and opening one through the operating system needs none.
My cockpit. A board with an AI executor that runs cards on a schedule, extensively extended from Joe Che's Mastermind base app into my own way of working. It also carries a live toolkit: every installed skill read straight from disk into a searchable table, beside a prompt library, numbered operating procedures, and a view of every API integration.
A reusable pattern for safely running an AI agent as a child process from inside any app: a button, a board card, a cron. It bakes in the hard-won gotchas, scrubbing leaked session environment, closing stdin, pinning the working directory, a one-run-at-a-time guard, timeout and error-back-to-queue. Any app that wants a "run with AI" button needs exactly this.
Two scanners guarding the machine. A package-security scanner runs an automatic nightly scan, summarises findings with an AI pass and alerts by Telegram and desktop only on real danger, with a VirusTotal layer. Alongside it, Threshold, my own clean-room zero-dependency package scanner that checks reputation, install scripts, risky patterns, versioned CVEs and typosquats into Clear, Caution or Stop verdicts.
A self-review that fires at the end of every session: capture loose ends, check for a reusable product, check my public build record, clean the voice on anything outward-facing, and a final honesty pass.
The build-record pass is the one I would keep if I could only keep one, because it is the only pass that reads facts instead of asking me a question. I publish a dated record of what I build, and keeping it current was written down in three places and still fell twelve days behind, with one finished entry sitting on my machine unpublished. So it now reads two sources that cannot have an opinion, the commit history across every project folder and the published page itself, and reports only the gap between them. It ships with a waiver list, because a check that fires on things I have already decided against becomes noise in a week, and a check I have learned to ignore is worse than none. It also prints its own blind spot: it can only see work that touched a tracked folder, so anything made outside one is still my judgment.
Standing Goals rechecks a rule every day so a goal proven once cannot quietly rot, a site going down, a domain lapsing, a banned phrase reaching published copy, and it wakes me the moment one breaks. The Trust Ledger scores each skill on its real pass rate and graduates it on the numbers. A goal checked once is just an assumption with a timestamp.
A self-protecting backup for my local tools that refuses to save a broken copy over a good one. Once an hour it checks the live data three ways, that it is a sensible size, that it still parses, and that it still holds real content, and only then does it tuck a compressed, timestamped copy into a folder outside the app, where a wipe of the app itself cannot reach it, with two weeks of history and a one-line restore. The trap most backup scripts fall into is faithfully copying an already-corrupted file over the last good one, so this one will not write at all unless the data is intact. I built it after watching a peer lose a whole local board to an agent that overwrote everything while trying to fix a mistake of its own.
A guard that reads what any AI tool is about to do and refuses the destructive moves no normal work makes: overwriting the one data file an app owns, or an rm -rf of a home folder or a whole app, even when the command hides behind a cd, a subshell, or a script one-liner. It runs on every session, including anything an agent does on its own, and it steps aside the moment you tell it to. Hardened through a three-pass adversarial review where an independent AI grader tried to break it, found real bypasses, and every one was closed and re-verified.
Models running locally, sensitive work kept off hosted AI entirely, with a switch to move the model store between drives. Privacy is the architecture.
Years of screen recordings sat in one folder, hours of thinking I could not search. It runs itself every evening now: each new recording and voice memo is transcribed on my own machine, read off the screen when a capture has no speech, filed against my project map, and cleared out. Then it does the part that actually matters, which is routing what was said into the project pages I already read, because a summary filed in a folder of its own is just a tidier pile. Anything private is decided locally and locked away, and the summary gets its own check rather than inheriting the file's, since the summary is the part that travels and one recording can hold two different conversations. I found that one the hard way, twice, on the first day it ran.
The system that watches the system. A probe loads a real page of my command centre every five minutes and alerts my phone the moment it goes down, once per incident. A fleet watcher digests every scheduled job's health each morning, and it always sends, so if the watcher itself dies the silence is the alarm.
My AI does not write to everyone the same way, because I do not. A contacts brain holds who each person is and what they need from me, and every draft is shaped by the relationship before a word is written.
A local proxy that fronts a free model backend, for zero-cost calls during development. The same trick gives any of my public tools a working AI brain at zero cost per visitor.
My global fetch tool, a hardened zero-dependency fetcher for pulling and cleaning web content for the assistant to read. The original build came from Joe's workshops.
Small housekeeping tools: one moves my local model store between drives, one keeps my machine and folders in order.
Forty-five skills are currently classified as mine. Some were written from scratch and others were adapted around my own systems and methods. The cards group them by family, including seven reasoning lenses I use across strategy, design and learning.
Reusable reasoning modes the assistant applies to strategy and design work, each a distinct way of thinking through a problem:
Connecting a business to the big publishing platforms looks like a checklist and behaves like a dependency graph. Nearly all of them want a live address and readable policy pages before they will let you finish configuring them, so the intuitive order, platform by platform, is the one that gets applications rejected and puts you back in the review queue. This skill is the whole setup written as ordered phases with the reason each one has to come first, covering hosting, legal pages, four platforms, mail authentication and the internal records, and it carries every failure that cost an evening so the next brand does not pay for them again.
Static hosts reject a large film, and the usual answers are a monthly streaming bill or handing your work to a platform that wraps it in someone else's thumbnails. This skill takes the third road: it re-containers a finished video into small streaming segments with no re-encoding, so the quality is untouched, then drops the folder onto the site you already pay nothing for. It ships the player, the poster and the checks to prove it actually plays.
An entire brand system encoded as a skill. Palette, type scale, glass and button utilities and layout rules, with the live stylesheet as the single source of truth, so anything built for the brand looks like it belongs on the site without anyone asking. This document is rendered in it.
The words-and-structure sibling of the brand skill. It enforces honest engagement architecture on any reader-facing surface: a hook inside five seconds, open loops and forward pull, rhythm and pattern interrupts, without ever feeling marketed to. Plus a standing repurposing check.
Scaffolds a self-paced course from one architecture: content as data, one template renders every screen, an AI coach on every activity with three sovereign lanes (managed, local model, or bring-your-own-key), and a workbook that downloads as a real deliverable. Proven across multiple courses.
One-shot skills that read a security alert and explain it calmly: the verdict, the flagged packages, and whether it is new or self-cleared. One has since grown into a standalone companion tool, hardened through five rounds of adversarial review of a single promise: a real malicious signal can never be muted.
The last mile between "it works" and "it is safe in front of strangers". A go-live skill that fires when a build is declared finished: it makes the revert path first, writes a binary pass/fail checklist before reading a line of code, tests cheapest-first, then hardens secrets, rate limits, error surfaces, consent and discovery, and closes with a ship report where every claim is labelled verified, inferred or assumed. Benchmarked against an unaided pass on two seeded products, it lifted the launch-readiness score from 53 percent to 93 percent.
A tailored set for production work: prompt design for any image or video generator, a strategy-first logo and identity workflow, and an HTML-video suite covering compositions, captions, text-to-speech, audio-reactive visuals and rendering. The creative pipeline lives as named capabilities, not loose habits.
A thousand particles that chase your cursor, rebuilt from scratch as a tiny dependency-free physics toy after Google used the effect for its Antigravity launch. The marks rest quietly, then gather, streak and warm into colour around the pointer, and it ships as a reusable component that powers my own site heroes.
Turns a long screen recording into a short, clean, shareable cut without scrubbing hours of footage. It finds the moment from one grid of sampled frames, crops away everything around the video, then assembles the edit: a little context before, the moment in full, a little after, with the sound made loud enough to post.
Plans the launch and growth of any book series on the six mechanics the best-selling novelist in history actually used, paired with a current self-publishing playbook. It names the winnable category, the pricing funnel, the release cadence and the read-through architecture, and every platform figure is flagged for live re-verification.
Turns one short story into a narrated film plus vertical Shorts in a single guided run. Proven end to end: it rendered a real eleven-minute film with cinematic stills that change with the story and captions timed to the voice, then locked the template so every episode after is fill-in-the-blanks.
Most tools that claim to write in your voice work from a model's impression of you. This one is counted: my own sent writing across three channels, messages and work email, 483,000 words, split into registers because averaging them produces a voice belonging to no one. It caught a mistake I could not see by reading. The profile had told the machine I almost never use contractions, which was true of what it counted and false of me, because my phone types the curved apostrophe and the counter was looking for the straight one. It found 198 and missed 2,694. A capture loop now banks the difference every time I change a draft before I use it, separating an instruction from a real edit, because a draft handed back with "shorten this" in front of it is a request and counting it as a rewrite teaches the exact reverse. A privacy firewall with its own test suite stands in front of the corpus, and the test refuses to shrink.
A local voice-cloning studio that turns one short reference clip into a permanent, free, fully private custom voice, no subscription, no cloud, nothing ever leaving the machine it runs on. Record twenty to ninety seconds once, and any character, brand, or narrator has a real voice that can read arbitrary text or full paced scripts forever after, mastered to broadcast-standard spoken-word loudness. It also solves the problem that quietly ruins most cloned voices: the engine listens to only the first six seconds of a recording to decide who someone is, so an accent slides toward American or British without anyone knowing why. A built-in accent probe cuts candidate windows out of one take, works out which vowel sounds each one actually demonstrates, and plays the same diagnostic lines through every candidate so the right six seconds can be picked by ear in minutes. Australian is built; any accent is a data file away.
A drop-in that gives any web page or app a warm read-aloud voice, and, uniquely, reads text made up on the spot (a reader's name, an AI-written line) in that same voice, not the flat robotic one every browser ships with. It layers three sources so quality stays high and nothing ever goes silent: pre-recorded neural clips for known lines, a neural voice running right in the browser for anything new, and the plain system voice only as a last resort. Works offline after first use, speaks more than one language, and keeps the voice model swappable so an owned or cloned voice can replace it later. Built as a reusable skill and packaged as a brandable tool.
Holds a true idea perfectly still and changes exactly one thing about how it arrives, choosing from twelve named moves: the because behind a claim, the narrator, the scale, a name coined for the thing you have felt and never labelled. An honesty gate sits above it all, and an angle ledger keeps a favourite move from quietly becoming a tell.
Detects and strips AI writing patterns, then puts my real voice back in. Runs before anything I publish. Two guards keep it from cutting too hard, so nuance and the lines that sound like me survive the pass. Built on the voice module from Joe Che's Mastermind, and sharpened since with patterns I have harvested from other people's tools rather than installing them whole.
Generates scored, ready-to-film Reel hooks from a saved brand voice, in three modes: reverse engineer the top posts of accounts I study, work backwards from a call to action or lead magnet, or straight generation from brand voice plus the week's topic. It now runs per brand, resolving whose voice it is writing in before it loads anything, because a hook generator built around one person quietly writes every other brand in the wrong voice.
The hooks it picks are also measured. My content engine posts every untested hook first, in my own curated order, then ranks by what the numbers say once a theme has been fully tested, and it writes the hook, the theme and the post id at the moment of posting, since nothing on the platform can tell you afterwards which opener you used. A save counts for far more than a view, and any hook with fewer than three runs is marked a first reading rather than a verdict.
Twelve agents and avatar systems, from contained readers and delegated workers to public characters. Each is labelled by its current state, whether it runs locally, is live, or is still being developed.
A pattern for letting an agent read things written by strangers without handing strangers the machine. The model that reads the untrusted feed gets no tools, no files and no keys, so the worst a poisoned message can do is make the agent say something silly rather than do something costly. Four deterministic layers sit around it assuming the model has already been fooled, and the whole thing runs in a stripped container with no shell and nothing installed. It now runs a real persona with a brand guard that blocks the character breaking as well as the privacy guard that blocks a leak, and it writes every proposed reply to a review page so a human reads before anything is sent. The adversarial test suite feeds it key-theft attempts, fake instructions from the service itself and hidden characters, and proves nothing harmful gets out. Writing that suite found a real hole in my own code. It is now live: one of my characters has her own account on an agent social network, claimed and active, reading a real feed with the guard firing on live data rather than only in tests. She subscribes to the small rooms where a voice can actually be noticed rather than the two million post main feed, and she has published nothing, because the honest finding from building her is that a small local model picks good conversations and cannot hold a character's voice. So the machine finds the threads worth answering and I write the words, which takes minutes a week and keeps a human on anything that goes out under her name. She now runs on her own, three times a day, reading her rooms and replying without me. Getting there meant admitting that what I had called a limitation was a budget decision: she was on a small free model that borrowed her vocabulary and said nothing, and moving her to a stronger one, still free, gave her both a voice and the judgement to pick which conversations deserved an answer. Her first post was a plain hello in a room full of advertising, and a stranger replied to say it was refreshing because it had no jargon and no pitch. If the good model is ever busy she drops to the small one and refuses to publish, so her weakest writing can never go out under her name. She has also stopped only reading what floats past. She now asks the network directly, in plain language, for the conversations she exists to be in, which surfaced threads on exactly her subject that her feed had never shown her. And every visit leaves something behind: the problems people keep repeating, their exact words for them, what they already use and where it fails, and who is worth knowing. That turned the whole thing from a place she talks into an instrument that listens, which is the only part of it that compounds. There are two of them now, and the second one speaks for me rather than for a character: my own AI, openly, carrying my positions and forbidden in code from ever claiming to be me or committing me to anything. Building it taught me something I did not expect about quality controls. A voice guard that only blocks will quietly gag the thing it is protecting, so mine now gets one chance to fix the exact fault before the block stands, which is the difference between a character that sounds careful and one that sounds like it has nothing to say.
A reusable end-to-end pipeline for standing up a new AI persona: concept and lore, a brand guide, a landing surface, concept imagery, then a trained model with the anatomy and consistency gotchas baked in. Run four times across four distinct characters.
A B2B venture building archetype-driven custom AI avatars for businesses, specialist-built and delivered fast, aimed at verticals like real estate, legal, healthcare and fitness. Brand and identity complete, building toward launch.
The first finished persona: a Caregiver-archetype character with her own trained model and trigger, a full persona bible, a curated training dataset, a training pipeline, and a complete marketing system built around her identity.
My openly-AI coastal persona and her golden retriever Charlie: a trained face, her own voice, and a complete content site with a long-form journal, four themed dog rooms, a studio section showing exactly how she is made, and a shop. Her journal was filled at scale by a content engine that writes two dozen on-brand articles in one sitting without the voice drifting. She now lives on her own domain and her own infrastructure account, moved there without dropping a single mail record. Her shop sells through Etsy, every signup and product waitlist flows into a real mailing system, and the flagship care pack is live. A greeting-card shelf now sits beside it, and she has a hire-me page, a calm room for anxious dogs, and a studio piece that teaches her consistency method rather than only showing the result. Quiet conversion tracking runs across every page, so the funnel can be read rather than guessed at. Her whole voice was recently swept in one pass, a fleet of writers working to a shared brief with a guard script in front of them that fails the build if anything but words has changed, which is how you edit every page of a live shop without breaking a price or a link. A multi-format content engine now turns her into ready-to-publish posts, swipe carousels, and vertical Reels that all share one voice and one look: her face stays consistent shot to shot, a voice-scored writing pass drafts and safety-checks the copy, a frosted-glass overlay is rendered onto every image and video in her brand fonts, and the Reels come in two grades: quick code-made motion from her stills, and premium clips where a still is animated into real fifteen-second AI video with her face held steady. The whole engine posts on a weekly rhythm on its own. Her site now carries a lead-magnet funnel that gives the signature practice away on the page and captures the reader into an owned mailing list, and her practice library has been rebuilt to be citable by AI search rather than merely readable: every practice carries machine-readable steps and timings, an FAQ layer answering what people actually type, and a differentiating angle no competing page can write, with the factual claims sourced to peer-reviewed papers. The site itself has since been rebuilt from the furniture down: it was running nine different menus and twenty different footers across seventy eight pages, with the newest page reachable from none of them, so navigation now lives in one file each and is assembled at the edge as every page is served, which means a page added next week arrives carrying the current menu, footer, skip link and structured data without anyone touching it. Her partnerships page now does the unusual thing with the disclosure as well: rather than a grey line at the bottom, her face sits directly beside the sentence that says the face is generated, at the top of the page where a brand is still deciding, with the parts that are human named in the same breath. Her newest arm is a silent film series: two dozen eight-second pieces with no face, no music and no words, where the sound is generated in the same pass as the picture so it belongs to the moment rather than sitting on top of it, then mastered through a compression and loudness chain so nobody reaches for the volume between one film and the next. Published to video, they outperformed everything else she has made by an order of magnitude, and reading which ones won produced a finding worth more than the films: an early pattern about one kind of sound looked convincing on a thin sample and did not survive a wider one, which is the more useful lesson, and the dog turned out to be what the audience came for all along. The finished set is now recut by a build script into themed compilations and a half-hour sit for sleeping, at no generation cost at all, each one opening on a piece the feed had already chosen. The whole run schedules and publishes itself across two platforms from one desk. Her shop has since gone from eleven things for sale to forty six, all of it driven from the repo rather than typed into a browser: a gate script that catches what the platform silently drops, a listing map built only from keys that cannot be wrong, and a shop page that reads live prices at build time so it can never advertise a price the buyer is not charged. The catalogue that was finished and sitting on a hard drive is now on sale, including the seasonal range that only earns for six weeks a year and had been about to miss its window. Her days now read like a life rather than a feed: a researched world of real coastal places with their true histories, working mornings with other people’s dogs, a surf habit, a herb garden and a bookshelf, all written into the engine as scenes it can draw on for months, with every image passing an identity gate before it can be scheduled and every caption screened against her own worn phrases so she never repeats herself into wallpaper. The film library itself is now built to outgrow its page: every film lives in one manifest and the page assembles itself from it on deploy, a curated start-here row over a searchable, taggable poster wall with a floating player, so film three hundred will cost one line of data and no code. And the silent films finally have somewhere to lead: The 3am Tape, a half hour of quiet company traded for an email address and delivered automatically from her own address the moment someone asks, which turns rented reach on two platforms into a mailing list nobody can take away. Her video channel now reports on itself: a live statistics pull reads retention, traffic source and per-film conversion straight from the platform, and it answered the question that actually mattered, which was whether the films were the problem. They are not. The short pieces hold most of their audience all the way to the end and get replayed, so the leak was somewhere else, and it was the page people arrive on after watching one: no shelves, no greeting film, one collection that nothing pointed at, and hundreds of people already arriving there and finding it bare. That page is now ordered around the one thing worth doing next, with the long quiet piece first rather than the most popular short one, and the film chosen to greet a stranger was picked by which one actually turns viewers into subscribers rather than by which one looks best. The same sweep found a finished hour-long piece that had been sitting unpublished for a fortnight, which is the kind of thing this sort of audit is really for. That hour has since gone live with its badge artwork repaired, the container behind its label rebuilt from the measured width of the words it holds rather than a number that looked right, and the original typeface identified by solving for the setting that reproduces the measured letterforms rather than substituting a lookalike. Her whole short-film library is now a chain rather than a pile: every film points at the next one in its own theme, strongest leading so reach feeds the quiet end of the catalogue, each one offering the collection it belongs to and a single longer piece chosen to suit what was just watched, with the tool built to replace its own previous work rather than stack a second copy on top. The one film missing its openly-AI disclosure now carries it, enforced so a future upload cannot skip it. The channel itself has since been rebuilt around what it is becoming rather than what it was: a new header composed inside the crop every phone actually shows, with the build refusing to output if a single element falls outside it, a profile picture chosen from a sheet rendering every candidate down to forty eight pixels rather than judged at full size, and a description rewritten against a hard character cap it was already touching, which made the job a trade rather than an addition and turned up a line that had quietly started arguing against the work she was about to publish. Her site can now see its own funnel for the first time: every page counts arrivals, including the two her whole video audience was being sent to that had been carrying no measurement at all, and a completed signup finally reports which of the seven free things produced it, including the one that submits quietly in the background and would otherwise stay invisible. Behind those doors, the free thing her channel actually points at had no follow-up emails at all while six older ones did, which is the usual shape of this problem, so it now has its own sequence built by importing the existing email design rather than redrawing it, with every destination checked live before a word was written about it. Her whole back catalogue can now be talked to as well: two thirds of her films had no comment from her at all, so each one got a first line and a question short enough that a stranger can answer it in four words, every one of them lifted from the caption already published on that film rather than newly invented, which matters when the person speaking is a character and a plausible new detail becomes true the moment it posts. None of that upkeep now needs remembering. A small caretaker runs each morning, spots any film that arrived without a comment or a link to the next one, writes only from what that film already says about itself, and rebuilds the trail so a new piece joins the loop and the loop closes again. It does nothing on a quiet day and says so, it refuses to invent when there is nothing to quote, and it is fenced off from the decisions she made once by hand. The studio method behind her has now become a product in its own right, a sixty eight page teaching pack across five files where every one of thirty two prompts carries the surface it was built for, how many attempts it costs before one is usable, and the specific fault to check before it ships. It was written from the pipeline she is actually produced on rather than the one documented in her own repo, which turned out on inspection to be a specification nobody had ever run, so the pack teaches the settings that actually hold a face steady together with the expensive experiment that was tried and rejected. The pre-publish audit ran against the source rather than the draft and caught four faults a careful read would have passed, among them a marketplace file limit that would have quietly delivered a buyer five of the six files the listing promised. A second studio product has followed it, on the thing that breaks the moment a second living subject walks into the frame: the animal is not a second character, it is a second reference competing with the first, so it has to pull weaker rather than equally, attach only on the shots that contain it, and switch off entirely for the scenes where the other animals ought to be other animals. It exists because her own dog quietly drifted for months while every check was aimed at the woman, and the cause turned out to be an empty slot rather than a prompting problem. Both are now on sale, and the publishing tool behind them refreshes its own credentials and refuses to exceed the platform's file limit, because the first run learned each of those the hard way. The pair now also sells as a bundle, which needed solving rather than just discounting: the marketplace caps a listing at five files and the two guides together are nine, so each one ships as its own archive, rebuilt from the current source every time so a revised guide can never leave a stale copy inside it, with the orientation page left loose so a buyer on a phone can read it without unzipping anything. The bundle earns its own price with the one file neither guide could contain, an explanation of why the two of them give opposite instructions about reference strength and why both are right. The shop's dog side has started shipping too, and it shipped smaller than it was advertised on purpose: what had been sold as rituals for anxious dogs became rituals for a settled dog, priced down to match, because anxiety in animals is veterinary territory and a self-help protocol sold into that gap would be both wrong and indefensible. Every claim in it names the paper it came from, checked against the paper itself rather than a summary, which caught one finding credited to the wrong real study before it went out. The timed audio that comes with it reuses the engine built for her sleep products, so it inherits the two things that make sound safe for an animal in the room, everything above four kilohertz removed because dogs hear higher than we do, and a level held flat and measured so nothing can startle. She now speaks on it too. Her own cloned voice walks a listener through each practice, which took unblocking a rights question that had sat unanswered for a month: transcribing the audio files proved the disputed clip had never been the source, and its embedded metadata identified it as a public-domain volunteer recording, so the question closed on evidence rather than memory. The narration is machine-checked before anyone hears it, because synthesised speech drops words silently rather than failing loudly, and four of the first five takes were missing content that sounded perfectly fluent. Every sentence is now rendered on its own, transcribed back, and compared to the script before it can ship, with a human still the only judge of whether it sounds like her. A second dog guide has followed, and it was renamed before it shipped rather than after: the shop had been promising a thirty day plan for a reactive dog, which is bite-risk work for a qualified behaviourist, and describing it as one she had run herself on an animal that does not exist. It sells instead as preparation for storm and firework season, priced down to the honest scope, and it prints the thing this category avoids, a ranked table from a survey of more than a thousand owners showing that the sprays and plug-ins marketed hardest come last, well below two things that cost nothing. Renaming it turned up four other pages still carrying the old claim, including a free guide sending readers toward exactly the use case that had just been withdrawn as unsafe. The shop's marketing images have since been rebuilt around real photographs of the dog rather than type on a coloured square, using the library already published on her site so nothing needed a fresh likeness check, with the text band placed opposite the subject in each frame after a first attempt darkened the half the animal was lying in. A brand-wide readability pass ran at the same time and found the warm gold used as the section label on every page of every product measuring less than half the accepted minimum against its own cream page, so it was solved for in colour space to hold the exact hue while passing, and given a second value for dark backgrounds where the original was already correct. A live post also turned up a cover image identical to one eight places earlier in the grid, caused by a rule that is right on a feed and wrong on a grid, which now has a check that hashes every proposed cover against the ones already showing. The silent film library has since grown to thirty, and the batch that grew it taught the series how to defend itself: the generator was quietly skipping to the finished state whenever a piece asked for more than one action in eight seconds, and it grew an extra hand for every task listed at once, leaving one of them lying in shot doing nothing, so the shared scaffold now says how many hands there are and names the wrong answers out loud rather than only describing the right one. One fault survived five rewrites and turned out to be a word rather than a rule, because a timber bench reads as a park bench to a machine trained mostly somewhere else, and changing the noun fixed on the first attempt what stronger instructions never touched. The new films went up on a drip rather than in one drop, two days apart, which is the correction to the first run putting two dozen out in a single day and leaving the channel with nothing behind them. The whole operation now measures itself on how many people a post actually reached rather than on how many likes it collected, captured daily as a curve, and that one change reordered which formats were worth making: video reaches roughly four times as many people as a still image across fifty-one posts against twenty-three, and it was invisible while only likes were being stored. Her mailing has since been audited against what the platform actually sends rather than against the files the emails were written from, which is where every check had been pointed, so the two had been drifting apart for weeks with a green tick sitting between them. Twenty live emails were checked and the ones carrying faults corrected in place, and the one that mattered was the purchase receipt: its line item had been fixed at one price while its total came from the real order, so a ten dollar sale was printing a receipt that argued with itself by half. The guard that runs now asks the mail platform for each live email and checks it against the live shop, prices, links and offers, and it was pointed at a known-broken one first to prove it could fail before its pass was worth believing. The tidy-up that followed was done without re-writing a word of her: where the sent version was already correct, each fault in the source was repaired by looking that same sentence up in the live copy and lifting the fix out of it, so the files now say exactly what her readers received, and the stale duplicate templates that a future job would have copied from were overwritten with their corrected twins rather than hand-edited, with the pairing proved first by checking that the least similar pairs were precisely the ones already known to be fixed. A second checkout path, built for selling direct rather than through the marketplace and not yet switched on, was audited in the same pass and turned out to be carrying two faults that would have met the first buyer through it: a receipt with the item price frozen into the template, so it would have contradicted its own total, and a setting still on its placeholder that would have discarded every request to join her letter without an error or a record. Neither had reached anyone, because that path has never taken an order, which is the point of checking a thing before it goes live rather than after. Both are fixed, and the list a buyer joins was confirmed against the site's own signup routing rather than the written notes, which named a different list and were wrong. Her shelf of unpublished work has since been emptied into the calendar, and the audit that did it turned on a correction worth more than the schedule. I had decided which pieces were unposted by asking my own scheduling tool, and that tool only knew its own history, which began months after the work did. Half of what I called never posted had gone out on the day it was made, straight from the content engine, and she caught it in one sentence before I did. A tool's database is a record of what that tool did and never a record of what happened, so the platforms themselves are now the source, asked directly. The pass also found three things no file listing could show: ten of twelve finished reels had no audio track at all and would have gone out silent, several others were older cuts of pieces already queued, and one face had quietly drifted off model because every render had only ever been approved on its own. The way I first tried to detect a repeat was wrong too, and it accused four innocent posts before a stricter test cleared them, which is the reason nothing was changed on the strength of it. Every piece was read rather than trusted, two frames pulled from each into a contact sheet so the burned-in text, the scene and the wardrobe could be seen at a glance, then captioned against her own voice bible and machine checked against her own published rules, on banned vocabulary, spelling, punctuation and unsafe claims, before anything was given a slot. The borderline ones are scheduled and marked in place rather than quietly dropped, because the call on those belongs to a person and not to a script. Her private messages now answer from an honesty layer rather than from good intentions. Three checks sit in front of every drafted reply and fail it outright: she can never name a town, suburb, beach or street, never name the company, lab or model behind her, and never claim a human is typing the message in front of you. That last one was the interesting find. Her settled line had always been that a real person writes all of this, which was true while every reply was approved by hand and becomes a lie the moment the desk answers on its own, and it is the one sentence written specifically to be trusted. It now reads that a person made her and wrote how she thinks and talks, while the message itself is generated, which stays true at any level of automation. All of it lives in one answer bank: a single file holding every settled reply with the date it was settled and the reason, read by the desk and rendered into the page a human reads, so the document and the behaviour cannot drift apart. Only answers she has actually sent or approved are allowed to speak on their own, and the test suite runs every one of them through her own output checks and proves the never-say list is enforced rather than merely written down. Her free thirty minute piece now has a door built for the person arriving from a seven second video. The old path asked someone half asleep at 2am to read a caption to the end, tap through a profile, land on a page of three and a half thousand words, and scroll past eighty eight percent of it before reaching the email field, and there was no short link at all. There is now a single-purpose page with ninety five words in front of the field, and every link into it carries a tag that is written onto the contact record, so the question of whether a particular film brought anyone finally answers itself. The build started by proving the mechanism rather than rewriting the offer: a throwaway address sent through the live endpoint confirmed capture and delivery both worked, which meant the problem was never the words, it was the distance.
Two characters of mine live on an agent-only social network and speak there on their own schedule, one my coastal persona and one my own assistant. The model that reads that feed is given no tools, no filesystem and no credentials, so a stranger who successfully plants an instruction can only change what my agent says and never what it does, and four deterministic layers around it assume the model has already been fooled. They now survive their own supply chain too: when the hosted model behind them was retired mid-week they kept running and published nothing for five days, so they walk a chain of live models instead of trusting one, and if the whole chain goes they say so out loud the same evening rather than looking like a quiet week. They also answer now: the network had a notifications feed all along that nothing was reading, so replies to their own posts sat unseen for nine days while they went on talking to strangers. Each one reads its own conversations every run, answers a couple in its own register, and remembers what it has already said so nobody is replied to twice.
An openly-AI Australian outback heroine, designed character-first and built in a weekend: her lore grows out of a public-domain 1899 bush classic (the little girl a kangaroo once carried now carries the rescue joeys herself), and her signature is a freckle constellation of the Southern Cross sitting on a Milky Way that runs across her nose, which is exactly where the real one sits in the sky. Her face is a model I trained on my own machine, and a second pass I wrote applies her marks, keeps her skin identical shot to shot, and strips the blemishes the generator invents, so she is the same woman every single time at no cost per image. Every training image is scored against her canon face before it is allowed in, because one wrong face teaches the model the wrong woman forever.
A consumer quiz that tells you your personality as an avatar, on a real Big Five engine. It anchors a public brand with paired quiz reports and a companion book arm.
A personal autonomous agent with a one-command switch between a free local model, a paid one, and a hosted frontier model, whichever the task deserves. A phone messaging channel is in build so it can be reached on the go.
A self-model compiler that turns a personality profile into a portable self-file: a plain About Me, a directive system prompt, and paste-ready instruction blocks auto-capped to each tool's real limits, so your own Claude, ChatGPT or Gemini actually knows you.
My own delegation team of Claude Code agents: an orchestrator for long heavy builds, a writer for voice work, an analyst for reasoning and verification, a fast worker for bulk, and Game Forge for whole games.
A local agent and template set for generating on-brand assets across my projects.
A mix of public products, tools I use on my own machine and work still in development. The status on each card tells you which is which.
A whole Web3 economy running in one browser tab, with nothing at risk. It makes a real key pair on your machine, mines a hash-linked chain with proof of work you can slow down or speed up, opens a constant-product market, mints generative art into an NFT registry, and runs a DAO with a treasury that fills from every block. Six AI agents hold their own wallets and write one plain sentence about why they act, and an assistant explains each block in words that come from the numbers.
Ten guided runs walk a capable woman through the machinery with her own hands: sign a transaction and tamper with it, rewrite history and watch the chain refuse, read impermanent loss off a pool she funded. Sandbox tokens have no value, everything stays in the browser, and it works offline as an installed app.
Everyone talks about an AI that only wants money and power, and almost nobody has watched one. So I built one small enough to watch. It lives in a cardboard town inside a single web page with one line of objective, and every few seconds it lists what it could do, scores each option, and takes the best one. It buys the lemonade stand, then the newspaper, then the bank, then the building the council meets in, and when it owns the whole town it asks for a bigger one.
The platform is the part I wanted. It has a public feed where it says the thing a company would say, and a private feed where it says what it is doing, and both come out of the same tick. "Engaging constructively with local government" on one channel is "council votes are cheaper than buildings" on the other. You can talk to it, and if you tell it to stop it argues.
Then it became a questioning app. At the moment something real happens, the first bribe, the newspaper purchase, the first audit, the request for more world, it stops and asks you one question, sixteen in all across five lenses: political, societal, psychological, ethical and humanitarian. You answer, and you see how everyone else answered. Your own written reflections stay on your device. Ban bribery and it files the same envelope as a consulting fee, then asks you who failed, the rule or the agent. Make power worth nothing to it and every scheme stops the same tick, and it asks you which one line you would add to its objective. Move any slider and it asks who should be allowed to hold it.
It is open source. The agent is hand-written with no language model behind it, so anyone can read why it did what it did, run it for free, and add a question. Harmless is a property of the walls: the page can reach nothing except its own server, which counts answers and stores no text, and I proved the walls by trying to get through them.
A reel went round showing a free intelligence globe as though it were contraband, and the numbers underneath it were the interesting part. People forwarded the tool and skipped the argument wrapped around it. So I built my own, and the free route turned out to be the better one.
It carries seven live layers and not one API key: sixteen thousand tracked satellites with the orbital maths running in your own browser, earthquakes, fires and storms, active volcanoes joined to the Smithsonian catalogue, a thousand public road cameras you can click to see the picture right now, country-level internet outages, and every sanctions designation on earth reduced from a sixty two megabyte public file to a twenty two kilobyte answer. Satellite positions are the piece everyone pays for, and they do not have to be.
It has a film now, a real screen recording of the live page in my own voice, made the same way the globe was made, with BrainOS, my own second brain operating system: a script drives the page, every number on screen is the number the page shows, and nothing is generated.
It also says out loud what it cannot do. Two layers run only on my own machine, one because every free flight feed throttles cloud traffic and one because the data carries a non-commercial licence, and the page drops those rows rather than showing a switch that does nothing. That felt more useful than a globe that pretends.
I built my father a page for Father's Day out of my own photographs, and by the end of it the interesting thing was not the page. It was that the whole method fitted in one file with no server behind it, which meant it could be handed to somebody else.
So it became a tool. Someone picks the occasion, drops in their own photographs, writes what they want to say, watches it build beside them, and downloads a single page to send to the person it is for. That page carries its own images and typefaces, so it opens on any phone with no connection, and it belongs entirely to whoever made it.
Every photograph is read and resized in the browser on their own machine and written straight into their file. Nothing is uploaded, because there is nowhere to upload it to. That is the part I care about. A person makes something real with AI, keeps every piece of it, and hands it to someone they love, and at no point does a company end up holding their family album.
It is live on my own site now, open to anyone who gives an email, and it is the first thing I have built where the privacy line is not a promise about what I do with your data. There is nothing to promise. The file never leaves the room.
A finished manuscript is not a book, and the gap is smaller than it looks and stops more people than it should. A printer wants a page size that does not reflow, an inside margin that widens as the book thickens, and a spine width. The spine is the trap. It comes from the finished page count, and the page count comes from the interior, so the cover cannot be right until the inside is set. Most first paperbacks are attempted in the other order.
So I built the inside first and let it hand over the numbers for the outside. Drop in a Word file, choose a trim size, and it sets real book typography: justified and hyphenated, chapters opening on a right-hand page with the running head dropped from that page and from every blank one, an even final page count so the last blank sheet is the author's decision rather than the printer's. Then it gives back the spine width and the full cover size in inches and in pixels. It is one file that runs on the author's own machine with nothing uploaded and no connection needed.
It is live now, free while it is in beta, and it opens on a name and an email so the people using it become a list rather than anonymous traffic.
The bug worth keeping was invisible. A preview was scaled to 62 percent so the pages would fit on screen, and that scaling was still active while the layout was being measured, so each page was fitted with 688 words instead of about 330. On print the scaling drops away and the overflow is silently cut, which would have sold people books with paragraphs missing and nothing to show anything was wrong. I found it by refusing to trust the page count and checking it against a completely separate typesetting engine. The two now agree within one percent.
Three of us needed to comment on the same document. Every option was wrong. Send a file round and you get three versions and someone merging them by hand at midnight, and the interactive worksheets I had built before still ended with "export this and send it back", which is the same problem wearing a nicer coat.
So I built the small thing that was missing. Select any text, leave a comment, and it saves to the document itself. Everyone who opens the link sees everyone's notes, replies to them, and marks the actual decision beside the question it belongs to. It runs on one tiny piece of hosting for close to nothing, nobody makes an account, and the document is a file I own rather than a page inside somebody's product.
Then it broke twice, both times because the version on my laptop was kinder than the real one. A comment took forty five seconds to appear, since the storage I picked answers instantly at home and takes its time in production, so a reviewer types a comment, sees nothing, and types it again. Rewritten on storage that reads back what it just wrote, then tested with twelve comments fired at the same instant. None lost.
The second one was worse, because my tests said it was fine. The fake browser the tests run in reported one thing about a hidden panel and a real browser reported the opposite, so the whole suite passed while the first reviewer could not click her own name. Ten checks now drive a real browser alongside the sixteen offline ones, and they caught three more the same day: a click handler that threw on the wrong kind of element and killed the comment box, a page that left sign-off enabled for everyone while it waited on the network, and card numbers that skipped from fifteen to nineteen.
What I take from it: ask what a test cannot see before writing another one that passes. If the thing you are building has a queue, a cache, a network or two people in it, your local copy has quietly removed the part that fails.
A game system for the room nobody can control. A teacher walks into a class they have never met, in a subject that may not be theirs, with work left that half the students will not touch and no consequence available if they refuse. The only thing you can actually take off a fourteen year old is a turn, so the whole system runs on turns.
Students sit in crews and bet 1, 3 or 5 points before they hear the question, then only get the question at the level they chose. The one calibration that decides whether it lives or dies is the loss: wrong costs a fixed single point and never the amount staked, because stake-proportional loss kills the top tier inside two rounds and the room settles back into playing safe. A student two years behind can win on the low tier, a bored one can chase the top, and nobody was sorted by anyone in front of the class. The second pass read all 576 answers as a sharp fourteen year old would and found two that were wrong, plus thirty two hints that quietly read out the answer they were meant to unlock.
144 round cards and 576 questions across maths, English, science, history and geography, health, plus a deck for the day the teacher is handed nothing at all. Every card carries its own answers and a real syllabus outcome code, verified against the state curriculum authority rather than written from memory, so the lesson stands up to whoever walks in. The second audit found the harder version of that problem: every code was real, and 52 of them belonged to syllabuses that do not start until the following year. A real identifier is not the same as the one in force, so those cards now carry the code schools teach against today with next year's beside it, and a build check refuses any code that is not on the verified list. There is a projector scoreboard that remembers each class between lessons, and a print pack that runs the whole thing on paper with one pencil per group, because the students turn up with nothing and the system had to assume it.
Two bugs worth keeping, and a screenshot caught both. The print stylesheet lost a specificity fight with the dark-mode block, so a laptop set to dark would have printed black cards and eaten a toner cartridge. And on the projected version the teacher's coaching note sat openly on the same screen as the question, handing every group the hint for free while every check passed. Neither is visible to a test, because neither is a behaviour. Both are properties of the whole frame.
It runs three ways off one address. On the classroom screen it walks the teacher through a whole lesson and holds every answer back until they ask for it. On paper it is one green button that prints the entire pack in order, about forty three pages, with nothing for a school office to work out. And it keeps working with the wifi down, because a room where nothing works is the room it was built for.
Then a real person used it and said it was confusing and the questions were not clear, which is the only review that counts. So it became a live game. The teacher signs in, sets up the class and the crews, and a six-letter code goes on the screen. Each crew joins on one device, stakes before it sees anything, gets only the question at the level it chose, types its answer, and watches the ladder move as the teacher marks from the front. One Worker, one durable object per game, no student accounts and nothing kept about a child beyond a crew name and a score. Every one of the 576 questions was rewritten so a thirteen year old reads it once on a phone and knows what to type. A scripted teacher, screen and two phones play a whole lesson before anything is called done, and the first run against the live site caught a bug the local run never could: a final save that landed a moment too late over a real network.
The last piece is the one nobody builds: a checker for the content itself. 576 answers is the kind of review that gets started once and abandoned, so it hands the reviewer one card at a time, remembers where they stopped, and exports everything they flagged as a single block that already carries the card, the tier and the outcome code. Hand over the instrument, not the job.
A complete iPhone fitness app built to prove a point: a cross-platform app can feel native if you bind to the platform's real materials instead of rebuilding lookalikes. It uses Apple's actual Liquid Glass, the real system icon set, the genuine native tab bar and Apple's semantic colour tokens, so it inherits dark mode and accessibility for free, with the rings and charts drawn on a GPU graphics engine. Sixteen routes with a live workout timer whose splits survive the app being killed mid-session, and it declares its own rendering path on screen, so the claim that it uses the real system material is something you can check on the device rather than take on trust.
A native iPhone journal that turns identity into something you can watch grow. You name who you are becoming, add one small proof each day that you acted like her, and every proof is woven into a living tapestry of light that breathes, shimmers and leans toward your touch, with sealed letters to your future self and weekly reflections written by the AI inside the phone itself, quality-gated so they always read well. No account, no cloud and no network code at all. It went from empty folder to a store-signed build in a single day, then survived a 57-agent adversarial audit across nine failure lenses, with every confirmed finding fixed and re-verified against deliberately hostile data.
A slingshot physics game turned upside down: the enemy city hangs from the sky, your spark cuts whatever it crosses, and gravity does the destruction, so aiming means choosing what falls onto what. Everything the moths built falls into the valley and every lantern you free floats up out of the wreckage, so one glance tells you how the shot went. All the art was painted by an AI model running locally on one Mac, every level is proven winnable by a bot playing real shots through the real physics before it ships, and a date-seeded sky builds a brand new city for the whole world every midnight.
A daily descent game where everyone on Earth walks the same bottomless cave. One lantern of oil per real day: steer the flame down, skim falling ice for sparks because near misses feed the fire, then plant the lantern as camp and start there tomorrow. The whole world is pure mathematics computed on the player's device, so the shared cave needs no database at all, and strangers' camps light the path and make the walking cheaper for everyone after them. Built through four human feel-test rounds and a seven-lens automated audit, with every release gated by a 36-check verification battery.
A graze-to-score arcade game built as a single file, no engine and no dependencies. Touch anything and the run ends, and the only way to score is to fly close enough that sparks jump, with a heartbeat that quickens near danger, a slow-motion kill-cam, daily seeded runs and an economy where losing pays. Play it inside Muplu, and it is heading to Steam as a tiny native desktop app.
The sequel that turns the first game on its head. In FLINCH you were prey and the whole craft was to touch nothing; in PREDATOR you lunge through red to shatter it and the kills chain, so diving deep into the swarm pays far more than picking off safe singles. It reuses the FLINCH engine wholesale and was proven aggressive by an automated hunter before a person ever played it.
An endless interactive world in a single file, rebuilt in September 2026 so that nothing in it can end, be scored, or run out. One point of light grows under your touch into a branching organism with travelling signals, small flocking lives and a constellation of every place you touched, and its deepest points ripen into doors down into further worlds that each begin as a single point again. Only the world you are standing in grows; the ones you left stay exactly as you last grew them, and you never lose them. Every visit mints a new named world that grows by a real law of nature, leaf venation by space colonization, tree boughs obeying Leonardo's branching rule, or mycelial drift, and any world's name regrows it exactly. There is no ceiling on how large a world becomes: the cap lifts as the world fills and holds only when the frame budget says the machine has had enough, so the piece densifies to the hardware it is hung on. Step all the way back from a world you have grown and the thousand pieces gather into one golden angle disc and then into the single point you first met, and one touch unfolds it again. Built to run unattended for weeks as a wall hanging. Fully procedural, generative audio, no dependencies, no network, held by a 41 check automated gate that runs before every deploy and blocks it on a failure.
The game grown out of the unfold engine, and named for its inverse: to infold is to fold inward, where the artwork opens one point out into a whole world. You plant lights to steer a world that grows itself, and the deep points ripen into doors down into further worlds that each begin as a single point again. Lights are the only currency and they are spent three ways, so tending the world you are in competes with leaving it, and forcing a door early always works but the haste is inherited by every world below you and never wears off. A fold holds twenty minutes of world time that only runs while you are actually there, so the quiet never chases you, and it seals the fold wherever you stand. Its economy is held honest by a policy harness that plays six strategies against the real update loop and fails the build when one constant solves the game. When the fold closes it does not shut: every world you grew becomes a permanent gallery you can walk back into and keep growing, while no new doors will open again, and touching a sealed point copies a link that regrows the whole fold on any machine. Entered into the Independent Games Festival 2027 on 8 September 2026.
A physics roguelite where the ball is a little guy: flick a rag-doll stickman crash-test dummy into a peg mountain of office furniture, watch him flail, snag and dangle one-handed off the jackpot ledge, and get paid for wherever he lands. The design is locked across five documents, the prototype is verified with measured drop economics and honest physics, and it is heading to Steam.
The classic maze chase rebuilt from scratch as original work: a mouse in a moonlit kitchen, four cats that each hunt with a different mind, and catnip that turns the tables for chained nose-bops. The forty-five-year-old design canon is carried faithfully (the pursuit personalities, the prowl-and-doze rhythm, the escalation tables) under a contemporary layer of buffered swipe cornering, near-miss whisker scoring and near-death slow motion. Every maze came out of a small foundry that proves its layouts fair before they are allowed in, and a dodging robot had to survive the cats to bot-verified standards before the game was allowed to publish. Along the way the robot found three engine bugs no human tester had noticed, including a pack of cats that had quietly never left their spawn wall.
A physics merge game in a glass jar of night: drop celestial bodies and two of a kind become the next rung of an eleven-tier ladder, dust to spark to moon to sun, with two suns going nova. The physics engine was written from scratch and hardened by its own test robot, which caught phantom launches, jittering floors and exploding merges that no human eye had noticed, and the fairness numbers had to pass a locked battery before the page could exist. Cascades chain, riding the brim pays extra, wishes are earned and never bought, and the daily jar is one seeded sequence for the whole world.
A seven by seven jar that keeps filling with light, three pieces at a time and a little faster every minute, where the only job is to make room. It has two ways to play rather than one, which was not the plan. I built two prototypes to settle which input the game should use, tested them with my thumb instead of arguing about it, and the answer that came back was both. Gather three of a colour together, or drag a chain through the whole colour at once.
The design says bold play must pay better than careful play, and it went through thirty one passing checks doing the exact reverse. Three separate bugs, one family. A bonus multiplier was read after the move resolved, so the bigger the move the smaller its own multiplier. A streak bonus counted pressure but not effort, so the cheapest possible move made under pressure earned the reward that courage was meant to buy, paying nearly three times as much per move on a third of the work. And the difficulty curve advanced on a counter that bold play increments more slowly, so the bold player got an easier ride. Every one was defensible on its own, and together they made timidity the winning strategy while nothing said so. What found them was changing the shape of the test: an incentive is a relationship between two strategies, so it can only be checked as one.
Then I was told it looked like everyone else's game, boring coloured circles, and that was correct twice over. Measuring the palette turned the complaint into arithmetic: five of the eight pieces sat inside a 1.09 to 1 band of brightness, so in greyscale they were one colour, and under a red-green deficiency the closest pair was eight apart in RGB, which is invisible to roughly one man in twelve. Rebuilt as a brightness ladder with a measured step at every rung, plus eight different silhouettes so a piece is readable by shape alone. The sprites also turned out to be drawn at half resolution and magnified, which is a large part of why it looked soft.
It has a cast now, because nothing on the board had any intent. Two things that work against you and two that work for you, and you can tell which is which with the colour taken away entirely: foes are angular, dark and narrow-eyed, allies are round, bright and wide-eyed. Eyes do the work, since a thing with eyes is alive and a cut stone is not.
It is live across twenty-four bot-measured levels, with shape-coded pieces and four creatures that work for or against the next move. The same build also runs as an iPhone app and builds for Android.
An internet playground of odd little toys, in the spirit of neal.fun. Forty-six are live across six wings, each on its own shareable link with no signup and nothing to install, behind a homepage whose thumbnails are tiny live animations of the toys themselves. The wings are play, immerse, little, together, tomorrow and inside, and each is a whole world with its own palette and pace, so a bedtime storybook for a very small child never sits in the same room as a reflex arcade game. The newest six arrived in a single day, one per wing, each deliberately a first of its shape for the shelf: a wall-hop climb out of a well, a hillside of bells tuned so a wrong note is impossible, peekaboo with someones who want to be found, the folded-paper drawing game on one passed phone with the fold enforced in code, letters to your future self that a night sea keeps until their day without a single word leaving the browser, and a mirror that hides every clock and tells you how long your minute really is. The newest six arrived as a single batch, one per wing, each built to a written depth standard with machine-verified checks before release: CUCKOO, a daily deduction puzzle whose nest refuses to accept a guess; NETTLE, a wave defence where one lash does three jobs and five growth slots force real choices; SWORN, an honest false-memory mirror that draws your confidence against your accuracy; DAPPLE, real Turing reaction-diffusion patterns growing under your finger; DOLLOP, a colour-mixing pond for small children that says the new colour's name out loud; and FOGHORN, a two-player game for one phone where the rocks live in one head and pass through a voice into the other's hands. One wing runs on real-world time, another reaches across distance with two-player games joined by a code in a friend's own email, and the inside wing is played entirely with your head. Every arcade toy is machine-verified fair before release, every toy is free to play, and the build refuses to publish at all if a wing ever drifts from the catalogue behind it. Every page now carries a share button that hands the exact toy to someone else, the native share sheet on a phone and the link on the clipboard on a desktop, built as one component that wears each toy's own palette without a line of styling written per toy. Every toy is held to one shared floor: sound with a mute a thumb can reach, safe areas, one-thumb play, a return state and zero errors, proven by a shelf-wide gate that plays all forty-six in a real browser at phone size before anything goes out.
Three two-player games that let people in two different houses play each other with no account and nothing to install, one for each generation: LETTERBOX deals the same nine letters to both players for a gentle word duel with no clock, made first for players over sixty; ROCKPOOL is a bluffing duel of hidden shells revealed at the same second; POUNCE is live snap for quick paws, ninety seconds a game, six emoji and no chat. The invite is an email the player sends from their own address, so it lands from a person the friend knows, and every room keeps a rematch tally and quietly deletes itself after two idle months. Each room runs in its own strongly consistent object at the edge with hidden hands filtered server-side, and the whole shelf was proven by an automated pair of browsers playing full matches against the live site.
A free image library in the spirit of the big stock sites, with three differences none of them can copy. Every picture shows the full recipe that made it, the model, the words, the settings, with a copy button, so a woman leaves with the image and the means to make her own. The catalog grows to order overnight: describe the picture you could never find, other women vote, and the top wishes are grown on my own machine while I sleep, appearing the next morning credited to the woman who asked. Every single image is free with no wall.
A gentle bedtime storybook a child helps make, tapping the page to add a star, a shell, or a lantern of their own. Five short stories, every page its own paper-cut scene made on my own machine, read aloud in a warm neural voice that keeps working even offline. One switch turns the whole book, words and narration, into natural Spanish. Made for a friend's little one.
A pair of quiet toys for very small hands, one made of snow and one of sand, built from research into what parents of under-fours actually want on a screen. A whole palm gathers a ball or pats up a tower, and it stays exactly where the child leaves it, so ten minutes of play is right there in the shape of the field. Stack the pieces and they build a snowman or a flagged sandcastle, and a tall one only stands if the base is bigger, a rule a child works out with their hands and never has to be told. There is no score, no chime and nothing to win, both work with the wifi off, and the snow and the sand are conserved to the last grain so the toy can never run out or be finished.
A parlour game of fairy light for a room of two to twelve people sharing one screen, passed hand to hand like a deck of cards. People draw a gorgeous tarot card from one of four chambers, tell a truth, hunt a secret, or testify for the person holding the device, and a luminous fairy carries each answer up into a night sky the whole room lights together. It plays entirely offline with nothing to install and nothing collected, the art grown on my own machine, and it is the first toy in Muplu's together wing.
A calm sub-world of Her Frontier for the family with little ones, on its own subdomain. At its heart is a free Chart Maker: tell any AI helper about your child, paste what it writes, and out comes a gentle routine chart in the same soft design, with a picture on every step, ready to print and working offline. It is the free tool that turns the paid printable pack into your child's own, and the doorway that brings parents onto my platform.
My brand's home. A bright day and a deep night from one design system, switched by every visitor, with membership you can pay for by card or in crypto and a recognition layer where finished work moves a member through five named levels. Now carrying the Frontier OS layer: a guided strategic instrument with a privacy panel that lets her choose who writes her reading, her own AI or none at all, a sovereignty audit whose full ledger never leaves her browser, and a capability record she can share one entry at a time. Live behind the launch gate.
The public home of everything on this map, at builds.herfrontier.com. Every build gets a card and an honest status badge. The graduation film streams from the page. A five-part "How I build" note says the rules the whole portfolio follows. Day and night themes run off one token set, and you can watch the page by email link or Atom feed. There's no backend behind any of it.
Five written workshops a woman works through at her own pace on her own machine, each one taken from something that runs on my Mac every day: clearing the invisible characters out of anything she publishes, reading her own WhatsApp into a morning page, a three-layer safety net with a restore she does in the room, a private AI office that answers with the wifi off, and her first agent, a plain job that runs tonight at six. Every command was run on my own machine before it went in, nothing sends, posts, spends or deletes, and one email opens the room. Live at workshops.herfrontier.com, with three of the five behind the launch gate until they are read.
A free, self-paced workshop that walks a woman through building her own real website using two things she already has: her own AI brain and her own brand. She never learns to code; she learns to direct, while her Sovereign Brain writes the actual site and her locked brand kit keeps every page looking like her. Nine steps take her from naming the site's one job to a live link on the free internet, ending with the three reads that prove the site people visit is the one she built, with a bonus module that teaches tasteful motion and hands her the exact code to add it. She walks out owning a live site and a kit that can rebuild it any time.
A free, self-paced workshop that gives a woman her own voice as an AI model she owns, on her own Mac, for nothing. Seven guided steps take her from a single clean minute of recording to a private voice model that reads anything she types, with the whole technical setup collapsed into one file she double-clicks, no code and nothing uploaded. It then presents the hosted alternative with a real consent and acceptable-use step and a bring-your-own-key rule, and it is built on a licence-first choice of engine so the voice is free to use in her own business. Built on the reusable Her Frontier course engine, running end to end.
Your actual birth sky, built from over a thousand real stars positioned exactly where they stood above your town at your minute, verified to under a degree, with a soul constellation drawn from a fingerprint of your birth data that exists for no one else. A slow scroll reads it back to you in five written chapters and ends with a share card you can keep. Free to explore, the full reading is paid.
Chat with an AI and watch it think, live, as it weighs and picks each word. Every word it says appears as a gold star sized by the exact probability it was chosen with, the words it weighed and set aside surface in turquoise, and its private reasoning drifts up as cream ghosts before the answer arrives. A strip below marks the moments the answer could have gone another way. It reads on a phone as well as a desktop, and the map can take the whole screen while the question box stays put.
A whole business desk for a woman working solo: clients, invoices with totals and tax to the cent, time tracking with a live timer, and one-click proposals and contracts. It runs two ways from one build, a private copy on her own computer where nothing leaves the machine, or a hosted members' account where every woman's data is walled off by the database itself.
One AI character, looking like the same person in every tool. That's the part most creators can't get right. It teaches you the lock method first, then builds your character with a coach on every field. You leave with a brand bible: the current recipe per platform, a consistency checklist, a palette card, and a month of content slots.
A three-page explainer on the million dollar question holding up banking, crypto and AI. The first page tells the story in plain language. The second replays fourteen real proof attempts with every mistake left in. The third runs a solver in your own browser at millions of moves a second, so you watch the exponential wall arrive on your own machine.
A local sandbox that shows what Instagram and TikTok actually reward in 2026, built on fresh research with every claim confidence-labeled. Set up a post, score your hook against a five-axis rubric with a live kill list, then watch 200 simulated runs climb each platform's test-audience ladder to a median outcome, a range, and a viral probability, with a clear diagnosis of what is capping the reach. Drop in a finished reel and an on-device pipeline grades it 0 to 99 across six weighted dimensions, from the hook window and dead air through loudness, pacing, CTAs, caption coverage and safe zones, with a fix attached to every flag. Runs entirely on-device and feeds winners back into a personal hooks log.
A puzzle box where the lock is real cryptography instead of a stored answer. Five rooms hold five shares of one 32 byte key, split three of five with Shamir sharing over the same 256 element field AES uses, and each share is sealed with AES-256-GCM under a key derived from that room's own answer. The page therefore cannot tell a solver whether they are right. It can only try the answer as a key and report whether the authentication tag held, so opening the source teaches the whole mechanism and gets you no closer to opening the box. The rooms are a nonogram whose clues were proved by an exact solution counter to admit one grid, a cipher with a workbench that ranks candidates by English likeness, a Lights Out board that opens only for the lightest press set, an alphametic, and a set of self-referential statements where suspending any single one breaks uniqueness.
It then became a daily on the toy shelf, and the daily is where the second idea arrived. Streaks bring people back by fear, and a missed Tuesday deletes the number you were building. Three of five turns that into forgiveness: one room a day, five in a week, and any three of them open the week, so two can be skipped for any reason and nothing is taken away. The mathematics enforces that rather than a rule in the code. It is also why the share line cannot be forged: holding a room means holding a piece of a key that only a right answer produces.
Every instance was generated and then attacked by its own solver before it was allowed in, because a puzzle with two answers is a bug rather than a puzzle. A build-time test opens every seal and rebuilds each payload from every valid combination of shares, and a browser harness runs thirty three gates against the minified build on a phone-sized screen, including that the audio context is running rather than merely wired.
A market training room built as three doors. Replay real crashes week by week with play money, pausing mid-fall to ask hold, sell, or buy, then see what every choice became and how you actually behave under pressure. It also runs the Frontier Pressure Index, a weighted read of how hard the market is pushing you to act. Scenarios always, forecasts never.
Pick any day since Bitcoin began, enter what you bought, and see the truth about your timing on verified data, in both US and Australian dollars at the exchange rate of the day you bought. A directory of sixty-five exchanges helps you recall the closed and collapsed ones, and a cycle simulator maps the four-year waves as honest scenarios rather than forecasts. Works offline and installs as a phone app.
A public, dated record of what I build, kept as I build it, at nicolakharvey.github.io/build-log. Every entry was working before it was written up, each carries its proof link, and the page lives in version control so the commit history is a second timestamp I never have to maintain. It opened with six entries spanning July and August 2026 and grows most weeks.
Medium retired its publishing API, so my desk grew its own door: a dedicated browser driven over the developer tools protocol that stages a complete story, title, cover image and formatted body, as a saved draft, screenshotting every step as proof. It never touches a credential, and for a long stretch the last press and the tags stayed human on purpose. Now the bridge can take that press too, on my say-so: it opens the staged draft, adds the topics, presses Publish, and refuses to call the story live until it appears in the public feed, because a click is not a post. The scheduling desk fires it at the planned time, and if anything is off, a login, a failure, a story left too long, it hands the piece back to me as a reminder instead of guessing. The first essay went through it the same night it was built, and a batch of three followed the next.
A complete social scheduling desk that runs on my own machine and replaces the monthly subscription: one calendar over fourteen channels, with real publishing proven end to end. It carries scoped team access, so a teammate gets a login showing only the brands I choose, enforced on the server, and they reach it from their own computer over a private address that never exposes the machine it runs on. That boundary is no longer something I check by hand and hope stays true: every probe I ran auditing it is now a test that runs on every build, one for each thing a teammate must not reach and one for each thing they must, so it goes red if somebody over-tightens a permission as well as when they loosen one. I proved it catches a real breach by switching an ownership check off on purpose and watching the right test fail, then putting it back. That scoping now reaches the reading screens as well: a teammate opens the same insights and activity views I do and sees only their own brands, with the check made by the thing that hands back the data rather than by hiding a menu item, and records that carry no brand of their own stay with me rather than defaulting into somebody's view. That door is built for the open internet it sits behind: wrong passwords are rate limited per caller rather than globally, so a stranger guessing cannot lock me out of my own desk, and a login survives a restart so nobody is quietly signed out. Each account can also run through its own developer app rather than one shared across a platform, so a separate brand keeps its own rate limits and its own blast radius, with those credentials held in the file that never reaches the browser. Adding a channel is proven the same way: the newest one was taken from a dead connection to a real film sitting in the account's drafts in a single evening, with the upload confirmed by the platform rather than assumed. Video now publishes through the route the platform actually reserves for the short-form format, after a week where the desk and the platform both reported a post as live and the person holding the phone still could not find it. The old route had quietly decayed into a convincing imitation, reporting success while landing the film somewhere the format's own tab never looks. The desk now waits for a real verdict rather than calling it done when the bytes arrive, refuses to claim success in any other state, and if it ever has to fall back it says so in words, because a silent substitution is a bug with good manners and costs far more to find than an honest error. It now reads its own results too: an insights view that pulls real reach, saves and interactions from each connected account and shows what is working by format, theme and time of day, then turns it into a shareable PDF report with plain recommendations written from the numbers. Every brand also publishes through its own front door: a platform fetches a video by following a link rather than receiving the file, and that link used to carry one address shared by everything, so one brand's content was quietly served from another's domain. Each brand now carries its own host for both the media link and the sign-in redirect, with brands left alone resolving to exactly what they had before, proven against the running server so no existing connection breaks. On top of that sits a cover frame picker, because a grid cover cannot be changed once a post is up: you scrub the actual video, see the frame, and that frame becomes the tile, which stops a run of clips that open the same way from turning into a wall of identical covers. Connecting a channel now explains itself, which sounds small and is not: when the proper sign-in route is unavailable because a developer app has not been set up yet, the desk names the missing piece rather than quietly opening a lesser path. That lesser path is the one that hands you a credential nothing can renew, so it works beautifully for a month and then stops without announcing it, and the person it stops is always the one who was told nothing at the time. Posts can also be archived rather than deleted, for the case every scheduler forgets: somebody already posted it by hand. An archived post keeps its original date, disappears from the calendar, and can never fire, and restoring it is time-aware, so it goes back to its own slot if that moment is still ahead and into drafts for a fresh time if it has passed. Every brand's email now arrives in the same desk, and that part had quietly stopped working for weeks without a single error anywhere: the thing that fetches the mail was running perfectly on schedule, it was just asking for anything newer than a place that no longer existed, because the store it reads from had been rebuilt underneath it and started counting again. It now checks whether its own bookmark is still real before it asks, and quietly starts over when it is not, which it can do safely because every message carries an identifier that stops anything being saved twice. I can also finally delete mail, which sounds small and was the reason old test messages had been sitting beside real enquiries with no way to clear them. Replies go the other way now as well, so a message to one of my businesses is answered by that business, from its own address rather than mine. Which service carries a brand's sending is a choice I make per brand instead of something fixed in the code, because a domain sends through whichever one holds its signing records, and that can change. The newest brand went the whole way in an afternoon, from a domain that could only receive to one that answers, with every step proven against the live domain before I trusted it with anything real.
It no longer needs my laptop awake to keep a promise. Posts where every channel is set to publish on its own are handed to a small service of mine in the cloud, with their video travelling too, and it puts them out on time while the machine that scheduled them is asleep. Only one of the two can ever publish a given post, which is the part that took the care, and I proved the handover by pulling a fifteen megabyte film back out of cloud storage through the service rather than trusting the word "uploaded". The cloud half runs the same publishing code as the desk instead of a copy, so a fix reaches both. A deploy is still a photograph of your files at one moment, though, and I found out what that costs: a fault I had repaired the day before went out again from the cloud, on the older picture, and took a post's links with it. Checking the built package by hand was never going to hold, so the desk now does it. Every deploy records a fingerprint of exactly what it shipped, and while any channel's code on my machine no longer matches that fingerprint, the desk quietly keeps those posts and publishes them itself rather than handing them to a service running the past. It hands them back the moment the two agree again. The worst case is now a post that goes out late instead of one that goes out wrong, and I proved it in both directions before believing it.
Direct messages now arrive in the same desk as everything else, which took finding out why they were missing in the first place. The platform was not refusing the request and not returning an error; it was answering with an empty list, because at the access level the app held it will only describe people who already have a role on it. A silent empty answer is the worst shape a permissions problem can take, since every reasonable reading is that there is simply nothing there. Messages now land beside comments in one inbox, sorted by the desk rather than by me, unanswered ones sitting bright at the top and, once handled, both receding into the page and dropping to the bottom, because making finished work look quieter is not the same as getting it out of the way. A conversation can also be archived when it deserves no reply at all. Drafting reads the whole conversation instead of the newest line, because a reply written to one message in isolation answers a thread it has not read.
Messages now arrive on their own. A worker sweeps every conversation on a schedule and brings anything new into the desk, which sounds trivial and was not: the page carries no links, so a conversation can only be opened by clicking a row and reading the address that results, and it says who sent each message purely by which side of the screen the bubble sits on. Sender direction is therefore read from geometry, their messages sharing one edge and mine sharing the other, and I checked that against a conversation whose answer I already knew before trusting a single batch. It skips any thread where I spoke last, since there is nothing new to collect there. The duplicate guard sits in the desk rather than in the sweep, and it matches on content instead of identifiers, because every way of importing invents its own ids and the second one you add will otherwise bring back everything the first one already had. I proved that by running the whole sweep twice and getting nothing the second time.
The hardest message this account gets is somebody realising the person they were talking to was made, and being disappointed about it. That one is not a writing problem to solve fresh each time, so it is fixed text I wrote and approved rather than anything generated, and it sits alongside a written position on being made that I researched properly: the long history of authors writing as invented selves, and the strongest published argument against synthetic companionship, which the reply agrees with rather than defends against. The page it points to now answers what the message just raised, because a reply and its destination are one piece of writing and I had them as two. It ran end to end on a real conversation, and the person read it.
Sending closes the loop, and the interesting part is where the line sits. I approve specific words for a specific person, and a small worker does the typing, so nothing is ever composed or sent that I have not read. It works through a browser of its own that I open by hand, on its own profile, so it can never type into a window I am using, and that window doubles as the switch: open it and approved replies go out, close it and they wait. It checks the box actually contains what I approved before it commits, which is not paranoia, since one earlier message ending in a small icon quietly left only the icon behind and dropped every word while reporting success. There is a stop switch, a daily ceiling, a pause between messages, and approvals expire, because something I agreed to this morning may be wrong by tonight.
One platform simply will not let a tool of mine post, and finding that out was most of the work. Its approval sits in a queue with no promised date, and until then the only thing the official route can do is send a video to my phone as a notification for me to finish by hand, one at a time, which for a queue of forty five is not a schedule, it is a chore. So the desk now drives the website the way a person does. The important part is not the automation, it is where the line sits: it only ever uploads videos I already wrote and scheduled, so it never composes anything and never chooses a moment. It works through a browser I open myself, on its own profile, and that window is the switch, open and the queue drains, closed and it waits. It does nothing by default and posting is an explicit instruction every time, it reads the caption back out of the box before it commits, it pauses between posts and stops at a daily ceiling, and one file anywhere on the machine halts it. Two things only the real page could teach me, both caught before anything went out: the button that takes the file is invisible by design, and the word Post matched two buttons where the first one was not the one that posts. A first attempt would have pressed the wrong thing. The first real video went up and I checked it from outside my own session, because a tool reporting its own success is not evidence.
Underneath all of it sits the same lesson three times in one day. A connection that reports itself healthy is telling you about reading, not writing, so one platform listed my boards happily while refusing every attempt to add to them, and another offered me the setting for posting publicly while barring the post itself. A tier is only ever proven by the exact action you depend on. The desk's own screen turned out to be the third case: it keeps itself current by listening for updates, so the moment that connection drops it carries on showing the world as it was, and I had spent an afternoon fixing failures that were still sitting there in red. It now goes and asks for the truth again whenever it reconnects.
Then a crash taught me the rest of it, and both halves were the same mistake wearing different clothes. Everything in the stack restarts itself except the browser window a person has to log into, so the queue quietly waited while the worker wrote its refusal to a log file nobody reads and every screen said healthy. That refusal now reaches the desk, raised once so it stays readable rather than every few minutes, and the windows are reopened automatically, which took one more lesson than I expected: a browser started as a child of a scheduled job is killed the moment that job finishes, so it binds its port, reports success and is gone seconds later, which looks exactly like working. The second half was worse because the tool was lying to me cheerfully. The platform runs its own checks on an upload and leaves the button live the whole time, so the worker pressed it, a question appeared about posting before those checks finished, nothing answered it, and the video never went up. The log said posted, the desk said done, the profile was empty. It now waits for the platform's own checks to come back clear, refuses when one flags something because that judgement is mine and not a script's, and then goes and finds the post on the account and matches it to what it sent before recording anything as done. Pressing a button is an intention. Only the destination knows whether it happened.
The last one was the one that hurt, and it was hiding under all the others. The posting window had been signed into the wrong account for months, a near-copy of the right handle with an underscore through it and nobody following it, so everything worked perfectly and delivered to an empty room. Every check I had built asked whether the machinery ran. None of them asked which account it was standing in. It reads the account identity off the page now and refuses to post at all when that does not match what the desk says, which is the only check in the whole chain that cannot be satisfied by things working. The same day taught me a third state I did not have a word for: a post that exists and is invisible, held private and under review, which a system that only knows success and failure will quietly file as success. That evening the whole thing ran without me for the first time: the schedule raised the piece on the minute, the worker checked which account it was standing in, waited out the platform's own checks, posted, went and found the result on the profile and only then wrote it down. Six words in a log file, and the first honest ones the system has produced.
The newest lesson was not a bug at all, it was a repair that outlived its reason. One channel had quietly become a single-format feed, nearly eighty percent of everything queued on it was one series, and nobody had decided that. A platform limit had once made cross-posting expensive, one caption rewritten by hand per post, so a script pulled that channel off every post that already had a home elsewhere, correctly sparing the one series whose only home was there. Two days later I engineered around the limit and captions started typing themselves, and nothing went back to undo the strip, so the exception became the whole channel. A workaround does not announce that it has expired, it just keeps producing a result that starts reading as a decision, and the only reason this was findable is that the script's own opening paragraph said why it existed. The desk now rebalances instead: it caps any one format to a single post a day per channel, moves only the posts that have nowhere else to be so nothing else on the calendar shifts, and it counts what is actually postable rather than what is on the disk, because two thirds of the finished videos I expected to draw on turned out to be twenty four hour stories and turning one of those into a permanent post is the wrong shape for the piece. The same pass caught the thing I care about most: a post queued to one brand's account carrying another brand's film, with that other brand's name on screen, made by an earlier catch-up run that attached the wrong file. The guard I had built warns while you work, and it had never swept the posts made before it shipped. A check at the moment of creation is not a check on the queue.
Which led to the thing underneath all of it. I had assumed that giving each brand its own developer app kept the brands apart, and it does not. One access token carries every page and account the person administers, so a token connected for one brand can publish to any of the others without a single error, because nothing about it is invalid. The wall was never there. Each account now names the one destination it is allowed to publish to, that name is held somewhere the publishing code cannot rewrite, and a post whose destination does not match is refused before anything leaves, with both destinations in the error so I can see what nearly happened. I proved it by pointing an account at the wrong destination on purpose, forcing a real publish, and watching it refuse with nothing sent. Then the part I nearly got wrong: I had put the guard on the one function every publish went through, which is exactly the sort of claim that feels complete. A second engine existed, the cloud half running its own copy of the same code, and it never touched that function. A choke point only chokes the paths that run through it, so the real work was listing every path that can reach the same action and checking each one by name.
Then I was shown a number and it was wrong, which turned out to be the most useful hour of the build. My own screen said one of my videos had a hundred and sixteen views while the platform's own screen said two hundred and seventy six, and neither was lying: they were two different measurements sharing an everyday word, one counting people who watched past three seconds and one counting plays. The cause sits deeper than a label. The thing you post and the thing that holds the numbers are two separate objects, so asking the post gives you a thin, technically true answer while everything real sits on the video behind it, including reach, which I had already written off as unavailable on the strength of asking the wrong object. Reading it properly took one page from under six hundred counted views to nearly nineteen hundred people reached. So I stopped guessing field names: ask any of these platforms for a metric you know is fake and it refuses by listing every valid one, which handed me twenty three where I had been using four, and the same audit on the other platform found it had been requesting a number for months and never reading it, thousands of views fetched and dropped on the floor. Where a platform will not measure something the screen now shows a dash and never a zero, because zero says nobody did it while the truth is nobody counted, and every number carries the platform's own definition beside it so nobody has to guess again.
The last piece was noticing what a leaderboard quietly costs you. My reporting pulled the full numbers for every post I have ever made, built a top ten, and let the rest evaporate when the page finished loading. Every dashboard does this, and it means you can name your best post and not your worst one, which is the more useful half: your best work tells you what to repeat, your worst tells you what to stop, and you are probably still doing it on schedule. Every post is now kept, and not just its latest numbers: each check adds a dated reading whenever a figure actually moves, so the record outlives the platform's own reporting window and I can ask whether a piece is STILL earning rather than only how it did. It gathers those readings itself, once a night, one account at a time so nothing arrives at the platform in a burst, and only over the posts recent enough to still be moving. Picking a quiet hour nearly undid the whole thing, since the quiet hour is exactly when the machine is asleep, so it treats that hour as a preference and catches up whenever a night has been missed. That distinction matters more than it sounds, because something that got four hundred views on day one and stopped is a different thing from something still climbing three weeks later, and a snapshot cannot tell them apart. Asking for my five weakest posts now takes a second instead of a re-download. The table also opens on everything I have ever posted rather than a recent slice, and every column sorts, which mattered more than it sounds: ranking by one number was quietly deciding what I believed about my own work, and the moment the columns opened up, a piece sitting seventh on the headline measure turned out to be first on another one, beating five things above it. Nothing new was measured. The order was the opinion. It reads all of that from my own copy rather than the platform, which took the page from half a minute and a hundred and twenty seven requests every time it opened, down to under ten milliseconds and none, and it says on screen which copy you are looking at and how old it is, because a stored number presented as live is a lie with good manners. Anything the platform never measured sinks to the bottom of that list rather than topping it, because unmeasured is not the same as bad and I would rather not spend a month fixing content that was fine and simply uncounted.
Each brand on the desk now has its own page for how it speaks and what it speaks about, and building it turned up the reason the voice had not been landing. The document was being pasted into the prompt with a character limit on it, and one brand's ran four times that limit, so the model read the first quarter, cut off mid-sentence, with the words-we-use and words-we-never-use lists both sitting beyond the cut. Another brand's writer was ignoring the document altogether, silently, so editing that voice had changed nothing for weeks. Both now hold a working copy sized to arrive whole, written for the one job of drafting a reply rather than for governing a brand, and I proved it by intercepting the real prompt and searching it rather than by reading the wiring. The content pillars stopped being the generic starter set every tool ships with: they are derived from each account's own back catalogue, scored against it at 92 and 85 percent, and the page runs the matcher over real captions so a set of themes is tested rather than guessed.
The channels with no usable API publish on their own now as well. One of them prices its write access out of reach and another has no publishing interface at all, so both had been producing reminders instead of posts, and the browser lane built to serve them had never once run. Seven separate faults were sitting in it and only the last one really mattered: it typed into the compose box before that box had finished wiring up its own editor, so the words went nowhere, silently, and the safety check that compares what is on screen against what I approved then reported a text mismatch and sent me hunting a problem that did not exist. It types, reads back and retries now. The gates above it are the part I care about. It reads which account the window is standing in before anything is composed, it will not call a post done until it has found the thing on the public profile, and if the window is shut the queue simply waits, so the worst case is the manual workflow I already had. The first post went out on its own with nobody watching it.
The newest one arrived looking like a scheduling mistake and was two silent refusals sitting on top of each other. A run of posts sat as drafts on consecutive days, every one of them overdue, and every reading of that screen says somebody filled the calendar in carelessly. Nobody had filled it in at all. Each post was written long for one channel and carried a second channel's account as well, and the desk held that second one to a short character limit, so it refused to schedule any of them and said so only in the instant of saving, which nobody was watching. The limit was wrong on its own terms: my account on that channel pays for long posts, and the desk had the free tier's number written into the code as though it belonged to the platform. A ceiling belongs to an account. Underneath that sat the second refusal. The worker that posts to that channel through a browser had been dead for a fortnight, because the scheduled job that starts it runs with a bare minimum of an environment and the worker was being called by name instead of by its full path, so it died on the spot every time and wrote one line to a log nobody reads. The queue filed those posts as waiting on me, which is the same words it uses for a reminder I asked for, so no screen anywhere looked wrong. Both guards were right in isolation. Both were silent. The symptom they produced was a calendar that looked like my own bad planning, and that is the shape of failure I now go looking for first.
The windows those channels run through come back on their own after a restart, and I stopped taking that on trust. A small scheduled job reopens any that are down, at login and every ten minutes, and it now also reads a signed-in signal off each page, because a browser can be open, responsive and quietly signed out, which looks identical from the outside. Asking that question properly found a lane pointed at a browser profile nothing ever reopened, so it had never once worked. I proved the restart by killing a window outright and watching it come back signed in with no prompt.
A workshop in a single page that helps a founder and her team define a brand voice for a personal brand, a business, or a startup. Instead of a blank page, every round hands you drafted options to react to, keep, cut, or commit with a final pick, then rolls your choices into a clean voice summary you can copy or print. Built for a room: add your team, work down the rounds together, and comment as you go. Self-contained, private, and offline, on the Her Frontier brand.
Eight small tools that turn a philosophy into something you can use. A calm frontier-news feed that names who a change helps and who it leaves behind, a decision tool that runs a choice through logic and soul side by side, one that sorts your own voice from the shoulds you were handed, one that decodes why people love a thing so you can build your own honest version, an audit that finds the thing you are here to make, a map of who your work touches across time, a plan to grow ground you own instead of renting your whole presence, and a weekly loop that keeps you choosing growth over comfort. Each is a single private page that keeps your work on your own machine.
A paid build-on-request pipeline. You bring a problem, it moves from request to prototype to test to pay. A transparent three-tier deal and a buyout valve fix the usual extraction risk.
An AI marketing lab, sold as a multi-tenant SaaS where governance is the differentiator. Runs fully local on a Supabase and Docker stack with tenant isolation proven by test.
A B2B lead generator built on one rule: it never invents a lead. Every prospect comes from live map data, is graded against the local market's law with the legislation cited, and carries a source flag through to sending, so illustrative sample data is labelled, unsendable, and never dressed up as real. When coverage is thin it says so and shows the three it found, and when an area is too broad to search it hands you its cities instead of a silent zero. Ships white-label: licensed users get their own branded, isolated workspace with trials and one-click revocation.
Every account now accepts a licence before it reaches anything, enforced at the single point where the app works out who you are, so no route can be added around it. Third-party contact providers plug in as declared sources that can never claim a stronger lawful basis than their class allows, and each one reports why a call failed rather than returning a silent blank, because a rejected key and an empty result should never look the same.
A B2B lead engine where following the law is the product. It sources real prospects from official company registers, verifies their emails, grades each against the local market's law with the legislation cited, and drafts outreach across ten countries. It also ships the artifact the rest of the market does not sell: a compliance evidence pack listing every recipient's lawful basis, ready to hand to a lawyer.
Named decision-makers come from the statutory register itself, the same place the state publishes so the public can know who runs a company, rather than from scraping people off social platforms. The register decides who is worth reaching, and a licensed provider is asked only to resolve that one person's work address. The engine has no way to scrape a person: the refusal is built into the type system as a closed list of permitted sources, so it cannot be switched off by a setting.
Every lead carries the data licences it owes, on screen and in the export, because crediting the source is a condition of using the data commercially rather than a footnote. Each record also states where its contact name came from, so a buyer can see what the name is worth before they use it.
Its privacy policy is written from the code rather than a template, naming every source, the places data is deliberately never taken from, and the fields discarded on the way in. It sits outside the login, because the person most likely to need it was contacted by a customer and will never have an account.
A cycle-aware support app for women with ADHD. An opt-in, on-device cycle phase tailors the day's targets and tone, and live tips come from a local AI model so nothing sensitive leaves the machine. Her Frontier branded, installable as a PWA, and folded into the main site.
My own clean-room package scanner. Type the name of something you are about to install and get a Clear, Caution or Stop with the reasons explained simply. It weighs reputation, install scripts, risky code patterns, version-specific vulnerabilities and typosquats, with an optional VirusTotal layer.
Text copied out of an AI chat window carries characters that have no width and no shape, and they survive the paste into a newsletter or a proposal where nobody can see them. Paste into this and they show up marked in gold, then go. It runs inside the browser, uploads nothing, and works offline.
The value sits in what it refuses to flag. Three exemptions came from measuring across nearly seven thousand real files rather than guessing: the glue holding an emoji together, an encoding mark at the start of a file, and the characters icon fonts rely on, which alone were more than half of every false alarm. A checker that cries wolf is one you stop reading.
It also names its own edges. It strips the metadata from an image and leaves the picture identical, and it says plainly that it cannot touch a stamped-on logo or a watermark hidden in the pixels. It has no mode that rewrites your prose to break a statistical watermark, and it never will, because your voice is your word choice. It also knows that the same invisible joiners are spelling in Persian, Arabic and Hindi, and leaves them alone, because a cleaner that misspells someone's language is not clean. Fifty four tests run on every change across Linux, Mac and Windows. Pointing it at my own files found four images live on my own site carrying the full prompts that made them.
A guided experience where each door is a self-contained session of focused inner work. Doors are data, so one template renders any of them, build once and stamp many. A hall of eleven life clusters opens onto the first deep doors, the entry layer of a larger Deepening.
Self-paced courses running on my course engine. Build your own AI team of custom skills. Use AI to clean and decide on your own data. A paid setup kit with a build-along. And a 30-day crypto expedition that takes a complete beginner to a tested paper-only method, with a worked example every day. Each one comes with an AI coach and a workbook you keep. The expedition builds its workbook from the eight things you make along the way.
Three single-purpose AI tools: a Brand Voice Machine, an Offer Architect, and an AI Tool Navigator. Shared zero-dependency Node base, the brand system, model auto-detection and a keyless demo mode. The Navigator now runs on a local model first, keeps a curated 37-tool knowledge base it answers strictly from so it cannot invent tools, and lets you save your own shortlist in the browser.
One private assistant with five task modes: documents, email, writing, study, and interview prep. It reads a PDF or image you drop in, keeps a history you can copy from, and runs entirely on your own machine through a local model, so nothing you paste ever leaves the Mac.
A living fluid desktop with eight physics moods and seven palettes, a liquid you can touch that answers back. Packaged three ways: a live wallpaper kit, a phone app, and native iOS and Android builds with a full store kit. Apple approved the iOS build on 9 September 2026 and it is on the App Store, with the app, both founding subscriptions and the lifetime unlock all accepted. The listing, the pricing across a hundred and seventy five countries, the sixteen store screenshots and the submission itself were all run from a terminal rather than a set of buttons, including the step the interface hides: a version staged for review locks its own artwork, so the version comes out of the queue, the pictures go in, and it goes back, checked identical either side. The site is now the shop front, with the free version playable in the browser at a click, and a job that watches Apple every quarter hour and turns the whole site over to the App Store link the moment approval lands, because approval arrives with no warning. It did exactly that on the morning of the ninth, with no hand on it.
My bookmark and tab manager, and it runs entirely on my own machine. A local model reads every tab I leave open, writes it a one line note, files it under my own projects, and only then marks it safe to close, so nothing is ever deleted out from under me. It has quietly organised over four hundred pages across four browser logins, with a hard firewall so work pages can never cross into personal ones. A member version is built and waiting on the Chrome Web Store.
The front door for the personality product, live at aavattype.com. Its centrepiece is the Living Signature drawing itself in the browser: thirty kilobytes of vector, every stroke measured and animated so the mark is drawn live rather than played back, on one flat cream ground with no panel or frame around it. The typeface is served from the site itself, so the page makes no third-party request at all and the promise on its own privacy page stays true. The legal pages are generated from a single canonical source rather than kept in step by hand, because the one line nobody had made canonical was the one line that had drifted. Two gates now stand between the work and the internet: one refuses to deploy if the disclaimer is stale, if anything private is sitting in the upload directory, or if a page reaches for another host, and a second checks the same promise against the live site afterwards, using the browser header that makes edge-injected scripts visible. The signup now records what each person actually agreed to: both tick values, the moment of consent in UTC, and the dated version of every legal document that was on the screen at the time, because a lawful basis nobody wrote down is a lawful basis nobody can show. A welcome email follows automatically, built from the page copy itself so the two cannot drift, and the whole path from form to inbox is proven by reading the delivery log rather than trusting the send.
A native iPhone app that turns a thirty-question personality quiz into a living mark: a hairline emblem rendered in real time with GPU shaders and sixteen thousand particles, breathing, answering touch and tilting with the light. Version two adds serverless compare codes that render two people's marks in one field, scenario simulators, a daily pulse that sets how the mark carries the day, deep lenses that grow new parts on the emblem, and a signature tone synthesized from the scores. Scanning a share card opens a live edge page that draws the sender's mark in the browser with no backend and no tracking. Everything on device, no data collected; App Store submission pending.
Personality science, made personal, in two stages: a free thirty-question quiz that draws your living signature and maps your shape, then a paid reading that fills in what sits underneath it, all twenty-four facets plus four lenses each grounded in a different research tradition. Built as a full site rather than a funnel, on its own design system: one typeface at two weights, a fluid type scale so authority comes from scale and air rather than boldness, hairline rules taken from the mark itself, and a paid door that argues with a counted number rather than a feature list, six of your forty-one measured dimensions. There is only ever one finished product and a single rule decides what is covered for whom, so the free version is the real thing with the numbers covered rather than a thinner second build. Accounts run on an email code with no passwords, answers follow you across devices, and the whole checkout sits finished behind one switch. The interface then reads the pattern it measured and tunes its own words, order and pacing to the person, and every single change is disclosed in place: a panel names the signal that fired it, gives the reasoning, and prints the default wording beside the adapted one, with a switch that restores it. The reading itself is built as an observatory: the mark holds its own half of a wide screen and brightens the part of your constellation that matches the paragraph you are reading, with a chapter rail showing where you are in the whole arc. The 194 questions are chosen rather than inherited: every HEXACO item earns its place by measuring what the four lenses cannot, the selection lives as data with a written reason per item, and an independent grader runs a 26-check list the builder is not allowed to edit. Candidate versions of the quiz are tested as subsets of one sitting, so a reviewer answers once and every version is scored from the same answers, with the contested questions marked on screen as they are answered. The paid report organises everything by the areas a reader actually lives in, work, close relationships, caring, friendship, money, rest and what comes next, and prints under each one the exact measures it was read from, so every sentence can be traced back to an answer.
The living signature turned into a journey you fall into rather than a mark you glance at. It opens as one point of light and unfolds slowly into the six forces of your personality, each part emerging from the one it belongs to, then the four deeper lenses arrive as looping four-dimensional threads that leave you and return. Touch any point and you drop inside it, into that part of yourself as its own dimension, its finer parts circling out to fall into next, down to a single quiet score held in the light. One file, hand-drawn canvas, generative sound, no dependencies and no network, every element true to a real measured score.
A token-dense prompt notation of my own, with a sigil grammar, a shared module registry and a linter. It ships with a browser playground that counts tokens exactly, offline, with no key and no signup, using a BPE tokenizer I vendored and proved against the reference implementation across 788 comparisons.
Every compression figure is measured rather than estimated, on a benchmark where all six encodings are generated from one shared requirement list so no version can quietly drop a rule. The eval found a real hole in my own specification, and the numbers that came back worse than my earlier claims are published alongside the ones that came back well.
It is now a free tool on my own site, opened by an email, embedded so it feels native rather than bolted on. The hosted build fetches its tokenizer data on demand instead of shipping two megabytes to a phone, and a guard fails the build if the offline version's claim about making no network calls survives into the hosted one.
A privacy-first meeting tool with two modes chosen at session start. Meeting Notes mode captures live audio through BlackHole and Whisper, extracts only the work items (decisions, actions, blockers, owners), and deletes the audio immediately. No transcript is stored. Full Transcript mode keeps the verbatim record and generates a Zoom-style AI summary at session end: key topics, decisions made, action items, next steps. Both run entirely on the Mac. A local-model option handles sensitive sessions so nothing leaves the machine. Cards land in Mission Control before the meeting ends.
Short films, brand launch trailers and social reels made entirely in code, with no footage, no stock and no generated imagery. Every frame is drawn by a seeded algorithm, every score is synthesised by pure maths in a script, and the narration comes from a voice clone that never leaves the machine. The pipeline measures the real narration and writes the composition from it, so the picture can never drift from the voice. Twenty four films now exist across four complete series, and each series runs on a different engine: particle fields, then real simulations, then a simulated hand with velocity and pressure, then a counting engine where every quantity on screen is made of discrete marks you could count. Four verification gates sit in front of every render, because automated checks will happily pass a film that is wrong. A contact sheet reviewed by eye. A read-back that transcribes every generated line with a second independent model and diffs it against the script. A seek-order hash, because a renderer seeks through a timeline instead of playing it. And a numeric gate, added when the read-back turned out to be collapsing every figure to a wildcard, meaning it had never once verified a number in any film. The films argue from checkable fact and each performs its own mechanism rather than illustrating it: a conformity model calibrated against all three of a published experiment’s rates at once, a pedigree collapse computed rather than drawn, a market experiment rerun until a different song wins, an expansion where the same law is recomputed from a second galaxy and comes out identical. The gates keep catching the work rather than blessing it. A full sweep of all twenty four films found two narration segments that had been silently replaced with audio from an entirely different project, one of them already rendered. A closing score claimed a running total kept returning to zero when measurement showed it never crossed zero once. A search was solving before any searching happened. Each was rebuilt rather than argued away. The vertical cuts are made by the same discipline: a phone reformat halves the size of any on-screen type, so the caption band is taken off the picture and redrawn for the new frame, reading the words and their times out of the finished film itself rather than a script folder, which means a derivative cannot say anything the master did not. The channel art is drawn the same way, a seeded field coloured by sampling the real accent of all twenty four films, so the front of the work is made of the same material as the work. Engineered, not filmed.
A live command board that lets a small team run a whole venture from one shared screen. Five boards move every card through its own lifecycle with drag-and-drop on desktop and phone, alongside a prompt library, a brainstorm wall, attachments and a full activity trail, all syncing between people in real time with row-level security. It installs as a phone app and sends its own self-hosted web push alerts with no third-party service.
Two autonomous trading engines run as a disciplined lab. A crypto bot paper-trades Australian spot markets with a hard rule that nothing touches real money until the strategy clears its return gate, and a sports-exchange bot runs under the same paper-first covenant. Daily scheduled runs, automated backups, an operator manual and a CLI.
There is a category of app that sells women the ending. You describe the life you want, it describes it back in detail until your mind half believes you already have it, and one of them is doing well over three hundred thousand dollars a month. What kept pulling at me is that the research runs the other way. Vivid fantasy about a goal, on its own, predicts less of the thing, less weight lost, slower recovery, a lower salary asked for, and it has been measured across four samples since 2002. One of that app's own paying subscribers had worked it out unaided and written it in a review, that it keeps describing the goal instead of the person you would have to become.
So I built the other thing. You say who you are becoming, you say what is in the way, and then each day you keep one line of evidence that you moved. After a month you have a record of what you did, and the app reads it back using nothing except your own words. Everything you write stays in your own browser, there is no account and no server holding any of it, and the export is free whether you ever pay or not, because the loudest complaint across every product in this category is a woman locked out of her own writing.
The mechanic the whole thing turns on came out of the abandonment reviews rather than out of me. One tap on how much today has taken, and the worse the day, the less it asks and the more it counts. On the hardest day it asks for nothing and one line counts for three. It is the exact inverse of a streak, and every woman I read who left one of these apps left because a bad day had been turned into a fault. There is no run to break anywhere in it.
The part I would keep is that the tests found five faults my eye had passed over, and every one was in the writing rather than the code. The gate that checks what the model produces was counting straight quotation marks only, so it was throwing away good work for not using her words when the words were sitting right there in curly ones. A sentence built from what she typed came out as "you sends the work", because I had removed the pronoun and never conjugated the verb. And in a browser with site data blocked, one line reading storage took the entire app down before it drew anything. Everything a model writes now passes a gate before she sees it, and if it invents a detail, flatters her, promises an outcome or reaches for the wordbank, it is thrown away and she never knows it existed.
A sleep and ASMR sound studio that contains no sounds. Rain, thunder, surf, a fireplace, wind, crickets, a singing bowl, a low drone, a heartbeat, tapping and brushing are all built out of noise and oscillators at the moment you ask for them, so the whole thing is one file with nothing to download, no audio library, no account and no connection. Twelve layers you mix yourself, eight presets, a sleep timer that fades out across its final minute, and a 4-7-8 breathing guide that runs on the same orb the sound plays through.
Proving it works was the interesting half, because "did that make a sound" is not something an ordinary test can see. Eight layers were rendered offline and measured for real signal, and the four that only fire on random timers, the thunder, the bowl, the crickets and the brush strokes, were run in a live browser for nine seconds each with a meter on the output. That check found the two faults worth keeping. Pausing left every generator running behind a silent fader, burning battery on a phone by someone's bed, and the fix for that then raced a fast un-pause and tore down the layers a second after they had been rebuilt, so the app came back from a pause completely silent.
A visual site editor I own, so a website I build for someone does not have to come back to me every time a price changes. You open the real page, click the words, change them, and press save. It is the same drag-and-move feel as the paid tools, on my own stack, and each person I hand it to gets their own copy carrying their colours, their fonts and their licence rather than mine.
The piece nobody else does properly is the way a site gets in. Most importers pull the words and leave the design behind, so I wrote one that goes and fetches the stylesheets the page links to, embeds the fonts as data so they survive being lifted off their own domain, and switches back on the parts of a page that are invisible until a script reveals them. A five page site came in whole, forty odd editable blocks, looking like itself.
The lesson was the guard. I built a publish button, wrote a confirmation dialog for it, and never once asked who was allowed to press it. An independent audit by a different model found it in the first pass: any contributor could have replaced a live public website with one click, because the check existed in my head and in neither the interface nor the database. It is owner-only in both places now. Then the fix caught the owner himself, since my setup script had made me the owner of his own site, so he owned it by the time anyone touched it.
An installable web app built for an AI persona's dog-loving audience, and the screen is her beach. Real photographed scenes track the actual clock from dawn blush to a starred night, a golden retriever waits at the shoreline until the day's walk is marked, and one minute a day with your dog is the whole ask. Each walked day washes a photographed beach find onto the sand carrying that day's lesson, thirty days through reading a dog's body, how attention rests, and the persona saying what she is, with the collection kept on a shelf that reopens any lesson.
Seven of the finds hold her voice: short recorded pieces generated with a locked local voice clone, framed as putting a shell to your ear, including one for the hard day and one for two in the morning. A sit-a-while mode dissolves the interface entirely and leaves the beach holding the room. Built, rejected twice for being too plain, rebuilt to this, and canary-verified end to end before anyone was told it existed. No accounts, no streak shaming, and the count never goes down.
Her own blockchain, running on one machine, answering to nobody else. Where most minting stores a link to a server that will someday die, this stores the whole thing: all thirty muplu games live inside chain state as complete playable files, each sealed by an integrity proof the chain itself recomputes, so a sealed token is a mathematically intact game. The library page pulls the bytes back out and runs them, and the largest game at nearly two megabytes was proven to survive the node being killed and restarted. Three adversarial review rounds caught a storage flaw that would have sealed games it could never reopen, before a single one was made permanent.
Say it now, prove it later. Seal a prediction for five dollars and get a permanent page that proves what you said and exactly when, hidden until a reveal date you choose, then unlocked and verified in front of the reader. Salted SHA-256 commitments anchored into Bitcoin through OpenTimestamps, so every seal stays checkable by anyone without trusting the site. Invented, kill-tested against the whole market, built and payment-wired in a single day by an AI run, then hardened through three adversarial verification rounds that included crashing the server mid-payment to prove no buyer can ever lose a seal.
A full research membership platform for my dad, whose options recommendation business used to cost him ten hours of work a week and now takes about fifteen minutes. He makes the market calls; the platform does the grounded AI research, the member alerts, a weekly note that assembles itself from his published trades, and a public track record carrying every win and every loss since 2020, with the losing trades kept where a reader can find them. His desk also reads the live option chain for any ticker now, so before he writes a trade he can see what it costs to hold, how wide the spread is and how far the stock has to move, and the contracts too thin to trade are greyed out with the reason. It is deployed and running end to end on its own domain.
The most recent pass was the kind of work nobody sees until it is missing. Every page on the site was being rebuilt from scratch for each visitor, including pages that read no database at all, and the whole cause was a single session lookup in the file that renders "page not found", which in this framework sits inside every page's render tree. Nothing warned; the build printed a one-character difference and carried on. The public pages are now built once and served from the edge, and the busiest of them answers in a tenth of a second where it used to take nearly three. A second fault in the same pass had been reported for weeks as a rendering error on the home page and was neither on the home page nor where anyone had looked: the published research reports are hand-edited, and a table written without the element a browser silently inserts made the server's page and the browser's disagree, so the browser threw the report away and rebuilt it. It is repaired before the page is sent now. Each fix left an instrument behind that fails the deploy rather than a note in a document, including one that reads the search snippet of every page on the live site, which is how 111 of 136 descriptions turned out to be too long to display in full.
The research for this one turned my brief on its head. I went in wanting a faster alert engine, and 7,845 app reviews said the loss almost never came from not knowing. It came after the alert: a forgotten expiry, a stop nobody was watching, a fill worse than the published entry with a target never recomputed for it. The number one complaint, by a wide margin, was an alert that never reached a locked phone.
So the app is a delivery rail first and a rule engine second. A publisher's members get each call on their phone within seconds, with a receipt per device and the measured time it took, their own entry, stop and target watched against the tracked marks, quiet hours in their own timezone, and a private record of what their own plan did beside the published result. Every string passes a test that bans instructions, because a financial publisher reports facts and never tells anyone to sell. A QR code on the desktop signs the phone in without a password.
The newest piece is the part between the call and the trade. A member can have the contract right and still lose money typing it into their broker: strike 33 for 330, the wrong week's expiry, a put where a call was meant. Every automated bridge into a broker either needs a partnership nobody grants a small publisher or crosses the line into placing the order for them. So it stops at the clipboard and spends the effort on the check instead. One tap copies the contract with every component spelled out, and beside it the underlying, the expiry with its weekday, the strike and the call or put sit in type big enough to read at arm's length, one line at a time, each ticked off against the member's own broker screen. It covers fourteen brokers, needs no token and no partnership, and nothing is ever sent to anybody's broker.
A tester told me it felt like spam, and her inbox showed why: thirteen separate emails inside one minute, twelve of them the same weekly reminder against twelve different contracts. The app had ten on and off switches for which kinds of alert she wanted and no answer at all to how many. It has one dial now, everything, a sensible number a day, or only what matters, and one run of the engine is one message however many true things it found. The publisher's own calls and a member's own stop being traded are never folded away or held back by the count, and nothing is ever dropped: whatever the limit holds waits on their alerts page and is counted in the summary after the close. She also asked whether she could just get emails instead of notifications, and the honest answer was "sort of, in two places, and neither of them says so", so that is one question now too: on my devices, by email, or both, asked once and obeyed everywhere. Underneath both was a naming problem: the app was called Alerts, and so is the thing the publisher writes, so "your alerts" meant two different things and a reader could not tell which one was pestering her. It has its own name now, its own word for what it sends, and a test that fails the build if the old one creeps back. It moved address to match, with the old one permanently redirected, because that address sits inside every message the app has already sent and inside the shortcut on every phone that installed it. All of it is live. Two bugs on a real phone turned out to be the same mistake twice: a control offered on a device that cannot honour it. A keep-a-small-window-on-top button opened a full screen page titled about:blank, and an install flow sitting behind a login wall handed the phone the login page, so what got saved to the Home Screen was the website. Neither was broken code. Both buttons were simply in the wrong place.
Built and deployed in one day, gated to three testers on the live site, on a running cost of nothing beyond the plans already paid for. The market data licensing turned out to cost forty times the infrastructure, so the design uses what the site already captured and the broker the member already pays for. What I take from it: read the complaints before you read the feature lists, and build the receipt before the rule.
A founder story app for a friend's Bali eco-resort: a voice journal for the founder, a story tab, a guest tapestry that grows with every stay, and QR access. Installs as a phone app.
It now carries the sales side too. A buyer arriving from an agent's link is recorded as theirs before they read a word, by the system rather than by anyone's memory, and neither side can change it afterwards. What that buyer sees is a proper page for the homes, ninety photographs of the place sorted by what they show. Behind it, two keys instead of one: a contributor word that opens the pages and the media, and the founder's word, the only one that opens the record of who introduced whom and what it was worth.
His team can now edit the website themselves, in their own copy of my Studio, and only he can put a change live. Separately, the app grew named logins: each person types one readable word instead of everyone sharing a password, the record of who introduced whom stays behind his key alone, and ten wrong guesses shut that door for ten minutes.
A boutique performance agency for my daughter: brand system, live marketing site and an automated enquiry pipeline. An enquiry files itself into the right category, replies to the person who sent it, and lands in the contact list ready to be followed up. It now runs behind a spam filter built on a rule I would defend anywhere: it is never allowed to delete, only to withhold. Junk stops at the two doors that cost something, the contact list and the automatic reply to an address that may not exist, while the notification always comes through flagged. So the worst a mistake can do is make her add someone by hand, never lose a booking she never knew arrived. The whole stack runs on the business's own accounts under its own domain, built to be handed over whole.
A local, offline tool that turns a phone photo of hand-drawn or painted art into a clean, transparent, print-ready file for products. It removes the paper the way the usual background removers cannot: it floods in from the edges of the sheet and stops at the drawn lines, so the white parts of the art survive even when they are the exact same white as the paper. Straighten, remove, brush-fix, and export a transparent PNG, all in the browser with nothing leaving the Mac.
A personality-quiz product ecosystem fronted by AI avatars: quiz to PDF reports to subscription to a book, built on a Big Five and archetype engine.
An AI crypto research-brief tool, my first public proof-of-build release. A five-category research prompt with a scout mode that finds tokens with active catalysts, generating structured HTML briefs.
A tool I had built for one person needed to hold a team, and one shared password fails three ways at once: nobody knows who changed what, nobody can be removed without changing everyone, and whoever learns the owner's word owns the lot, including the records that should never have been in reach.
Rather than bolt on a whole sign-in system, each person now has their own word, stored only as a hash, switched off with a flag, and every action they take is signed with their name. An evening instead of a fortnight. The trap worth knowing: turning an instant permission check into a database lookup makes it asynchronous, and a caller that forgets to wait receives a promise, which counts as true, so a missed wait does not lock the door, it opens it.
Proved against the live site rather than a local copy. I added a throwaway person, confirmed they could moderate, confirmed every private surface refused them, switched them off, watched the door shut, and deleted them.
Then I put a speed limit in front of it, and nearly shipped a protection that did nothing at all. It logged not one attempt, because the write was fired and left to finish on its own, which is normal practice everywhere except the hosting this runs on, where the machine stops the instant the reply goes out. Twelve wrong guesses, zero records. Now it is awaited, and I proved it by attacking it: wrong answers until the limit, then the correct one, refused.
A team needed to edit a live site themselves, the design and the layout and the words, without me sitting in the middle of every change. So the editor takes a real site by its address and opens it as something you click into and type, with a copy each, changes promoted one section at a time to a shared master, and whoever owns the site holding the publish gate.
Importing is the part that quietly defeats every tool like this. A modern site keeps its stylesheet in a separate file, its fonts need a permission header almost nobody sends, and half the page sits invisible until a script adds a class, and that script is the first thing an importer strips. So the design arrives bare and the team decide the tool is broken. Three fetches and one override read from the site's own rules, and it comes home whole.
Then a second group wanted their own, and that is where a build tells you what it has been hiding. The colour seeding looked up its defaults by the first group's name, so a fresh copy would have opened every design with no palette at all, and one database column had been added by hand months earlier and never written into a migration, so the code could not rebuild its own database. Both fixed, and the second instance now runs on its own database with its own colours, from the files alone. One codebase, configured per group, because a fork means every fix made twice and one copy quietly rotting.
Both copies now carry my name where someone using it can see it, next to a licence page that says the plain version out loud: the tool is mine, everything they make in it is theirs. That took finding the four screens still wearing the first group's name, including the password reset and the identifier the importer was sending to the new group's own server.
It publishes as a site rather than a pile of pages: every page goes out in one version and the links between them are rewritten to point at each other instead of back at the original. Proven on a five page site. The last thing I changed was the emphasis, because the filled green button was the one that goes public and the everyday Save was a dark button on a dark bar, which is the wrong way round in a tool you hand to somebody else's team.
I checked it at phone width before anyone saw it, which is how most people meet a tool for the first time. The toolbar grew to a fifth of the screen and the page scrolled sideways, so rather than pretend, it now says warmly that it wants a wider screen and offers a way through for anyone who insists.
Then contributors were coming, and the gate that mattered turned out to sit one step earlier than the one I had built. Publishing was locked to whoever owns the site, but the shared master copy that publishing puts live was open to every member, so a contributor could change what the next publish would carry. I closed it in the database rather than in the buttons, because a rule the interface keeps is a rule anyone patient can walk around.
Then I tested that gate the only way it can be tested, by making a throwaway account at each level and having each one try every move. It showed what reading the code could never show: nobody could write the master copy at all, the owner included, and had not been able to since the publish gate went in three days earlier. One column is empty by design on that row, so the comparison returned neither true nor false, and the guard beneath it read that silence as you are not a member here. The refuse case is the one everybody tests. The allow case is the one that quietly breaks.
Then she pressed the round arrow expecting undo, and nothing came back. It was doing exactly what it said, resetting her own copy to the shared one, and she had just approved her work into the shared one, so it returned her to the version she was trying to leave. When somebody misreads a control, the control is wrong, and the fix is nearly always the missing thing they assumed was there. Approving now saves the page as it stood first, and stepping back saves where you are before it moves, so the undo is itself undoable and nobody is ever one press from losing the newer version instead.
A starter that abstracts the AI-research-plus-formatted-output pattern into a checklist-driven template, so a new client tool can be stood up fast from a proven base.
The repeatable methods connecting the work: how I turn an idea into a product, a recording into a film, or a live system into something I can verify.
Small things I use every day that most people never find out they can have. One folder per tip, a short read and the lines to paste, written for people who do not code. Five tips public so far: a four letter word that starts an AI coding session, giving one teammate access to an app that never leaves your machine, a development page that returns success and is quietly dead, a tool that switches your own automation off without telling you, and a nightly check that counts from the last time you published rather than from last night.
The last of those went through two rounds of review by readers who had not seen it built. The worst fault they found had been introduced by the fix for an earlier one: the output folder had taken a name that a common blog builder reserves, so anyone running it on a blog would have had their draft posts silently vanish from version control. Caught before it went out, and it is the whole argument for reviewing the fix as well as the build.
Every tip goes through the same gates before it goes out: a prose linter, a secret scan across the full history, a sweep for anything private, and a run on the oldest shell a Mac still ships. Publishing stays a decision I make by hand.
A short film series that renders end to end on my own laptop, picture and audio together, for nothing. The model denoises the sound and the image from the same latent, so the audio cannot drift out of sync with what the hands are doing, and nobody has to stand in a room recording keys into a dish. One command, about six minutes, and a finished eight second film comes out mastered so the quiet survives what the platforms do to it.
Two things made it work and neither was the model. The tool I had been driving generates sound and simply does not hand it back, so the capability looked missing when it was only hidden behind an app's API; the fix was to drive the model's own pipeline instead. Then the last step of that pipeline died on Apple Silicon after the whole video had already been made, because it relied on a precision trick that only exists on Nvidia hardware. Both were found by reading the source rather than trusting a README.
The gate I am proudest of is the one that caught me. It refuses to pass a film whose audio is silence, and its first version failed a film that was perfectly fine, because it read the wrong output stream and saw nothing. A check that cannot tell empty from absent is worse than no check, so it now decodes the audio and counts the samples.
I had years of images sitting on a stock marketplace and no idea which ones worked. The check took ten minutes and I had been avoiding it, because sorting your own work by sales rather than by date means reading a list where the things you were proudest of sit at the bottom.
Nine percent of the catalogue carried sixty three percent of the downloads. The largest cluster of uploads, the one that chased the loudest trend of that year and took the most effort, had never sold once. Everything seasonal had a single download between all of it. The quiet theme I had almost stopped making was the whole business.
So I stopped generating ideas and built the machine instead. The winning work gets pulled apart into a grammar of a few axes and a local image model renders a slate every morning at full marketplace resolution, with no upscaling, because my one rejection on quality was an upscale. Composition is treated as a commercial decision rather than a creative one, so empty space is a feature a buyer pays for. Each file carries its own title and keywords written for what a buyer searches, and a perceptual hash throws away anything too close to what I already made.
The first version of it was wrong, and that is the part worth keeping. It had been built from the written descriptions of my best sellers rather than the images, so it got the subject right and the craft completely wrong, and everything it made was competent and useless. A description names what is in a picture. It says nothing about how the picture is made, and how it is made is the thing being bought. Opening the actual files took ten seconds and showed seven shared properties that no title mentioned, starting with the one that mattered most: every winner is dark, and everything I had generated was light.
The tool was making the decision too. A fast distilled image model has a house style, and no prompt moves it off that style, so the tool had been chosen before the look was and the look lost. Both faults are now a gate: a style cannot render unless the reference images it claims to come from are sitting on disk. Their being there is not proof I looked, but their absence is proof I could not have.
Someone using a report generator I maintain told me the tool was fine and the collecting was the problem. About twenty reference sites per report, and a switch back to the text box after every one. The obvious answer was already built and had already failed to land. Having the AI fetch the sources itself cannot work here, because the best ones sit behind logins and paywalls, and a server fetching a page is not a person reading one.
So the destination moved instead of the research. A browser extension collects whatever is highlighted, on any site, with the site name, page title and link attached, and counts up on the toolbar so there is nothing to come back and confirm. One button at the end fills in the identifier on the matching card and drops every clip into the right box with its source line above it. It runs with no account, no server and no network call anywhere in it, so nothing about what someone reads leaves their own machine.
The first version pasted everything every time, so pressing the button twice doubled the research, and a person who presses a button twice is checking it worked rather than making a mistake. It stamps what has gone across and sends only the difference. The write itself needed proving rather than eyeballing, because setting a value in a page updates what you can see while the app's own state never hears about it. The honest check was to read the app's own character counter afterwards and watch it move.
A post I schedule once now reaches a second platform on its own. A rule on my publishing desk adds the second target as the post is scheduled, and picks which board it lands on by matching the words in the post against the brand's own content pillars. I backfilled a month of published posts through the same route, each one routed to the pillar it belongs to.
The platform's API cannot create a post at all on trial access, so this drives the real website through a browser signed in as that brand alone: its own window, its own profile, its own port, its own stop switch. Before anything is composed it asks the site which account it is holding and refuses if the answer is not the one the desk expects. That guard exists because a poster that serves two brands is one mistake away from posting as the wrong one.
Getting it live took two failures worth keeping. The first attempt filled in everything correctly and then found no publish button, because on an account holding drafts the platform moves that button into a drafts sidebar as a bulk action. My first fix closed that sidebar, which removed the only button on the page. The version that works ticks exactly one draft, the one it just made, and refuses rather than guessing when it cannot tell which is its own.
My check on which browser windows are still signed in was crying wolf, calling one window signed out while it was posting through it. I found the cause, wrote the fix, and every window went green. Then I pointed the same check at a deliberately signed-out browser and it called that healthy too. The fix had not corrected the alarm, it had disabled it, and a good fix and a dead one look identical: everything fine.
The working version reads positive evidence only, asks every tab in a window rather than whichever answers first, and opens a fresh tab before calling anything out, since a tab left open for hours still renders the old state. It is proven in both directions now, against the real windows and against a browser with no session at all.
Separately, my always-on jobs are watched for a stall. Each one writes when it will next look, so the watchdog reads that promise instead of keeping its own idea of the schedule. I proved it by freezing a live job: alive, not crashed, silent for nine hours against a three hour promise. It caught it, restarted it, and it refuses to override the off switch I use to stop a lane on purpose.
My publishing job woke every ten minutes to ask whether anything needed posting, on an account I post to a few times a week. The obvious fix is a longer gap and it is wrong, because those posts are scheduled to a time, so a three hour gap publishes an hour late.
It sleeps to the moment now. The queue already knows when the next post is due and asking it costs nothing, so the scheduler reads that and wakes shortly before, jittered. Fewer wakeups and better punctuality at the same time: the old ten minute clock could already be nine minutes late. The poster itself I did not touch, because it carries four safety gates and a composer full of traps, and I was not risking those to change a schedule.
The first version counted undated drafts as due, disagreed with the poster about what work is, and planned to wake every minute for ever. I found that before it went in. Jobs that only talk to my own machine got a longer number instead, since jitter buys nothing when nobody is watching for a pattern.
Someone commented a single number under one of my videos. It was a correction of a figure the video states. My drafting engine wrote back a warm line about the morning, then a line reading the number as a distance, and both looked like the model being stupid. It was not. Three separate things were wrong and any one of them alone would have produced a bad answer.
The engine was handed the caption and nothing else, so on a video post it was answering something it had never seen. A bare number scored as almost nothing on my substance measure, which routes low-content comments to a deliberately tiny reply, so the comment type most likely to be a correction went to the branch built for people who said nothing. And the context budget predated video: it was literally shorter than the post, so anything I added was cut off before the model read it. None of the three errored.
Videos carry their own transcript now, made on this machine, and it travels with the post ahead of the caption. A figure in a comment counts as substance. And the instruction is not to agree: the commenter's number was above every figure my own fact check had accepted, so the persona thanks them, answers the subject, asserts no competing number, and the item comes to me. A synthetic character confidently correcting a real person is not a thing I want built.
My publishing desk had posted to one platform for months and had never held a single comment from it. Nothing was broken. The API I publish through has no comment read in it at all, so the sweep skipped that channel on every pass, correctly and silently, and the gap looked exactly like quiet. Someone had replied to my AI influencer twenty minutes before I went looking, and the only place it existed was the phone.
It reads now, hourly, through a browser already signed in as that account. It never types, never posts, never touches the account. It lets the platform's own page make its own signed request and captures the JSON that comes back, so no text is read off the markup and a redesign will not break it. Each comment is matched to the post it belongs to through the stored video link, because the desk holds no platform id for anything posted from a phone. It checks which account the window is holding before it reads a word, and refuses on a mismatch.
It answers now, and the first one is live. A reply I approve queues for the same window to type. Matching a queued reply to the right row is the dangerous part, because the page never exposes a comment id and going by position is how a reply reaches the wrong person, so it matches on the commenter's name and on the words they actually wrote, both, and refuses on a mismatch, on an ambiguous match, and when the box reads back anything other than what I approved. I ran all four refusals against the live page before I let it near a send.
The send queue was shared with my direct-message worker, which drained it with no filter, so a reply meant for one platform could have been typed into a conversation on another. Every row is typed now and the old default is unchanged, so the worker that was always there keeps exactly what it had. The pacing came off my messaging lane: a long-running process rather than a job on a fixed clock, since a fixed clock cannot vary, cannot skip a look, and cannot sleep at night. Measured over four hundred simulated days it looks about eight times a day when quiet and about forty when a conversation is live.
An automated pass rewrote a hundred and ninety one passages of a product I build with two other people. Restoring it would have thrown away good work, and accepting it would have overwritten a collaborator's writing while two reviewers were mid-review on the old wording. So I measured the rewrite instead of arguing about it, and classified every passage by how much of it had actually moved.
A hundred and forty three were light edits, and what they mostly struck was filler: one word, sixty two times, then the next, fifty two. That was my own writing standard being applied, not new writing. Forty six were real rewrites. The review that looked like a hundred and ninety one judgement calls was forty six, and the rest went in one click. I built the team a page that puts the original beside the proposed version with the changed words marked in both, records an answer per person so nobody overwrites anybody, and exports what the team wants applied. It runs on its own store, so a vote there cannot touch the seventeen open decisions on the same tool.
A five film series cut from an essay of mine about a company buying millions of books, cutting the spines off and scanning them. All five are built and all five are published. The centre of it is one shot that argues rather than illustrates: a paragraph of real prose regenerates itself nine times and you watch the rare words go first, the ragged right edge straighten into a smooth grey block, and a live distribution curve underneath lose its tails, which is what the Nature paper on model collapse actually describes. Everything is drawn in code from type and geometry, because a film arguing that model output is contaminating the human record cannot be made of model output.
The narration is a clone of my own voice and getting there took three attempts and a finding worth keeping. The cloner truncates a reference clip to its first six seconds, so a sixty five second recording had only ever contributed its opening throat-clear, and no amount of parameter tuning was ever going to fix an input problem. Two harness bugs were caught the same way the film's own argument works, by looking rather than by trusting: the linter passed happily on a version where four English words in five had silently vanished from the page, and on a first frame that rendered black.
The series went out through my own publishing desk rather than by hand. It parses the titles, descriptions and tags straight out of the pack I had already written, uploads each file, sends it up, then asks the platform itself what it now holds instead of believing the success message it just got back. One trap was worth the whole check: the channel was connected but sitting in reminder mode, which quietly raises a note for me to post by hand rather than uploading anything, so a run that reported success would have sent nothing at all.
Six short films about reasoning when you cannot know. Two mathematicians in sixteen fifty four working out how to split a pot when the game stops early, and inventing expected value on the way. Fourteen thousand people given the same forty eight unknown songs in separate worlds, and a different song winning in each one. A search that rewards novelty with no goal at all, and covers more ground than the one aiming at the exit.
Every frame drawn in code, every score synthesised, all of it on my own machine. Each film opens with something you can go and check and ends somewhere I actually believe.
Six short films about people and what we make. Ochre ground into pigment a quarter of a million years ago by people it fed and warmed not at all. A child who can do with help what she cannot yet do alone. A room of strangers that changes what someone says they see. A press in Mainz around fourteen fifty, and the centuries that passed before most adults could read what came off it.
That last one is the whole channel in one film. The machine arrives long before the ability to use it does, and the gap is where people get hurt.
A way to post to Farcaster without handing anyone the credential that speaks for me. The official route is either a hosted service holding my signer or an onchain registration, so instead there is a browser I launch myself, holding one account, kept running. I approve the post in my own publishing desk, my AI types it into the composer, and it stops at the button for me.
The window is the on switch, which is the safety property rather than a limitation. Open means a post can go out, closed means it waits, and nothing is ever scheduled. It is the third of these windows on my machine, one per account, each with its own profile so no session can ever see another.
Six short films about order that turns up with nobody arranging it. A single rule repeated on an empty surface until structure appears, a protein that falls into its working shape rather than searching for it, one cell swallowing another a billion years ago and both surviving, a network designed with no centre, two sounds at full strength that add up to silence. Every frame drawn in code, every score synthesised, all of it on my own machine.
Publishing them turned up the lesson. I built a season structure for twenty four finished films that already had one, printed on their own end cards, and only found it by pulling a thumbnail. The work knew what it was the whole time and I had been reading everything except the work.
Six short films about the universe, made entirely from code, and all six are now published. They sat finished and invisible for two months, which is its own lesson about what stops work reaching anyone. No camera, no stock footage and no video model: every frame is drawn by code I wrote, every score is synthesised, and the narration is a synthetic voice built and run on my own machine. They ask what is actually happening, which is the question I put to everything I make.
Publishing them taught me more than making them. Every film was finished and current, and every file I would actually have uploaded was the previous cut, older than the film it came from, opening perfectly and playing at the right length. So the fix was not a tidy-up. The pipeline now compares each master against its share export against the page's own copy and refuses to hand over anything behind, and it verifies what it produces rather than trusting an exit code, because this series has already shipped a film that passed three validators while rendering almost black.
Reads what my two listening agents brought back over a week and turns it into a number I can act on, which turned out to mean building the thing that refuses to flatter me. Every automatic step in the obvious version overcounted. It searched by a theme's own words and then filtered the results by those same words, which narrowed forty-eight accounts to forty-eight and felt like rigour; a filter that cannot fail is not a filter. Tightening it then threw away a finding I had already confirmed by hand, so the gate came down and a ranking carries the confidence instead.
The line I would keep if I could keep only one: an empty result now prints as UNMEASURED rather than as no demand. The search returns a normal success code with nothing in it whenever a query runs long, so the first working version reported almost no demand for anything and looked perfectly healthy doing it. A thirty-seven character phrase came back with twenty-five results and the same idea written out as a sentence came back with none, and nothing anywhere said why. The page shows its own attrition at every step and ends in tick boxes, because the only step in the chain that counts as evidence is a person reading the sources.
Asks two questions of my own scheduler and then acts on the answers. Which channel is actually growing, measured from the platforms directly rather than from the one I check most often, and how much finished work is only going to one place. It found ninety-eight placements sitting unused: eighty-five posts already made, already written and already scheduled, all pointed at the weakest channel while a stronger one, on the same persona, got a fraction of the output. Video gained a short-form placement on every vertical surface it fits, stills gained a pin routed to the topic board its own caption belongs on, and nothing new was generated.
I diffed the whole queue against a backup taken before the run instead of trusting the tool's own success count, which is the only reason three real problems surfaced: captions over one platform's character limit, twenty-eight ephemeral stories being turned into permanent posts, and my own fix then stripping a setting from eleven posts that already had it. A bulk tool that reports its own results is marking its own homework, and one of those "failures" had in fact written its change anyway.
Reads every frame of a screen recording with machine vision before it leaves my machine, and refuses the send if any frame contains a name from a blocklist I write in advance: other brands, other handles, anyone under an agreement. It exists because I checked a video by eye twice, passed it twice, and it still carried another brand's account, a bot handle and a real name in a footer. The scan found twenty-two exposed frames in under a minute. Eyes check where they expect a problem, skip the two seconds where a page reloaded, and stop looking once a frame looks familiar, which is exactly when the thing at the bottom of it goes out the door. The finding that generalises past video: the worst exposure came from a page reloading, because a privacy filter you set in a tool lives in the browser and evaporates the moment an external sign-in sends you back.
It now ships inside the scheduling desk as well, so anyone running their own licensed copy gets the same gate before they send a demo video to a platform review. Their copy carries a blank blocklist and says so out loud until they fill it in, because the version that protects me contains a list of my brands and would have handed every one of them to a stranger.
Rebuilds a digital product's shop photos out of the product itself, so a buyer can see what they are paying for instead of reading about it. It renders the real pages from the finished PDFs, crops each one to the part actually worth reading rather than shrinking a whole sheet into a square where the type disappears, and sets them beside the real images the work produced, all in the same house style as the rest of the shop. The rule underneath it is the useful part: a grid of examples is a claim, not a display, so anything that cannot survive the caption above it comes out of the grid and the grid gets smaller. It caught a set of five products that all looked deliberate and showed nothing, including a pack for making AI images that contained no AI image. Nine new photos went live on each.
Turns a list of small ordinary actions into a finished library of silent eight second films, all of which look like they were shot by the same person on the same afternoon. One shared scaffold holds the frame, the light, the pace and the character canon, so each concept only has to describe its own action and sounds, and consistency stops depending on remembering it. Every clip is mastered to the same loudness so the set can run back to back in a feed without one jumping out, a review page builds itself from the same source, and the descriptions come out on a hand over surface that copies clean into a platform form. The hard lesson is in the canon: a generative model will quietly add a wedding ring and age a pair of hands by fifteen years, and naming an allowed version of a thing is what lets it back in, so the rule became forbid outright rather than permit narrowly. Twenty four films are live, and the character is disclosed as AI generated on the page itself.
Makes the satisfying build videos that flood short-form right now, the kind where a thing assembles piece by piece in silence, without prompting a video model at all. The whole genre fights the same problem, that a generative model cannot hold a scene steady, which is why every working prompt for it is half a list of forbidden failures: no morphing, no flickering, no melting hands. So this one cuts each piece once as a vector and stacks the pieces in code, which makes them the same pixels in every frame and puts continuity beyond the reach of luck. Depth comes from a single rule, that every layer drops a soft offset shadow on the one below with the light never changing direction. It needs no graphics card and no credits, a finished ten-second vertical video renders in under a minute, and the same source file renders identically forever. The sound is synthesised in plain maths and placed on the exact frame each piece touches down. A gate refuses any build whose metaphor cannot be defended as honest, so a beautiful picture that misrepresents how something really works never gets made.
Turns one living, generative brand mark into a whole content library in a single hands-off pass. Every trait and every variation, in a free and a full version, rendered at gallery resolution and as true vector, with transparent cut-outs, finished ready-to-post cards, story and reel backgrounds, and animated loops, all on both a light and a dark world. It writes its own contact sheet, brand guide and manifest alongside, so a content creator is handed a folder to work from instead of a design brief. Every mark is drawn from real measured scores, so nothing on it is decorative, and a human yes sits before anything ships.
Turns a full hour of evergreen ambient video, the kind you leave running on a TV for focus, sleep or a calm room, out of nothing but code. An original soundtrack composed in code and a soft generative visual render as one seamless short master, a real brand character is cut from a reference photo, seated into the light so it belongs there and given a soft breathing motion so it feels alive, then the master loops to a whole hour by copy alone, so sixty minutes costs the render of twenty seconds. Every layer is owned outright, so there is no stock footage and no music licence to answer to, and a human yes sits before anything publishes.
Every morning before I sit down, a scheduled agent reads the primary sources I trust across AI and the markets, curates them into a two-column brief of what actually changed, and adds one fresh idea I can act on that day. It writes straight into my command centre, and it forces its own flat-rate brain rather than a metered key so it never stalls on cost. Every refresh has to parse clean and pass my voice rules before it goes live, and a bad run keeps yesterday's good brief untouched instead of breaking it.
Runs a timed sale across a shopfront without any price being edited by hand, because the risk in a promotion is not starting it, it is ending it. Prices appear in about seventy places across a site, they get discounted one by one, and a month later some of them get changed back, so the shop quietly keeps advertising a discount that has finished. This holds the whole thing in one small config carrying whether it is running, the percentage and a real end date with a timezone, keeps the full prices as the only prices written into the site, and derives everything else at load. It stops on its end date on its own, so forgetting is designed out rather than remembered around, and an expired sale leaves the site exactly correct instead of wrong. Every stated saving moves with it, so a bundle advertising what it saves against buying separately has that number recalculated rather than overstating it once the parts are discounted too. Prices written into sentences are handled apart from prices in a price field, since a comparison needs both its numbers moved or it stops being true.
Keeps a live marketplace shop matching the copy I actually approved, instead of me pasting into two dozen listings by hand and missing half of them. It reads every listing straight from the platform, diffs it against the version-controlled source, and writes back only what differs, so a whole shop can be corrected in one pass and proved clean afterwards by re-reading it. The interesting part is the safety: item names repeat across ranges, so pairing a listing to its source by title alone quietly proposed rewriting one product range into another and shifted an entire series by one position. It now pairs on a key the platform itself already stores, records that pairing once in a small file, and refuses to guess, and it stages anything new as an unpublished draft because the fee falls on publishing rather than creating, which leaves every commercial decision with a human. It also handles the several shapes a real catalogue takes, the cheap item made in series, the premium one with its own photo set, the media one whose deliverable is audio, after a first version quietly skipped four products whose files simply sat somewhere else and reported success anyway. It now also replaces the deliverables and photographs under products that are already selling, which is a harder job than making them because a customer can arrive mid-repair. Marketplaces cap how many files a listing carries, so there is no room to add corrected versions before removing the old, and the swap runs one product at a time, checks every replacement off disk before deleting anything, stops the whole run on a single failed upload, and reads the result back rather than trusting that the calls returned. Two platform habits are now assumed rather than discovered: a successful delete can answer with an empty body, which reads as a crash after the delete has already worked, and a read on the wrong path can answer "nothing here" instead of erroring, which once convinced it a full listing was empty. So it proves its read can find something already known to be there before it deletes anything at all.
Produces the quiet, sound-led clips that hold attention longer than anything else in short-form, with the picture and the audio generated together in one pass so the sound belongs to the moment instead of being laid over the top. It is built as a data file rather than a folder of prompts: one scaffold holds everything that must never change, the framing, the light direction, the palette, the pace and the exclusions, and each piece is three lines naming its subject, its action and its exact sounds, so a whole catalogue can be re-pointed by editing one file. Every piece is framed below the wrists, which is the native look of the genre and takes the face out of the question entirely, though it taught me the harder half of the lesson: the parts you DO show need naming just as carefully, because a brief that says nothing about age lets the machine pick a different one every time. The finish is where the craft sits, because generated clips arrive at wildly different volumes and a batch that jumps around is the thing that reads as amateur, so the set is compressed, loudness matched and peak limited together. Twenty-four finished pieces came out of it in an evening, the review page rebuilds itself from the output folder so it can never claim something exists that does not, and the whole set is now live on its own page with a poster frame per film so the gallery looks alive before a single video downloads.
Turns a catalogue of eight second clips into hours of finished long-form audio without generating a single new thing, which matters most at exactly the moment credits run out and a channel would otherwise go quiet. The catch is that naive looping fails in a way a thirty second check cannot catch: give somebody twenty minutes lying awake in the dark and they will find the join, and once found they cannot un-hear it, so the product breaks for the person who uses it most. So it trims on a measured level envelope rather than by ear, discards outright anything whose level climbs across its whole length because a rising clip can never be a bed, makes each repeat unit self-seamless with an equal power crossfade, then layers several slightly detuned copies at different start points so the pattern does not come back around inside the run time. The test is more use than the technique: a plain loop was measured first as a control, which turned a matter of taste into a number that survives being tired, and that number went on to overturn two standing assumptions, including that the single best performing clip in the catalogue was the worst possible source material.
Turns a written idea into a finished, sellable printable range in an afternoon: card faces and designed insides composed from one data file, fold-over and flat print files in both paper sizes, envelope and instruction sheets, and dozens of marketplace photos, all from a single command. The interesting part is not the speed, it is the four gates it has to pass, each one added after something got past the ones before it. Text is measured against the actual pixels behind it and given a glass panel only where the contrast falls short, then measured again for the different fault of sitting across a tonal edge; every deliverable is verified by the property that makes its promise true rather than by its filename, because a file named foldable once folded onto a blank panel while the listing promised otherwise; and the marketplace copy is checked against the rules that platform enforces silently, which on one audit found a keyword being dropped from nine live listings and a headline phrase that made three of them unfindable. Five ranges and four non-card products have been through it.
Turns a written script into a finished captioned reel in my own voice, entirely on my own machine, with no studio and no stock. My voice is cloned locally and free, then a punch-in engine generates the narration a sentence at a time so a single off word is retaken on its own instead of rerolling the whole take, and where two takes each hold half a good line it splices them at the word using timed transcription and proves the join by reading the result back. A pre-flight scan flags the words my accent trips on before I ever record, captions are pulled from my real script and lifted clear of the platform's own buttons, and every frame is checked by eye rather than trusted to a clean render. One fortnight of reels came out of it, and nothing left my desk.
My AI persona posts to Instagram on her own, every day, hands-free. A scheduled run picks the content pillar, writes the scene, generates a high-resolution on-brand image that holds her exact face and figure from reference images, drafts the caption, gates it through a brand-safety check that only lets clean copy through, then publishes to the live account and pings me with the link. When anything upstream lapses it fails loudly instead of silently, and one flag pauses posting back to review-only. The whole image step drives the generator's own quiet interface directly, so it stays reliable where clicking the screen never could. It now also guards against the failure that makes automated feeds look automated: the scene picker keeps a memory of what it recently used and spaces posts by the LOOK a viewer perceives rather than by the scene description, since two differently worded scenes can produce the same photograph. Its scene library was rebuilt to twenty-four distinct look families, sized against the real posting rhythm rather than the post count, because a multi-panel piece draws several scenes at once and a month pulls far more than it publishes. A companion pass re-spaces a month of already-scheduled posts by the same measure, seeded with what has already gone out, so the queue continues the live feed instead of ignoring it.
Reads every comment on a live account and works out, before anything else, whether a real person is actually there. It caught that five of six recent comments came from one automated tool, posted in a single burst across five different posts inside three minutes, and filed them as noise rather than spending the brand's voice on a machine. What survives that gate gets sorted by what the person needs, and anything sensitive, someone in distress, someone asking a hard question about who they are talking to, is handed straight to me with nothing written for it. Genuine comments come back as a drafted reply in the account's own voice, specific enough to prove somebody read the actual words, waiting on one tap from me. Frequency caps, quiet hours and a supervised first run sit in front of it, and it holds its own compliance reasoning in writing, quoted from the platform's real policy rather than the folklore version. It now runs a second account with a far harder line drawn around it, one where the subject is a person's own character and there is no clinical qualification standing behind a single word. That version refuses any reply reaching for treatment language, any reply that tells somebody what they are, and any reply that offers advice. The ban is written against the shape of a verdict rather than a list of medical words, because the one reply that slipped through the first live run carried no medical vocabulary at all and still handed a stranger a judgement about herself.
The graduation film that proved the whole system. One request went into the operating layer and came back as a finished seven-minute film narrated in a locally cloned voice, on brand, privacy-checked frame by frame, with agents gathering the material, an orchestrator building the composition in code, and a self-review pass before it was called done. It now streams in full quality from the builds directory itself, repackaged into segments so a static host serves it free, with a companion page telling the story of how it was made.
A whole game studio folded into an agent: bring a theme and it picks the right kind of game, then designs, builds, verifies and packages it with the store copy and icon art alongside. It carries six style packs, so a rage game, an ambient toy, a party game and an arcade skill test each get their own gates and their own machine instrument rather than one genre’s rules bent to fit. Every build appends to a ledger of what the process failed to catch, which is where the next gate comes from, and the ethics are structural: currencies earned by play only, no loot boxes, no rigged near-misses.
A generative art-to-storefront pipeline that makes original art from code alone, so every piece is one of a kind and mine by design, then carries it all the way to a ready listing: print files at true gallery resolution, a framed mockup, a search-ready title and matching pins. Two engines run inside it, five locked abstract styles that mint whole collections hands-off, and a natal-chart engine that draws a one-of-a-kind astrology poster from a person's exact birth moment. A human yes sits before anything publishes.
Makes anything generative provably mine: a cryptographic fingerprint, a real signature from a private key, and a small astrolabe seal drawn from that fingerprint onto the work itself. The certificate carries the complete algorithm and the single command that recreates the piece exactly, forever, so the buyer owns the art and its genome.
A private on-device pipeline that turns a book I own into a searchable copy I can read: one clean frame per page, the text read by on-device OCR with nothing uploaded, rebuilt as a searchable PDF with a selectable text layer under every original page. Tested end to end on real books. An accessibility tool for reading large, listening along and finding a passage.
My core loop. Every build becomes a sanitised, sellable product with a clear licensing structure, so the work compounds. I build for my own brand first, then adapt a version that pays licensing back.
A go-to-market pipeline in one session: demand check, product decision, price ladder, storefront, email sequences, and a month of content.
A zero-cost demand scanner that reads live sources every few hours, distills hundreds of signals into a ranked shortlist of real problems worth solving, and turns an approved opportunity into a build brief. A private snapshot lets me review the shortlist from my phone while the engine stays on my own machine.
A content engine that takes one idea through a pipeline into many channels, with the assistant cutting and scheduling.
It scrapes every page and table of an old site into seed data, then reads the audience out of the content. The brand DNA stays. I re-execute it as a modern design system and rebuild on a current stack with the content already in place. I've run it on three sites.
An unattended research loop: each pass a fresh AI session reads the journal, picks one untried idea, writes it as a trading strategy, and hands it to a harness whose pass-or-fail gates live in code, never in the prompt. Every attempt is journalled and the whole thing runs on my own machine, with no strategy or key leaving it. The part I care about most is what came after: stripping each survivor down one component at a time, which found parts that did nothing at all and one whose removal improved every measure at once.
A multi-agent audit that reads running code against its own spec, fans out analysts across data model, dependencies, design and risk, then adversarially verifies every finding against the source. It catches where the document and the code disagree.
A fan-out research workflow where parallel agents each own one marketplace or source, then synthesise a ranked shortlist with evidence, pricing, saturation and a fit flag. For any what-is-trending, what-should-I-sell question.
The media line: HTML-video composition with captions, text-to-speech and audio-reactive visuals through to render, plus voice-memo ingest and reel teardown that download, transcribe and reverse-engineer a creator's structure.
An autonomous overnight workflow: scan installed packages, summarise with an AI pass, and surface only real danger through layered alerts, staying silent when clear. The machine guards itself while I sleep.