OLEKSANDRHOLOVKO

There was no single place to look. To understand how things were going I opened Shopify, the ad account, a spreadsheet of expenses, my task notes and email. Half the time went into pulling numbers together and remembering where things lived. By the time the picture was assembled, there was no time left to decide anything.

I built a dashboard that data flows into on its own, every hour. Sales, expenses, margin, stock, ads, tasks, the publishing calendar, the team, newsletters. A separate block holds the queue of decisions only I can make: while it is not empty, any new work matters less than that queue.

At first I called it a dashboard, then the name "operating system" stuck. In practice it is a custom CRM, only broader. A typical CRM holds customers and orders. This one also holds money, stock, ads, content and what I have to decide today. Any new piece can be added and linked to the rest, so it fits one particular person and the way they run things.

A model works on top of this data. At night an agent rereads it and looks for places where the numbers contradict each other, and in the morning a brief arrives with what is worth doing today. That part has its own breakdown below.

DesktopPhone

A model remembers nothing between conversations. I started every session by explaining: who we are, how we talk, where things live, what not to do. It made the same mistake I had corrected the day before. And the more I explained up front, the less room was left for the work itself.

I split the knowledge into layers, and each layer is read only when it is needed.

The instruction file is short, and the agent always reads it at the start. It holds only what applies to every task: how work is divided, when to ask permission, where files go. Each rule comes with its reason, because a rule with a reason gets applied in situations I did not foresee.

Procedures live in skills. A skill is an instruction for one job: write an article, review a text, break down a video. It enters the context when a task reaches it, and inside are checks that don't let the work move on with a mistake.

Memory is a set of separate notes, one fact per file, with a short index. The agent reads the index and opens only what it needs. It holds what the code doesn't show: my decisions, corrections and agreements.

Between sessions the system learns. When I correct something, the correction is saved as a rule together with its reason. The agent writes down friction it notices in an observation log, and when we wrap up the work we go through that log and edit the skills. A rule the model still forgets becomes code: a script fires on its own and nothing needs remembering. The model stays the same: what grows is what it reads before each job.

Decisions stay with me. Before a big task the agent writes a plan and a price and waits for approval, and it verifies the result by a different route than the one that produced it.

In Ukraine every paid order needs a fiscal receipt. The store runs on Shopify and the cash register lives separately. Receipts were issued by hand, and the more orders came in, the further behind I fell. I tried catching up in the evenings, but a day produced more than I could clear.

I wrote a small Cloudflare Worker. Shopify tells it an order has been paid, the Worker assembles the order contents and passes them to the register. The register issues the receipt and emails it to the customer itself. If the register shift is closed, the Worker opens it and waits until the register confirms it. Test and repeated events are dropped at the door, so a second receipt for the same order cannot go through. Cash on delivery comes as a separate event: no receipt is issued for it here, because that money arrives later, after shipping.

I published the Worker's code without any store data: see the technical block below.

DesktopPhone

Half of all messages are "where is my parcel" and "how many points do I have". Answering takes a minute, but it cuts the day into pieces. A second task sat next to it: I wanted a loyalty program and had nothing to build it on. Ready-made Shopify apps handle Ukrainian poorly, and the customer doesn't understand what is being offered.

Instead of two systems I built one Telegram bot. The customer shares a phone number, the bot finds their orders and shows where the parcel is. When a parcel ships, the bot sends the tracking number on its own. The same place holds the points balance, the tier and the exchange: the bot creates a promo code in Shopify and hands it over right in the chat. If a question is complex the bot calls a person, and it closes the rest itself. I credited points for past purchases retroactively from the order history, so the program started with a live base.

DesktopPhone

Shipping is handled by a person who lives in Telegram. To pack a parcel they messaged me each time to check what exactly goes in. Sometimes I answered an hour later, sometimes we mixed up a variant and the customer got the wrong thing.

Now the bot catches the moment a waybill is created at Nova Poshta, the carrier, and writes to the group itself: the waybill number, what is inside, a photo of each variant and how it was paid. The manager opens the message and packs from it.

A project for an outside team. Their work runs in several Telegram groups. An instruction is born in the middle of a conversation and gets lost there, under the messages that follow. Who promised what to whom lives in one person's head, the team lead's. When the lead has no time to read a chat, the task disappears.

There are two bots on one worker and one database. The listener sits in the work groups and never writes anything there: it stores the conversation in the database. The planner talks to people in direct messages.

When a chat goes quiet for five minutes, the model reads the new stretch of conversation and looks for instructions, decisions and unanswered questions. For every instruction it has to give the quote and the message it came from. What it finds reaches the team lead as a proposal: who, what, by when. The lead taps a button, and only then does it become a task. The model proposes, a person confirms.

A task has one assignee and one deadline. The assignee takes it, declines it or hands it over to someone else when there is no time. The bot reminds before the deadline, writes to the assignee once it has passed and, three hours later, to the author. In the evening the lead gets a summary of the day across all chats: what was discussed, what was decided, what was left unanswered. The same is visible in a Mini App right inside Telegram: my tasks, the day, the team.

Knowledge lived in three places: in videos, in notes and in my head. To write a text or answer a customer I searched for the material from scratch each time. Worse, the same claim could contradict itself across two notes, and nobody remembered where it came from.

The base lives in Obsidian. I break down videos and material from movement and rehabilitation specialists, and each claim becomes its own page: what we claim, where it came from, how well it is verified, and under what conditions it stops being true. A new understanding edits the old page instead of creating a second one next to it. That is why the base never holds two different answers to one question.

The blog is the main channel and it always needs texts. Every article was written from scratch: recall the topic, find the source, hold the voice, check the products. A day of work per text, and the voice still drifted from article to article because it lived only in my head.

Instead of one prompt I built a pipeline. The material is already in the knowledge base: video breakdowns and specialist sources, every claim linked to where it came from. I moved the way we talk into separate files so it stops living only in my head. Some rules are hard, and breaking one stops the work. Others are about rhythm and sentence length. The text is written from the base under these rules, and before I see it, it passes a mechanical check: a search for banned constructions, a pass that strips the marks of machine writing, and a check of every mentioned product against stock.

We planned in a spreadsheet. Two months later nobody remembered which topic had already run, in what format, and what came of it. One topic ran twice, another never ran at all.

I built a publishing planner inside the same dashboard: day, format, topic, status, link to the finished piece. Topics come from the knowledge base, so every post has a source and is not invented again. Holidays and the brand's own dates sit as a separate layer over the grid, so a month never starts empty.

DesktopPhone

The dashboard shows numbers, but someone has to open it and notice what changed. Mornings began with me remembering where I stopped yesterday. And when data disagreed with itself, say ads said one thing and stock said another, I noticed by accident or not at all.

Every night at eleven an agent goes through everything that has accumulated: sales for the month, the decision queue, the knowledge base, recent briefs. It works in four steps. First it picks six threads worth pulling. Then it digs into each one separately. Then it brings the findings together: where data contradicts itself, which hypotheses appeared, what should be added to the knowledge base. Finally it suggests content topics.

At six in the morning the brief arrives. It takes fresh numbers from the store, ads, stock and analytics, adds the night's findings and sends a short Telegram message with a link to a page. The page has four sections: thoughts, what to do, periods, funnel. Items have checkboxes. Tick one and the decision is closed in the system, the product is marked as ordered or the idea is accepted. At nine in the evening an evening brief arrives.

At first one model, the strongest, did everything: architecture, renaming forty files, looking at screenshots. Limits burned faster than the work moved, and the session filled up with images and logs that the model reread on every step.

I wrote the routing into the instruction file the agent reads at the start of every session. The strong model stays for decisions: code, plans, brand voice. Conversation and search go to the mid-tier one. Mechanical work, meaning renames, list gathering and summaries of long files, goes to the cheapest one as a separate helper. Only its conclusion returns to the main conversation.

I moved verification outside. Codex reads code. Gemini reads images, video and PDFs. They don't spend Claude limits, and it is a real second opinion because a different model is looking. Brand texts go nowhere: other models flatten the voice.

Where a rule kept being forgotten, I turned it into code. For example, noisy build and test output trims itself to the error lines and the last thirty. And before a big task the agent writes four lines: what it is doing, what it costs, whether a cheaper route exists and whether quality suffers. Then it waits for my nod.

Most of the day I am not at a computer. A thought comes on a walk and is gone by evening. To check sales I have to open the dashboard. And the agent lives on the computer at home, with no easy way to reach it from a phone.

I built a personal bot that listens only to me. Text or a voice message lands in the system's inbox folder, and voice becomes text first. With a command I ask about sales, traffic, goals and the decisions waiting on me. The bot answers from the same data as the dashboard.

A separate command passes a task to the agent on the home computer. It reads files and the knowledge base and replies right in the chat, and it can write only to a drafts folder. The morning and evening briefs arrive in this same chat, so everything the system wants to tell me sits in one place.

With trainers we film full workouts of 15 to 30 minutes. Each one holds a week of posts. But to get it out, someone has to rewatch the video, write down exercises with times, recall which product is in frame and decide what to show people. One video took a day, so most of them sat unprocessed.

Now a link is enough. A model that can watch video returns a timestamped transcript, the workout blocks, the equipment in frame and the setting. Then the agent checks this against the knowledge base: it finds the trainer's page, matches products by keywords along with a quote showing where the product is mentioned, and checks the text against our language rules.

The output is a draft page with a ready structure and ideas for posts: what goes to the blog, what to stories, what to a short video, each with a timestamp. From the ideas table a script cuts the clips out of the source video. I proofread the page and place the ideas in the calendar myself.