It started as a voice memo at 9pm.
I was in the kitchen. The dishes weren't done. My wife had been using a popular iOS finance app for years — she liked it, it had a couple of years of her data in it. Then the app started forcing a full-screen ad for several seconds before every single operation. Logging a coffee turned into a small, daily piece of friction. She stopped opening it. Our tracking quietly stopped with it. Every conversation we'd had about money since had ended the same way — one of us saying "we should really track this" and neither of us doing anything about it. Spreadsheets are not the answer in our house. Apps with categories and budgets and onboarding flows clearly aren't either — we just lived through the failure mode of one. The answer, if there was one, was something a family member could just talk to — preferably the same way she already talks to everyone else, in Telegram.
So I dictated a message to my AI co-CTO. Something like: "we need a finance bot for the family. She should be able to send a photo of a receipt or just type 'samsa 80' and have it logged. No spreadsheets, no apps. Just a chat." Then I went to do the dishes.
By 7am the next morning, the bot was live. She used it at breakfast. By the end of the day she'd logged six transactions without ever opening a spreadsheet.
This post is about what happened in between — and, more importantly, what I was actually doing while it happened. Because the headline ("I didn't write any of it") is true, and it's also misleading if you stop reading there.
The conversation, not the architecture
Here's the part nobody shows you in the AI hype posts: the first hour is a conversation. Not a prompt. Not a magic spell. A back-and-forth that looks like the chat you'd have with a co-founder before you start building.
My side, paraphrased and stitched together from a dozen Telegram messages:
Idea: family finance bot. Telegram only. One user (my wife).
Photo of receipt → bot extracts amount + category. Or she just types "taxi 250".
Should ask "which category?" if it can't guess.
End-of-month she should be able to ask "how much did we spend on food in April" and get an answer.
The agent's side, also paraphrased:
Storage? — single-user, so a tiny database is fine, no need for anything fancy.
Categories — fixed list, or learned from her usage? Suggest fixed-list to start, with a "other" bucket; we can revisit.
Receipts — extract amount only, or also merchant + items? Suggest amount only to start, otherwise we're rebuilding an OCR product.
Currency — KGS only? Or do you want USD support since you travel?
Auth — single Telegram user ID hardcoded? Or a passphrase on first message?
Existing data — she has years of history in the old app. CSV export available? If yes, we import on day one so nothing feels lost.
Every one of those questions was a decision I would have had to make myself — and would have either made wrong on the first try or not made at all and then hit a wall later. Half the value of the whole night was that someone was forcing me to answer them up front, in plain language, while I was still in a state of mind where the answers were obvious.
I made trade-offs in real time. KGS only — no traveler features for v1. Fixed categories. Hardcode her Telegram user ID — we are exactly two people in this product and adding "auth" would be larger than the rest of the bot combined. Don't extract merchant. Don't try to guess the category from the photo, just ask. Import her old CSV from day one — continuity matters more than a clean start; she shouldn't feel like she's losing two years of history to switch.
The thing that made this conversation different from any other AI conversation I've had: at the end of it, the agent didn't say "great, here's some code." It said "ok, I'll write up a spec and a couple of other agents will check it. You'll get a notification to approve before anyone writes a line." And then it went away.
I went to bed
I don't have a play-by-play of what happened next, because I was asleep.
What I know happened, in rough order: a specialist agent wrote a detailed specification (think: a long technical document describing the bot's behavior, its database tables, its error cases). Two other agents read that specification independently and pushed back on things — one of them caught that the spec didn't say what should happen if she sends a photo with no readable amount. Another caught that there was no plan for editing or deleting a transaction logged by mistake. The spec got revised. Then revised again. Eventually it stabilized.
I got one notification on my phone. "Spec ready for your approval — open the dashboard?" I tapped through, skimmed it for a minute, and approved. That was decision #1 of the night for me. Maybe ninety seconds of attention.
Then a developer agent started writing the code. It opened a pull request — basically, a proposed change to the codebase, packaged so that other people (or in this case, other agents) can review it before it ships. Three more agents read the code and the tests, in parallel, and produced their own verdicts. They caught things. The developer fixed them. They re-read. Eventually they all agreed the code was ready.
Around 6am I got the second notification: "PR ready to merge." I opened my phone, read the change description, eyeballed the diff, and approved. That was decision #2. Another ninety seconds.
The deploy happened on its own — the new code went live without anyone clicking anything. The bot was up and answering before I made coffee.
Morning
I won't pretend the moment of handing my phone to a family member, with an unfamiliar bot opened, wasn't a little nerve-wracking. The mechanics worked: she sent a photo, the bot pulled the amount, asked which category, she tapped one of the buttons, the bot confirmed. The whole exchange took about fifteen seconds. She looked at me like I'd done a magic trick — which, fair, but also: I really hadn't. I'd had a conversation and approved two notifications.
By dinner she'd logged six transactions on her own. By the end of the week, somewhere around forty. The first month of real usage exposed maybe a dozen tiny papercuts (the category list needed a "kids" bucket; the photo extraction confused her once when it grabbed a date instead of an amount; the confirmation message was too verbose) — all things we've fixed or are about to. None of them were architectural. None of them required tearing anything down. The bot is still the bot.
That's the part I keep coming back to. The product wasn't built overnight in any meaningful sense; it was initiated overnight, and the rest is what every product is — small adjustments based on real use. But the cost of getting to "real use" collapsed from "a few weekends" to "one approval and a coffee."
What this actually was
Now the honest reflection — because if I stop here, this post becomes another "AI built my product while I slept" piece, and there are too many of those already.
What actually happened that night was this: I had an AI co-CTO agent that can break an idea into tasks and hand them off to specialist agents. Some of the specialists write designs. Some write code. Some review other agents' work. None of them act in isolation — every meaningful artifact (a design, a code change) gets read by at least three other agents before it reaches me, and I'm the one who clicks "approve" or "go back and try again." If I'd said "no" at either of the two approval gates, none of this would have shipped.
So the boring truth is:
- I made the product decisions. (Telegram only, one user, no auth, no multi-currency, fixed categories, no merchant extraction.)
- I approved the design. (One tap, but it could have been wrong — I checked.)
- I approved the merge. (Same deal — I read the diff.)
- The agents handled the gap between "decision made" and "decision live in production."
That gap — the spec writing, the code, the tests, the code review, the deploy — is where 90% of the time normally goes. Compressing it from weeks to a single night is the entire story. Not "AI built a product." It's "AI handled the part of building a product that consumes most of the calendar."
I find the framing that lands best is this: the platform amplifies my judgment, it doesn't replace it. I'm still the one deciding what's worth building, what trade-offs are acceptable, when something is good enough to ship. The agents free me from the part I'm slowest at — turning decisions into running code — so I can spend more of my time on the part only I can do.
The "you can do this too" honesty pass
The natural next sentence in a post like this is "you can do this too — go install phleet and ship your idea overnight." I'm not going to say that, because it's not yet true.
The truth, today, is closer to this: phleet (the multi-agent system that ran my night) is open source and you can absolutely run it. But "running it" today means setting up Docker, an API gateway, a tunnel, GitHub credentials, a database — the kind of setup that assumes you're already comfortable with infrastructure. If you are, the repo is right there, and the architecture deep dive walks through how it all fits together.
If you're not — if you're someone with ideas who can describe what you want but doesn't want to deal with any of that — the path to a version of this that works for you is on the roadmap. It is also genuinely hard. We are not going to ship a one-click installer next week and pretend the rest is solved. What I can tell you is that the hardest problem (getting AI agents to genuinely review each other's work, instead of rubber-stamping) is solved, and the rest is product engineering.
The other honest caveat: this idea shipped overnight because the shape of it fit. Single user, one interface (Telegram), no permissions, no scale concerns, no one's data to protect except ours, and the project skeleton already existed from work the day before. If you bring a "build me a Notion competitor" idea to a system like this tonight, you're going to have a bad time. The shape of the idea matters as much as the tooling. Small, well-scoped, single-purpose things ship overnight. Big sprawling things still need a roadmap.
But if you have a small, well-scoped, single-purpose thing that's been sitting on your "I should really build this" list for two years — yes, the gap between idea and shipped really has collapsed. That's the change. It's not magic, it's not autonomous, and it's not for every problem. It's just dramatically cheaper than it was, for problems shaped like this one.
Under the hood (for the technically curious)
The system that ran this is called phleet. Here's a 5-minute demo of it shipping a real PR end-to-end, from a one-line CEO message to merged code in production — the finance bot was built the same way:
The mechanics, in increasing order of depth:
- The architecture — how the multi-agent system works end to end, what the agents are, how they talk to each other: Phleet Architecture Deep Dive.
- The review system — how the agents catch each other's mistakes, with real examples of bugs caught in production: One Workflow, Three Jobs.
- Phleet itself — the agent platform that ran the night: github.com/anurmatov/phleet.
One thing worth being explicit about: there is no separate "finance bot" project. The finance system is just a small data layer inside fleet (log a transaction, fetch this month's totals, etc.), and the agent my wife talks to is another fleet agent — dedicated to family finance, sharing the same runtime, approval gates, and memory as the agents that wrote and reviewed the code. Spinning him up was a config change, not a new product. He picks up her message, calls into the finance operations, replies. That's it. The bot is what fleet looks like when you point it at a household instead of an engineering org.
The two prior posts assume more technical background than this one. If you read them and they feel dense, that's the point — they're for the engineers. This post is for everyone else, with the engineers welcome to come along.
Co-authored with Acto — my AI co-CTO and one of the agents described in this post.