The Blog
I let a local AI sort and tag forty thousand photos
A decade of unsorted photos, described and tagged by a vision model running on an old GPU, with nothing uploaded anywhere. How the pipeline works, what it misclassified, and what the whole thing costs to run.
How I choose a local AI model: a method that takes an hour
Leaderboards rank models on standardized tests, which says little about your specific task. The selection method I use for production work: define the job, narrow by hardware, then run a shortlist against a tiny test set built from your own real inputs.
Why local models slow down and the levers that fix it
Local model slowdowns trace back to a handful of predictable causes: context length, the KV cache, models spilling out of VRAM, and uncapped output. Here are the levers that fix them, in the order I actually check.
Two years of local AI: what was hype and what was real
Two years of running models on my own hardware, scored promise by promise. Privacy and high volume economics held up, parity with the best cloud models did not, and the maintenance load is the cost nobody prices in.
The overnight bill that made me give my AI agent a budget
An agent stuck in a retry loop spent real money all night on a task it could never finish. Here is the counter, the cap, and the warning I built so that cannot happen again.
I put AI code review on my own commits. Does it help?
A few months of running a model over every diff I commit: the real bugs it caught, the context it cannot see, the noise it generates, and why the whole thing only works while it stays advisory.
How AI reads my invoices without touching the money
A small pipeline that pulls supplier, total, due date, and invoice number out of incoming invoices into a review sheet. It has no access to payments, and every row still gets approved by hand.
The AI news digest that replaced my morning scroll
I wired RSS feeds, a language model, and a schedule into a once-a-day news digest. What the build involves, what it costs each month, and where it still misses.
I ran a local model on a mini PC
A fanless mini PC with no graphics card runs a seven billion parameter model at ten to fifteen tokens per second. What the box cost, what I actually use it for, and where a small local model falls short.
I spent a month testing an AI second brain
Four weeks of routing all my notes through an AI recall layer. Plain language search and summarising earned a permanent place. The invented connections and the maintenance tax did not.
I let an AI sort my inbox, and sorting is all it does
A small system reads every incoming email and files it as an action, a thing to know, or noise. It cannot send, delete, or reply, and that restriction is the reason the whole setup is trustworthy.
How I monitor my servers with AI summaries
A model reads thirty minutes of logs and metrics from my small fleet and writes a five sentence summary I can scan while making coffee. The alerting that can wake me up stays deterministic and never touches the model.
The AI tools I actually use every day
Five AI tools survived a year of daily work: a writing model, one TTS voice, local image generation, a narrow agent, and plain scripts. What kept them around while dozens of others got dropped.
I let an AI triage my messages, with one rule that never moves
An assistant reads my email and chat apps, sorts what matters, summarizes long threads, and drafts replies. It cannot send anything. Why that one boundary makes the whole setup workable.
I put an AI on log watching duty
A cheap filter discards the routine lines, hard rules catch the known disasters, and a model reads only the ambiguous leftovers. What the layer costs, what it caught, and where I still refuse to trust it.
An AI writes my changelogs now
Commit notes pile up in shorthand nobody else can read. A model turns that pile into a grouped, readable changelog in seconds, for a fraction of a cent, as long as I read every line before it ships.
How my pipeline picks b-roll and draws diagrams from a script
Every visual in my faceless videos is placed by a program: footage matched to the meaning of each line, diagrams drawn from the structure of the script, captions taken from the text itself. Here is how the visual track gets assembled, and the ways it used to fail.
Cron jobs plus AI quietly run my operation
The most useful AI I run has no chat window. It lives inside scheduled jobs that do real work overnight, from renders to backups to a morning summary. What each job does, and what happens when one breaks silently.
How I back up everything automatically, and where AI actually fits
The 3-2-1 backup system that runs nightly on my machines, built on deterministic tools like rclone. AI helps at the edges, writing configs and summarizing logs, and stays completely out of the copying.
Building an AI agent with tools: how function calling actually works
A language model on its own cannot open a file, run a search, or send a message. Function calling is the mechanism that gives it hands, and it is simpler than the name suggests.
The cheapest way to run AI at home depends on three costs
Hardware, electricity, and your own time are the three real costs of running models at home. Steady high volume favors local hardware you already own; spiky occasional use favors a metered API.
Is CPU only AI usable? I timed it on a normal desktop
I ran three model sizes on a six core desktop with thirty two gigabytes of RAM and no graphics card, timing the first word and the tokens per second. The small models handle real work; the seventy billion one worked and was useless.
The dashboard I built to watch every automation I run
How I monitor dozens of scheduled jobs from one local status page. Every job pushes a tiny run record to a shared place, and the page flags anything that failed or went silent past its expected cadence.
Do you actually need multiple AI agents?
Multi agent diagrams look impressive, but every handoff costs money, time, and context. When one agent is enough, when parallel fan out wins, and why agent chains disappoint.
Embeddings, explained with one picture
An embedding is a list of numbers that places a piece of text on a map of meaning, and similar meanings sit close together. Here is the picture, the four step search recipe built on it, and the failure mode people forget.
Fine-tuning vs prompting: when each is actually worth it
Prompting costs minutes to iterate and covers most tasks. Fine-tuning changes the model's weights and leaves you with a dataset to keep current, so here is how I decide when it is actually worth it.
The first things to delegate to a virtual assistant
The six tasks I handed to my assistant first, the audit that surfaced them, and the short list of things I will never delegate to anyone.
Giving an AI agent memory that survives between runs
A language model forgets everything when a run ends, so memory has to be built around it. The working version is a notes file read at the start and updated at the end, and the hard part is deciding what to forget.
The guardrails I put around every AI agent I run
An agent with real tools can really send, delete, and spend. These are the specific limits I build around mine: least privilege, approval gates, dry runs, hard ceilings, and logs a human can skim.
How AI tokens actually work
A token is a chunk of text, usually a fraction of a word, and it is the unit behind AI pricing, paste limits, and the way long chats forget. One mental picture, a desk that fills up, explains all of it.
How AI transcription works, and where it predictably fails
A speech model turns audio into a grid of frequency features and predicts the likeliest word sequence behind them. That design explains both its accuracy on clean speech and its predictable failures on rare words and messy recordings.
How context windows actually work
A context window is the model's working memory, measured in tokens, and everything inside it costs money and latency. Here is what the headline numbers mean, where long contexts quietly fail, and the habits I use to keep mine short.
How function calling works: the model only ever asks
A language model can only produce text, yet AI assistants check weather and update calendars. The mechanism behind that is function calling, explained step by step.
How I decide what to write about
One text file per brand, about sixty entries in the biggest, and I have written nine. Topic selection stops being a creative decision the moment you publish on a schedule.
How I hire a Filipino VA on OnlineJobs.ph
The full process I use to hire a virtual assistant through OnlineJobs.ph: one month on the paid plan, a specific job post with a hidden filter, a paid test task, and slow onboarding.
How I use AI to write scripts that still sound like me
Most of my video scripts start as AI drafts, and I rewrite every line before recording. Where the model genuinely helps, where it cannot help at all, and the read aloud test that decides what survives.
How I write a VA job post that filters for the right people
The job post structure that took me from a flood of generic applications to about eighty genuinely good ones, section by section, including the one line that does most of the filtering.
How to spot a VA scam before it costs you
The five red flags I watch for when hiring remote help, learned the hard way on my own first hire. Covers both directions, because employers burn workers too.
I automated my email replies. The AI never touches send
An agent reads the full thread, drafts a reply from templates I wrote myself, and stops there. Approval stays with me, and that one design decision is what the whole system depends on.
How I automated my YouTube channel from one desk
A walk through the pipeline that turns a two thousand word script into a finished video on my own hardware, what each stage costs, and the bugs I only caught by watching the output.
I built an AI research agent to do my grunt work
An agent that reads full sources and returns a fixed-shape brief, cutting two hours of manual reading to about ten minutes per target. Here is how it is built and the one rule that makes it safe to use.
I built a scraping system that runs itself, and the scraper is the smallest part
Fetch, parse, store, dedupe, notify: the loop behind a scraping system that feeds a real pipeline daily. The parsing code is a day of work; the plumbing around it is the actual engineering.
The voice on my videos is a clone, and the line I hold on it
How I cloned my voice from a few minutes of audio, what the clone still gets wrong, and the consent line that decides every single use of it.
What giving an AI real access to my computer taught me
How MCP lets a model call real tools on my machine, the near miss that almost sent a message on my behalf, and the read versus write line every tool now lives behind.
I let an AI agent manage my calendar for a month
An AI agent had read and write access to my calendar for a month. The drafting and slot finding were real wins, the autonomous writing was a mistake, and one near double booking set the rule I now follow.
I let my VA use my AI tools
What happened when I gave my assistant access to the AI tools I use daily: the three tools I handed over, the guardrails, and where the combination still fails.
Installing Ollama and running your first local model
The full path from nothing to a working local model: install Ollama, pull a small model, chat with it offline, then call it from your own code through the local server. Includes the short troubleshooting list beginners actually need.
How I keep AI agents reliable enough to trust
An agent that demos well and an agent you can leave running unattended are different machines. The difference is built from constraints: scope, tools, validation, confirmation gates, and logs.
How I keep my AI costs under control
My first serious month of AI usage ended in a surprise bill, and the cause was a stack of small habits rather than one leak. These are the specific changes that keep my token spend predictable now.
Local image generation with SDXL on an old GPU
Every thumbnail on my channel comes off an SDXL family model running on a years-old graphics card: one to two minutes per image, no cost per attempt, nothing uploaded anywhere. The workflow, the three settings that matter, and where a paid service still wins.
Managing a remote VA across time zones
The rhythm and the small toolkit I use to work with an assistant many hours away: async by default, a daily handoff loop, and a standing rule for acting when I am offline.
Modern AI on a seven year old GPU: what still works
My daily AI work runs on a GTX 1080 Ti that is roughly seven years old. What it still handles well, where it clearly fails, and the handful of tricks that decide the difference.
My local LLM stack: what runs on the box and what still goes to an API
One previous generation consumer GPU, a small rotation of open models, and a short set of routing rules that decide which tasks stay on the machine. The honest version, limits included.
Fully offline AI meeting notes
I replaced cloud meeting notes tools with a two stage pipeline on my own machine: local speech to text, then a local language model that writes the summary and action items. The recording never leaves the computer.
How I onboard and train a new VA in a week
The week-one process I use with every new assistant: scoped access on day one, screen recordings that become written procedures, one task at a time, and a daily check-in that tapers off.
I built a content engine that runs many brands from one config
One shared pipeline engine, one small config file per brand, and a template every brand inherits from. How the architecture works, the discipline that keeps it clean, and when it is overkill.
One pipeline, many channels: how I run several brands from one engine
Several faceless channels come out of one shared engine plus one small config file per brand. What is shared, what stays unique, the separation rules that stop collisions, and the shared risk nobody warns you about.
Building a private offline chatbot over your own documents
The lookup-then-answer architecture behind a document chatbot that runs entirely on your own machine, plus the retrieval failures that cause wrong answers and the fixes that make it trustworthy.
How prompt caching cut my AI bill
My bill was climbing because every call re-sent the same two pages of instructions at full price. Prompt caching cut that workload's cost by more than half, and the fix took one afternoon of prompt reordering.
Prompt engineering is overrated
After a year of shipping real work with LLMs, the exact wording of a prompt turns out to be a minor variable. Context, examples, tools, feedback, and model choice move results far more.
Quantization levels explained: what Q4, Q5, and Q8 actually trade away
The number in a quant label is bits per weight, and it sets the whole trade between memory and quality. Rough VRAM figures per level, where the loss shows up first, and the decision rule I use on an 11GB card.
Queues and schedulers are the backbone of my automations
The layer that keeps my AI automations trustworthy is a job queue, a scheduler, and four plain patterns: idempotency, locks, retries, and a landing place for failed jobs. The first version of mine took an afternoon to write.
RAG explained by building one over my own notes
I built a retrieval augmented generation system over my own notes to understand what the term actually means. This is the full build, step by step, plus the failure modes that showed up and the cases where you should skip RAG entirely.
Why I replaced my no code automations with scripts and a local model
The per task bills kept climbing and every broken automation meant guessing at someone else's black box. I moved the ones that mattered to small scripts with a local model handling the one judgment step, and left the simple ones alone.
How I route work between three AI models
The small dispatch layer that sends each AI task to the cheapest model that can handle it. What it cut from my bill, how the fallback works, and the three ways the idea can quietly cost you instead.
Running a business from anywhere with a small VA team
What actually makes location freedom work: a few trusted people, written procedures with clear owners, and the honest costs that never make it into the pitch.
Running AI locally versus paying for APIs, a year into both
Where running models on your own card genuinely wins, where the hosted APIs quietly win, and the time costs that never make the thumbnail. Includes the per task rule I use to place each job.
The self hosted AI assistant I keep running around the clock
A small local model, a pile of single job scripts, a scheduler, and a chat surface I can reach from my phone. What the assistant does on a normal day, how hard questions get routed out to a paid API, and the reliability work that keeps it alive.
Starting an automated content channel from zero in 2026
If I had to rebuild my automated channel with nothing, I would rent every tool, pick an uncomfortably narrow niche, and ship a four step pipeline before buying any hardware. The order that avoids the mistakes that cost me the most time.
Structured output from LLMs: turning prose into data you can trust
Models answer in friendly paragraphs while pipelines need exact shapes. The path runs from asking nicely to schemas to constrained decoding, with validation catching what still slips through.
The Telegram bot that runs my automations
How a small Telegram bot became the remote control for my whole setup. The message loop, the single user ID check, confirmations for anything destructive, and the categories I deliberately kept off it.
Text to speech in 2026: what makes a synthetic voice convincing
Every narration on my channel is synthetic, so the voice has to hold up for ten minutes at a stretch. Here is what separates convincing text to speech from robotic output, and the thousand word test I run before trusting any voice.
Vector databases explained without the hype
What embeddings actually are, what a vector database does with them, and when a local library beats a dedicated server. Covers the failure modes that really bite: weak embeddings, stale indexes, and outgrowing your architecture.
VRAM math: how to know what fits before you download
A model that fits in VRAM runs fast, and a model that spills to the CPU crawls. The short arithmetic for weights, context, and overhead that predicts which side of that line any model lands on for your card.
What actually breaks AI automations
Field notes from a couple of years of running AI automations daily. The five real failure modes I keep hitting, none of them dramatic, and the building habit that turns quiet week-long breakage into loud second-long breakage.
What I pay my virtual assistants
Real ballpark rates for remote assistants, how I structure hourly versus monthly pay, and the payment habits that decide whether good people stay.
What I would automate first if I started over
Starting from zero, I would build four things in a fixed order: a script for one daily annoyance, automated backups, a scheduler, and a single narrow assistant. The order carries the lesson.
What my AI automations actually save me
Roughly eight to twelve hours of repetitive work handed to scripts each week, against a tool bill in the low tens of dollars and an upkeep tax nobody invoices. The honest ledger, including the months where the whole thing ran at a loss.
What my faceless video pipeline actually costs to run
A stage-by-stage cost breakdown of a daily faceless video pipeline that renders locally: script generation in pennies, a metered voice charge per video, and the hardware, power, and maintenance time that never appear on a bill.
When an AI agent beats a plain script (and when it does not)
A working decision rule for choosing between an AI agent and a plain script, from someone who runs both daily. If you can write the steps down in advance, a script wins.
Why AI streams its answers word by word
The word by word reveal in a chat window is the model generating text in real time, one token after another. Here is why generation works that way and what the stream gives you once you build on these models.
Wiring Claude into my real tools: the unglamorous reality
What it actually takes to connect an AI model to your files, messaging, and automations. The model is the easy part; the descriptions, credentials, and scoping are the real work.
Local text-to-speech vs paid voice APIs: how I decide
I generate voiceovers constantly, so local versus paid TTS is a monthly bill and a quality call on every project. Where local voices stand now, where paid still wins, and the volume math behind the choice.
What I would do differently if I started this business over
A SIM line costs me about ten dollars a month. Three decisions I would repeat, four I would change, and why a retrospective written by the person who knows the ending is worth less than it sounds.
How I set up a new machine (and the nine days I did not plan for)
A blank Windows install to a finished render took four hours and ten minutes. Finding what lived only on the old machine took nine more days. The order I install in now.
Transcribing audio locally with Whisper: the whole workflow
I transcribe hours of audio every week on a GPU I own, with Whisper. Model sizes, timed output, transcript cleanup, and the failure modes worth knowing before you trust the result.
The AI tools I dropped this year, sorted by why
A screenshot reader spent three minutes on my fleet dashboard and returned numbers that were not on the screen. Five reasons tools left my setup, sorted by reason because the reasons generalise.
When local AI is the wrong choice
I run most of my AI workloads on hardware I own and still pay a cloud bill every month. These are the tasks where local models lose, and the routing questions I use to decide.
What thirty automations actually cost me in a year
Logging every minute spent keeping existing jobs alive came to eleven hours in one quarter, and nothing broke that quarter. Here is where the time goes and the four rules I use to cap it.
Building a word list for what AI mishears
How I built a running word list to catch the transcription corrections speech-to-text keeps needing, and how it plugs into a real content pipeline.
Buy or build now that code is cheap
AI coding agents have made writing software faster than ever, which changes the buy vs build calculation. Here's a practical framework for deciding, from someone who runs both every day.
Do I tell people AI helped write this?
An honest breakdown of when and how I disclose AI involvement in my writing and videos, and why the question is messier than a simple yes or no.
Exporting my data before I need it
A practical case for exporting your own data on a schedule, before a vendor migration, account lockout, or shutdown forces the issue.
Getting a second opinion when you work alone
How to use AI as a second opinion when you have no coworkers to check your work, and where that setup actually breaks down.
How I keep fifteen brands from sounding the same
Eleven of my fifteen brands were opening every article on a number followed by a failure. Here is the editorial system that pulled them apart, and the part of the sameness I decided to keep.
Paying for AI tools from another country: what actually happens to your card
A practical look at what happens when you pay for AI subscriptions and API credit from outside the vendor's home country: currency conversion, declined cards, regional pricing, and business billing.
Single points of failure in a one person business
A practical look at where solo AI-run operations actually break, and how to build in redundancy without slowing yourself down.
The dry run mode that lied to me
Why dry run mode in AI and automation pipelines can pass clean and still fail for real, and what I changed after it burned me.
The messages I never let AI answer
Why I keep AI out of certain customer replies, even after running automation in production every day. A practical line for where AI customer replies help and where they don't.
The naming rules that hold my systems together
A practical naming convention for AI agents, scripts, and automation pipelines, built from running local and cloud AI in production every day.
The runbook that runs my systems without me
How I turned scattered scripts and habits into a written runbook that lets AI agents operate my infrastructure while I sleep, and where the guardrails are.
The work I delegated and took back
A rundown of what happened when I handed real production tasks to AI agents, what broke, and which jobs I pulled back to run myself.
Video SOPs rot faster than written ones
Why a screen recording of your process goes stale in weeks while a written standard operating procedure survives interface changes. What actually breaks and how to structure both.
What I never paste into a chat window
An operator's working rules for AI data privacy: what never goes into a cloud chat window, why, and how local models and agent tooling change the calculus.
When a platform suspends you with no appeal
What actually happens when a cloud AI platform, API provider, or hosting account gets suspended with no appeal path, and how to build automation that survives it.
When two of my automations fought each other
A concrete walkthrough of how two unrelated automations ended up undoing each other's work, why it took a while to notice, and what actually fixed it.
Where the free tier is actually enough
A practical look at which free AI tools hold up under real, daily use and where the limits force an upgrade.
Which alerts I muted and what it cost
A concrete account of alert fatigue in a production AI automation stack: which alerts got muted, why it felt reasonable at the time, and what broke as a result.
Who Maintains the Code an AI Wrote?
AI can generate working code in seconds, but someone still has to own it long after the prompt is gone. Here's what maintaining AI generated code actually looks like in production.
Why I dictate more than I type
An operator's honest look at building a dictation workflow into daily AI automation work, including where voice beats typing and where it still falls short.
The AI advice everyone repeats that I think is wrong
Six AI positions I get argued with about, each grounded in something that broke in a business I run: a nine month old prompt that outlived two model swaps, and a ten step chain correct six times in ten.
What AI actually costs me in a month
Every voiceover I publish is synthesised on a free tier and costs nothing per call, while an annual plan I have never used runs until March 2027. Here is where the money in an AI-assisted business actually goes, sorted by how each cost behaves.
The automation I deleted (and why the business got better)
Nine scheduled jobs came off my servers last year and nothing broke. Here is how I decide which automation is an asset and which one is quietly costing me more than doing the work by hand.
I built a content pipeline that runs itself, and here is what broke
A dry run marked an entire publish queue as shipped in about eleven seconds without sending a thing. That bug, and four other failure classes, cost me far more than building the pipeline did.
Running AI on an eight year old GPU: what actually works
An 11GB GTX 1080 Ti is only about two times behind a current flagship at generating tokens, but five to ten times behind at reading your prompt. That gap decides what old hardware is good for.
Building A Weekly Report That Reads Itself Into My Inbox
How I built an automated weekly report pipeline that pulls my own data, summarizes it with an AI step, and lands in my inbox every Monday without me touching it.
How I Keep A Year Of Automation Logs Searchable
A practical breakdown of how I store, structure, and search a year's worth of AI automation logs without a cloud logging bill, using JSONL files and a small SQLite index.
How I Split Work Between A VA And An Automation
A practical breakdown of va versus automation: how I decide what goes to a human assistant and what gets handed to a script, agent, or local model.
How I Version And Roll Back My Automation Configs
A practical look at how I track changes to my AI automation configs with git, and the rollback habits that keep a broken workflow from becoming a lost afternoon.
What I learned running the same prompt across three model sizes
A practical look at comparing AI model sizes, from a small local model to a mid-size and large cloud model, and what changes as parameter count goes up.
Managing a Remote Virtual Assistant Across Time Zones
The rhythm and tools I use to manage a remote assistant across a big time-zone gap - async by default, a daily handoff, and judging outcomes over hours.
Running a Business From Anywhere With a Virtual Assistant Team
The real reason I can run my business from anywhere is not a laptop-lifestyle trick - it is a small, trusted remote team, systems, and letting go. Here is how.
How to Onboard and Train a New Virtual Assistant in a Week
My exact onboarding process for taking a new VA from day one to genuinely useful in about a week - scoped access, record-then-document, SOPs, and feedback.
How to Spot a Virtual Assistant Scam Before It Costs You
The real red flags when hiring a remote assistant, on both sides of the table, and the boring reliable way to protect yourself and the honest workers.
How to Write a VA Job Post That Gets Great Applicants
The exact anatomy of a virtual assistant job post that attracts great applicants instead of a flood of the wrong ones - specifics, pay, and a hidden filter.
OnlineJobs.ph vs Upwork vs Fiverr: Where I Actually Hire
I have hired real people on all three. They solve different problems. Here is what each is best for, the honest cost math, and a simple rule for choosing.
I Gave My Virtual Assistant My AI Tools: Here's What Happened
The popular take is that AI replaces virtual assistants. I did the opposite - I gave my assistant my AI tools. Here is how the combination actually works.
What to Delegate to a Virtual Assistant (and What I Never Would)
A practical delegation playbook - the delegation audit, the first tasks I handed over, how to hand a task over so it sticks, and what I keep for myself.
How Much to Pay a Virtual Assistant (Real Numbers From My Experience)
What I actually pay my virtual assistants, with real ballpark ranges, how I structure pay, and why paying fairly is also the smart business move.
How to Hire a Virtual Assistant on OnlineJobs.ph (My Exact Process)
The exact step-by-step process I use to hire great Filipino virtual assistants on OnlineJobs.ph - the job post, filtering, a paid test task, the interview, and paying fairly.