Building something useful with AI has become strangely easy. Over the past year I've built a shared shopping list, a resume pipeline, an image generator for this blog and a product that audits website copy, and in every case the first working version arrived faster than I would have believed a couple of years ago. What took longer, and what I think actually matters, was deciding what each of them should become once it worked.
Some of them should stay small, personal and slightly scrappy. Some needed to run on their own without me watching, and one needed to become a proper system that other people could rely on. The AI barely changed between those levels. What changed was everything around it: who relies on the thing, what it can touch, and what happens when it gets something wrong.
Some things should stay small
My partner and I share a grocery list app I built in about 15 minutes because I refused to pay $5 a month for a shopping list. It's Python, PostgreSQL and plain HTML, it refreshes every few seconds so we can both edit it in the supermarket, and it has exactly the features we've needed and nothing else. It has two users who live in the same house, so every bug report arrives over dinner.
I could turn it into a product with accounts, onboarding and a pricing page, but nothing about how we use it asks for any of that. The right amount of engineering for a personal tool is whatever keeps it useful, and keeping it small is a decision rather than a lack of ambition. A surprising number of good AI builds should stop exactly here.
Personal tools still need guardrails
My old resume pipeline was a Claude skill that read a job ad, mapped it against my experience, flagged the gaps and produced a tailored resume as structured YAML. Only I ever used it, so it didn't need much ceremony, but it taught me more about where AI is unreliable than anything else I've built. Early on it added a technical skill I had never confirmed, simply because the job ad asked for it and the claim sounded plausible. Nothing about the output looked wrong, which was exactly the problem.
The fix wasn't a better prompt. I gave it an explicit evidence file covering everything I could actually back up, and made it a rule that every claim had to trace back to that file. Confident output that happens to be wrong is the most common AI failure I run into, and in a resume it's the kind of mistake that surfaces in an interview at the worst possible moment. It's also a small version of a much bigger problem with hiring right now.
An automation is mostly plumbing
Every article on this site has an illustrated cover, and I don't make any of them. When I publish a post without one, a Sanity Function picks it up, a small language model reads the title, summary and opening of the article, and it writes a one or two sentence visual metaphor along with the alt text. An image model then draws that scene, using three existing covers as style references. The instructions rule out text, charts, screens and laptops, because a data blog illustrated entirely with glowing laptops would be its own kind of failure.
The two model calls are the interesting bit to describe and the least interesting bit to build. Most of the work went into the plumbing around them. The function only fires for published articles with no image, and it saves the result to a draft rather than the live page, so it can't set itself off in a loop and nothing goes live until I've looked at it and published it myself. Run locally, it saves the images to a folder and writes nothing to Sanity, which is how I tested it before letting it near real content. The prompt also keeps the subject in the centre of the frame, so the same image survives being cropped into a homepage card and a LinkedIn preview.
None of that is AI, and all of it is why I trust the automation. If the image model has an off day, the worst outcome is a strange illustration sitting in a draft until I bin it, which is a very different risk from a strange illustration appearing on the site at 2am.
When it has to become a system
Revisi crawls a website, scores each page against a set of brand voice criteria and produces a prioritised list of fixes. Other people's websites go into it and other people act on what comes out, which changes the standard completely. Asking a model whether copy sounds "on brand" gets you answers that are vague in a way that sounds helpful, and explicit voice criteria worked far better than any clever prompt I tried.
The rest is ordinary engineering. The crawl is cached, re-audits only re-score pages that have changed, and the AI does the one job code genuinely can't, which is reading a paragraph and judging whether it sounds like the brand. Defining what "on brand" means, testing it against real sites and explaining how the scores work all took longer than building the first version, and that work is what made it something I could put in front of someone else.
Know what it touches
I make most changes to this site through Claude Code, and the agent can read and edit the blog's content through a connector to Sanity. One day it couldn't find any of my articles, and there was no obvious error explaining why. The connector had quietly signed into the account for SplitPea, my A/B testing tool, rather than the one that owns this site. It was harmless that time, but it changed how I set these things up.
Before I wire an AI tool into anything now, I want a plain list of what it can read, what it can change, which account it acts as and what happens if it's the wrong account. It isn't a security review, just enough that someone who does security for a living could look at it and know where to start. For a personal tool the list is a sentence long. For anything shared, writing it down is often what reveals the tool should be built differently.
The question I ask now
Now that building is cheap, the question I ask most isn't whether something can be built but what it should become. A tool for one person can stay scrappy as long as I know where it's likely to be wrong. An automation needs a clear trigger, a safe way to fail and a human checkpoint before anything goes live. A system other people depend on needs the boring parts: a definition of what good looks like, testing against real cases, documentation, and a record of what it touches. I wrote about a pre-AI version of this in when an analysis should become a tool, and the logic hasn't changed much. The cost of the first version has just dropped close to zero.
So if you've built something with AI that's starting to matter to other people, the most useful next step usually isn't a better prompt. It's writing down what the tool touches, where it tends to be wrong and who would notice when it is, and then deciding how much scaffolding that deserves.
