AI for Coffee: Or How I Automated the One Thing That Didn't Need Automating

At the end of 2024 I bought myself a Fellow Aiden, a fancy pour-over machine that makes great coffee once you tweak and tune a complicated (to me) brewing profile. Previously, my coffee ritual involved either French press or a drip machine with freshly ground beans of some sort. I liked pour over and never loved the labor nor the engagement of learning it, and as such, I spent a few frustrating weeks fighting with the new machine before I built a custom GPT to help me figure out which levers to pull in order to get a coffee profile that was at all drinkable.

The Aiden gives you a lot of levers, and that was the whole problem:

• Temperature and coffee-to-water ratio, the basics any brewer thinks about (I lie about the ratio and run the default, because the machine won't let me dose as little coffee as I need to report).
• Bloom settings: whether to bloom at all, the bloom ratio, how long it blooms, and at what temperature.
• Pulses: how many pours the machine makes, separately for single-serve and batch, the time between each one, and the temperature of every individual pulse.

That last one, the pulses, is where it gets overwhelming to me. A profile isn't just one temperature; it's a different temperature for each pour, and changing one by a degree or two changes the result in the cup.

A year and a half after going back-and-forth with ChatGPT to create some really great profiles that met my tastes, I had everything I needed to build a real app from my Pinocchio experience: a pile of profiles, the experience to know what I wanted, and finally the infrastructure to run it myself.

And so can you.

From GPT to Chat for Coffee

Back in early 2025 I built a custom GPT to tune coffee profiles, shared it on Reddit, made a few profiles for people who asked, then pointed folks toward using their own AI instead, because, frankly, it seemed like it'd be easier for them to have that discussion and tweak to their own preferences. Plus, I didn't want to be someone's go-between to my GPT to tune a profile that might be too bitter, too astringent, etc. Someone built a polished public site that did the same thing (and better), which was great to see.

At this point, I didn't have the infrastructure yet, so I just kept an ongoing conversation every couple of weeks when a new bag of coffee entered the mix. I'd feed it the details of the new coffee and my tasting (and sometimes smelling) notes, and over a year and a half we got dialed-in enough that I could grab a new bag and land a cup I loved in one or two tries, working from little more than the roaster's notes and my own history.

And that system has been working fine, without any complaints. It works fine. It also lives on someone else's servers, learning my palate in someone else's cloud. It's only coffee, so it never bothered me much, but I still wanted to do a bit more.

The MVP Was Easy

I had months and months (over a year) of dialed-in profiles ready, and ChatGPT knows my taste preferences, so I had the experience of tuning by taste. I discovered that someone in the community had already worked out how to talk to the Fellow cloud API, so device access was not an issue; the current only way to add or remove a profile is through an iOS app that isn't always convenient. Someone else shared how to get MCP access to the Aiden, which was also helpful.

What I assembled was a coffee profile archival system with machine retrieval and placement: a library of every coffee I've tried, profile generation, push to the machine, and pull back into an archive that outlives the device's 14-profile limit.

With over a year of trying a lot of coffees, I had built up a lot of preferences that allowed me to also build a personalized Taste Model too: my preferences as structured data on a 0 to 10 scale, learning from every brew I log, and visible enough that I can correct it. It keeps Qwen and me pointed at the same target.

That part came together fast. The build was easy, because the hard pieces already existed.

The Testing & Refinement Was Less Easy

Getting the archive working was the easy part; the application was up and functioning in little time. Pages were showing, content was seeded from experience and from the Aiden itself.

When it came to teaching the model my taste profile, things got a bit more involved. I started out on a frontier model and I was moving to Qwen3.6 on local inference so there was a lot more training and testing to do in order to prevent regression into muddy and undrinkable brews. And I didn't want to start the new week ahead with trash coffee, either.

Previously, every discussion was in a chatbox and it's easy to assume that any AI is your pal, your buddy, and they just know and remember things. You kind of set it and forget it, and as such, my early generated profiles looked fine and made sense. I hadn't previously been committing much to memory because AI did all the work and I just filled in the blanks, shared how things tasted, modified and moved on with my life.

Now, with a new AI that doesn't have nearly the same capability (nor cost, for that matter), I found I had no way to know if the model was reasoning or just handing me back my own data on a web page. It looked good, and I was afraid to waste good beans, so I built a blind test.

I hid an existing coffee's existing recipe and provided the model only the coffee's character and my taste model. I was able to see how close that profile landed to what I currently brew, and if it was close without seeing the current answer then I knew it was learning something, however, if it drifted pretty far away, I'd know that I was getting confident guessing.

It was guessing.

The model bloomed hot, around 188 to 190 degrees regardless of the coffee, when my own history shows I bloom much cooler on naturals and fermented coffees to protect the sweetness. It gave me a four-pulse batch where I'd hand-tuned five, plus a few other variables that were off just enough to notice.

The reason was simple: the model had nothing of my taste to reason from, so it fell back on generic averages. So I gave it something. I fed it my own dialed-in profiles as worked examples alongside the taste model, so instead of guessing from the middle, it could reason from the coffees I'd already gotten right.

Then I tested it the hard way, across all 29 of my coffees, one at a time, hiding each coffee's real recipe so it had to predict a profile it couldn't peek at. If it landed close to what I brew, it had learned from the other profiles. Likewise, if it missed, it hadn't learned much of anything.

The numbers split into two stories, because my coffees split into two types: ones I dialed from scratch, and Fellow Drops (an opt-in coffee subscription) that ship with a published recipe I then used as reference and had GPT adjust toward my taste profile.

The coffees I dialed from scratch were the first story. Blind testing revealed that the model predicted my ratio almost perfectly, nailing my exact pulse count 78% of the time, and my bloom temperature within about 1.4 degrees. It landed inside four degrees of my real bloom 89% of the time, without ever seeing the recipe. That might seem pretty close and accurate, however, when it comes to fine tuning a pour over coffee profile, single degrees within a specific bloom can change the entire taste of the cup you're drinking (he said, sounding like a coffee snob).

The Fellow Drops profile modifications were pretty compelling. A Drop comes with Fellow's own published recipe, which is what you'd use if you had no tool at all, and if you went by someone else's definition of what makes a perfect cup of coffee (and in my personal opinion: a very, incredibly, over-the-top strong cup of coffee!).

Fellow's base misses my bloom by 8.7 degrees, my pulse count by nearly two, and my ratio by 0.84, when measured against my real profiles. The grounded model, which never saw the Drop recipe, beat Fellow's preset on every dimension. Fellow blooms hot, around 200 to 205 degrees. I bloom the funky coffees much cooler to keep them sweet: 25 degrees cooler on a Grape Soda co-ferment that I found gross, 21 cooler on a Rwandan natural. The model picked up that cooling habit from my real profiles and settled right where I prefer.

A model trained on my taste predicts my preferred cup of coffee better than the roaster's own recipe does. And, in all sincerity, that's not an insult to the roaster's own recipe; they offer a great starting point that everyone should tweak to their own preferences, and I appreciate the baseline they provide. The model means I don't have to have a tiny sheet of paper taped to my fridge telling me how much to adjust each new profile that I want to try, and it's really great to be out of the 1970s.

The tests were incredibly insightful and they really helped close the loop on what it means to fine-tune a profile. We went from "pretty much guessing" to "this is how you apply the taste profile and preferences to get to something consumable by Russ" after a few rounds of rigorous testing.

When I started with GPT a year and a half ago, a new coffee took two to four tries to dial in. By the end I was down to one to three, and I'd often skip the first attempt entirely and jump to GPT's "if this doesn't land, try this instead" suggestion to get closer faster. The current model lands that close right out of the gate, before I've tasted a thing.

I want to be transparent about my testing: my from-scratch sample is small, nine coffees, and I'm reporting it with its size rather than rounding it into a tidy headline. Leave-one-out is a proxy for a brand-new coffee; it's a solid approach and, it's still a proxy. Bloom carries a lot of per-coffee judgment that no amount of metadata predicts, so the model gives a strong starting point and the tasting loop closes the last few degrees.

Why I'm Not Selling (You, Anyone) This

It's built, and it's tuned to me, and I was implicitly selfish about this from the start. Yes, I could add user accounts and allow people to customize their own taste models, and I could probably get some neat traffic and continually find ways to add feature bloat. Or, I could open-source the code and let everyone participate, or tell me what I left out because of how they drink their coffee. I could put a subscription model on it and chase that one-user SaaS joke into something real.

I just really don't want to.

I like being able to just continue to make adjustments to this for me and for my coffee and let it sit as a standalone app just for me, much like the at-home gym app that I have helping me (and only me) make custom workouts.

My coffee taste is finicky enough that maintaining this for other people would mean either compromising my own setup or signing up to be responsible for someone else's morning. If I tweak how the model handles a natural process coffee because it improves my cup, I might quietly ruin someone else's and that's a strange kind of liability to take on for a thing I built to make myself a better cup of coffee.

Instead of building a SaaS with one user, and instead of providing a github repo with open source code that someone can give a star to or not, I'm giving away the brief.

I wrote a full product requirements document for Coffee Compass that includes what it does, how the pieces fit, and the hard-won specifics about the Fellow integration that will save someone days. You can read it online or download the Markdown to hand straight to your own agent. There is no code nor repository at all to wrangle, review, or worry about whether or not there's something deceptive or hidden or tracking of use or any of that.

You can take the PRD and feed it right to your own AI agent, in your own environment, and build your own version, calibrated to your own taste, learning on your own hardware or cloud compute that you use.

Please inspect it first, or at least have your agent inspect it, of course. You'll want to have it consider your environment and needs and get things setup the right way for you, which is maybe on a local device or on a website somewhere. Or maybe you want to be the open source person, which would be cool, too. That's entirely the point; you build it yourself to meet your own needs, so you know exactly what it does and what it touches.

A Closing Thought

Software is getting cheap to produce and easy to print on demand. Rather than give you code, I'm sharing the blueprint, which is the part that lets each person build their own.

If you've got a Fellow Aiden and an AI you trust, take the brief and make your own coffee compass.

Read the build-it-yourself PRD ↗ Download the Markdown ↓