RimaruBook a call

How I use AI to do real work

Skills, workflows and automations I built, and the board I drew for each one.

Three words I use

A skill is a set of instructions an AI follows for one kind of job, like adding an order or building an ad.

A workflow is several steps with a check between each one, so nothing moves on until it passes.

An automation is something that runs on a schedule without me.

Skills

Testing a way of working before trusting it

I spent a month watching AI fail the same way, and I kept guessing at fixes, changing three things at once. So I thought, okay, what if every fix is an experiment? I write the pass line first, test it with fresh chats and reviewers who can't see the answers, and change one thing at a time. A no-AI checker caught 93% of planted defects in 13s with 0 false alarms.

Skills · PortfolioTesting a way of working
Saved
Use it
The picture of the skill’s instructions. Edit either one; the other updates, and a person reviews the change.Instructions

Testing a way of working. The steps in order:

  1. Start: Repeated AI failure. It starts when AI keeps failing the same way. Instead of guessing at fixes, I go looking for the cause.
  2. Diagnose from chat records. I go back through the chat records and diagnose in rounds. The fix has to come from evidence, not a hunch.
  3. Write hypotheses. Each possible fix becomes a hypothesis, with its pass line written down before any test runs. That way I can't move the goalposts after I see the result.
  4. Test with blind reviewers (Claude). Fresh chats do the work and blind reviewers score it against answer keys they can't see. Anything a plain program can check gets moved out of the AI step.
  5. Decision: Every hypothesis judged?. I keep going until every hypothesis has a verdict, and "not reproduced" counts as one. Those stay in the log, because a method that only reports wins isn't worth much.
  6. End: Method adopted or dropped. The fix is adopted or dropped based on what the tests showed. The methods that make it now sit underneath my other design and build processes.
  7. Change one thing. If a hypothesis is still open, I change one thing and test again. Changing three things at once means never knowing which one helped.

Running operations by chat

To add an order or check a vendor payout, I had to re-explore the backend every single time. So I started asking in plain words, and the AI shows me the numbers first. Now every change is a dry run, then I confirm, then it reads the record back from live data. I ask in one sentence, and nothing goes live without a preview.

Skills · PortfolioRunning operations by chat
Saved
Use it
The picture of the skill’s instructions. Edit either one; the other updates, and a person reviews the change.Instructions

Running operations by chat. The steps in order:

  1. Start: Plain request (Owner). I ask in plain words, like adding an order, making a discount code or checking a vendor payout. The know-how is already packaged, so nobody re-explores the backend each time.
  2. Dry run, show numbers (Claude). Every write runs as a dry run first and shows me the numbers. For ads, that's a confirmation table with every text variation in full.
  3. Decision: Owner confirms? (Owner). Nothing goes live until I've seen the preview and said yes. If it's wrong, it goes back to the request.
  4. Commit the change (Claude). Only after a yes does the change get made. Ad campaigns are built paused, so nothing spends money until I turn it on.
  5. Read back from live data (Claude). Afterwards it reads the record back from the live data to prove the change landed. For ads, it shows what I asked for against what actually landed.
  6. End: Verified result. The result is a change that's been checked against the live record, not just reported as done. One sentence in, one verified change out.
  7. End: Live data. The live business records: orders, discount codes, vendor payouts, finance summaries and site languages. Every change is read back from here, not taken on trust.

Packaging a system for someone else

A system only I can run isn't much use to anyone else. I wanted another person's AI to be able to rebuild it for them, after asking a few questions about their situation. It asks first, writes a blueprint, and the person confirms it before anything gets built. 8 skills are packaged this way, and the same ones run on both my computers from one synced folder.

Systems · PortfolioPackaging a system for someone else
Saved
Use it
This is the master. Each package built from it becomes a copy for one new person.Copies

Packaging a system for someone else. The steps in order:

  1. Start: A working system. It starts with a system that already works for me. The point is to hand it over so another person's AI can rebuild it for them.
  2. Ask a few questions (Claude). Before anything is built, the AI asks the new person about their situation and their problem. That way the result fits them and doesn't just copy my setup.
  3. Write the blueprint (Claude). The answers become a blueprint: what the system needs to solve, what it covers and what shape it should take. Nothing gets written until that's settled.
  4. Package as one file. The finished system is zipped into a single file the new person can upload. It travels as one piece instead of a folder of parts.
  5. Decision: Another AI rebuilds it?. The test is whether someone else's AI can rebuild it from the package. If it can't, it goes back to the questions.
  6. End: Fits the new person. The new person ends up with a version that fits how they work, not a copy of mine.
  7. Note: The person confirms the blueprint first.. Nothing gets written until the person says yes to the blueprint. The design is a conversation, so it's paid for once, up front, not on every run.

Workflows

Redesigning a product

On Vizi, my AI chats lost memory 115 times, and most of my "I told you before" moments came from that. So I moved the truth out of chat and into files, set the rules before any page gets drawn, and had every page checked before I saw it. After I approve, it's built to match and handed over through issues. Blind receivers scored 7 of 7 from the issues and 2 of 7 from the first email.

Portfolio · BoardsRedesigning a product
Saved
Make plan

Redesigning a product. The steps in order:

  1. Start: Brief. Every redesign starts with a written brief. It lives in a file, not a chat, because long design work with AI loses memory and the truth has to survive that.
  2. Audit code or interview. For an existing product I audit the code. For a new one I run an interview. Either way I start from what's really there, not from guesses.
  3. Foundations and rules. The foundations and rules get approved before a single page is drawn. Every page after that follows them, and decisions are written down once so nobody argues them twice.
  4. Design pages, check each. Each page is designed, then checked automatically and audited blind before I see it. Problems get caught by the checks, not by me spotting them late.
  5. Decision: Owner approves?. I review the pages. If something's off it goes back to design, and only an approved set moves on.
  6. Freeze board. Once approved, the board is frozen. The build has one fixed target to match, so the design doesn't keep shifting under it.
  7. Build and test loop (Claude). The build matches the frozen board exactly, and a test loop keeps running until it comes back clean.
  8. End: Handover through issues. The handover to an engineer goes through written issues, not email. In my tests, blind readers knew what to do from the issues far better than from a first email.

Building to match the design

Wiring a design to real data is where the design gets lost, and AI will happily edit the design until a check passes. So now I bring the design in unchanged, measure it, and give one worker one item at a time, with a separate auditor checking each. Questions about the design come to me in a batch. It loops until the checks find nothing. 547 of 547 screens identical to the board.

Plans · PortfolioBuilding to match a design
Saved
Make plan

Building to match a design. The steps in order:

  1. Bring in and measure. The approved design comes in unchanged and I measure each part of it. From here on the design files are frozen, so nobody edits the look just to make a check pass.
  2. Build shared data first. The shared data and save pieces get built before any single item, with one owner per file. That way the workers building items don't trip over each other.
  3. Build an item (Claude). One worker takes one item and wires in real data and actions, with scripted user journeys running first. It never touches the frozen design, and design questions come to me in a batch.
  4. Build an item (Claude). Items get built side by side, one worker each. When an audit sends an item back, this is where it gets fixed, under the same rules.
  5. Audit each item (Claude). A separate auditor checks each item without seeing how it was built. It's not the builder marking its own work, so it catches what the builder missed.
  6. Decision: Zero issues?. If the audit finds anything, the item goes back to be fixed and audited again. The loop only ends when the checks find no issues.
  7. End: Item accepted. The item is accepted, with its screens matching the approved design. Then it's ready to hand over to my technical co-founder.

Auditing a codebase with AI

Technical risk in a live product is usually a feeling, not a list, and I wanted a list engineers could act on. So AI inspects the code and the infrastructure, each problem gets written down on its own, and they're ranked into stages. The engineers repair from the top. I direct it and decide the order. It became a ranked repair plan for the engineers.

Portfolio · BoardsAuditing a codebase with AI
Saved
Make plan

Auditing a codebase with AI. The steps in order:

  1. Start: Codebase to check. It starts with a live product's code and infrastructure. The risk in there is usually a feeling, not a list, and the point is to turn it into one.
  2. Inspect code (Claude). AI reads through the code and the infrastructure looking for problems, with me directing the work.
  3. Write down findings. Each problem is written down on its own. That way it can be tracked and argued about one at a time, instead of living in someone's head.
  4. Rank repairs. Findings are ranked by how serious they are and grouped into stages. I decide the order, so the engineers work from the top down.
  5. Engineers repair (Engineers). The engineers own the repairs and work through the plan from the top. I set the order, they make the fixes.
  6. Decision: Outcome verified?. When a repair lands, someone checks it actually did what it should. If it didn't, it goes back to the engineers.
  7. End: Record updated. Once a repair checks out, the record is updated. The list stays something engineers can act on, not a worry.

Spending AI only where it counts

Most recurring work is plain code, and running it through AI just burns tokens. Why not run the job on my own machine, and let the AI wake up only when a flag fires? The cheapest model that can do the job leads, and I clear its memory before it gets heavy. A build chat that let a no-AI checker do the checking used 30% fewer tokens with no false "done".

Portfolio · BoardsSpending AI only where it counts
Saved
Make plan

Spending AI only where it counts. The steps in order:

  1. Start: Recurring job. It starts with a job that repeats, like pulling data, syncing or moving files. Most of that is plain code and never needs a model.
  2. Decision: Needs reasoning each run?. The first question is whether each run needs real reasoning. If it doesn't, it shouldn't touch AI at all.
  3. Local scheduled job. The job runs on my own machine on a schedule, with no AI. It does the work and raises a flag when something looks off.
  4. Decision: Flag raised?. If nothing's off, the job just finishes. AI only gets called when the flag fires, so it never burns tokens on an empty queue.
  5. End: Done, near-zero tokens. The job's done for close to no tokens. Most of my recurring jobs end here without ever calling a model.
  6. AI step, cheapest model (Claude). When AI is needed, it gets the cheapest model that does the job and only what it needs to read. The strongest model is kept for the hard stuff.
  7. Clear memory. The chat gets cleared before it gets heavy. Long chats get expensive as they fill up, so each run starts fresh.

Two AIs, one checks the other

An AI that builds something will often tell you it's done, and I kept seeing "done" mean "I changed something", not "it works". So I had a different AI review it, against checks written for that change, and if it fails it goes back to the builder. A person still signs off. Independent review has sent real work back to the builder with fixes.

Portfolio · BoardsTwo AIs, one checks the other
Saved
Make plan

Two AIs, one checks the other. The steps in order:

  1. Start: Task assigned. Every task starts with what done should look like, written down. That's what the review checks against later.
  2. One AI builds (Claude). One AI does the work and writes down what it changed. It doesn’t get to just say it’s done.
  3. A different AI reviews (Codex). A different AI checks the work on its own, against the checks written for this change. It’s not the builder grading itself, so it doesn’t share the same blind spots.
  4. Decision: Passes review?. If the reviewer finds a problem, the work goes back to the builder to fix. Nothing moves on a promise.
  5. Person approves (Owner). A person looks at it and signs off. The AIs can check each other, but they don’t get the final say.
  6. End: Done and recorded. It’s marked done, with a record of what changed and who approved it. A daily brief tells my co-founder what’s live and what isn’t.
  7. Note: Nothing is signed off by the AIs alone.. This is the one rule the whole thing hangs on. Two AIs catch more than one, but the call stays with a person.

Programs check the AI

AI is good at judgement and unreliable at counting. In my tests, reviewers listed only 4 of 10 defects, even when I asked for one. So I split every check in two: a plain program counts the mechanical stuff, and the AI only judges what needs judgement. Look checker: found 6 of 6, 0 false alarms. The old checker found 2 of 6.

Skills · PortfolioPrograms check the AI
Saved
Use it
The picture of the skill’s instructions. Edit either one; the other updates, and a person reviews the change.Instructions

Programs check the AI. The steps in order:

  1. Start: Work to check. Something's been built and needs checking. AI is good at judgement but unreliable at counting, so I don't let it be the only one checking its own work.
  2. Decision: Mechanical or judgement?. Every check gets split in two. Anything mechanical goes one way, anything that needs judgement goes the other.
  3. Plain program counts. A plain program with no AI checks the mechanical stuff, like layout, links, look and matching the design. It counts the same way every time and costs no tokens.
  4. AI judges (Claude). The AI handles what needs judgement, like whether a page makes sense to a client. That's the part it's actually good at.
  5. Plant defects to test checker. Where I can, I test the checker before trusting it. I plant mistakes on purpose and see how many it finds and how many false alarms it raises.
  6. End: Verdict with evidence. The result is a verdict with evidence behind it, not a confident "done". In my tests, chats with these steps made no false "done" claims.

Automations

A live copy of my data

My dashboards disagreed with reality. Analytics showed zero purchases, and the payment processor only sees the payments that succeed. So the database itself became the source of truth. I set up a live copy of it, defined an order once, and now every dashboard reads from that copy. It also showed me three traps I'd never have spotted.

Map · PortfolioOne live copy of the data
Saved
Make plan

One live copy of the data. The steps in order:

  1. End: Production database. This is where real orders live, including cancellations, orders paid another way and abandoned checkouts. Web analytics and the payment side only ever see part of that.
  2. Continuous copy. A copy of the production database sits in a warehouse and changes as the live one changes. It's always on, so every report reads the same up-to-date records.
  3. One definition of an order. An order is defined once, in one place, and every report uses that definition. Orders, revenue and attribution all get counted the same way.
  4. Dashboards. Every dashboard takes orders, revenue and attribution from the copy. That includes the marketing and sales dashboard I share with my co-founder and the monthly investor report.
  5. Other analytics tool. Web analytics only covers the part of the funnel it can actually see. Orders and revenue come from the copy, not from here.
  6. Note: If tools disagree, the copy wins.. When a tool's numbers don't match the copy, the copy wins and the gap has to be explained. That's how it caught revenue being added across currencies and test traffic inflating checkouts.

A job search that runs overnight

Searching for a job by hand is slow, and most of it is finding roles and checking they're still open. So I did the search by hand once, then built it. Overnight it finds roles, screens them, checks they're live and finds a contact. In the morning an AI applies, using only facts from one master document. It applies to 20 a day, and it gets more interviews than applying by hand.

Portfolio · BoardsA job search that runs overnight
Saved
Make plan

A job search that runs overnight. The steps in order:

  1. Start: Overnight sourcing. Overnight, a local job finds roles and removes duplicates. It runs on a schedule with no AI, so the slow part happens while I sleep.
  2. Screen and check live. Roles I can't take get screened out, and each one is checked to make sure it's still open. Nothing goes forward to a dead posting.
  3. Find verified contact. For each role it looks for a verified person to write to, where one exists. Finding who to contact used to eat most of the time.
  4. Apply from master document (Claude). In the morning, an AI step does the applying. It works only from one master document of my real experience.
  5. Decision: Fact in master document?. Every claim has to be in the master document. If it's there, it can be used. If it isn't, it can't.
  6. End: Tracker updated. Each application gets logged in the tracker. I did the search by hand once, then built this so I wouldn't have to do it twice.
  7. Note: Left out, never invented.. If a fact isn't in the master document, it's left out of the application. The AI doesn't get to make up experience I don't have.

The rest of what's running

Skills

  • Writing in my own voiceDrafts anything I send as me, with hard rules and a check before it's done.
  • Designing a new skillWorks out the problem with me first, then decides whether it should be a skill at all.
  • Writing project instructionsWrites the instructions that tell an AI project how to think about its job.
  • Writing issues for engineersHolds how my engineering tracker is set up, so every issue gets written the same way.
  • Picking up where I left offReads the open items from every place I work and asks which one to resume.
  • Reviewing social commentsShows one comment at a time with a draft reply, and posts only after I approve.
  • Reading and editing boardsLets an AI read and edit my Vizi boards safely.

Workflows

  • A growth experiments queueSplits each experiment into work for coding agents and work for research agents, and pulls it from the tracker every hour.
  • Search landing pagesBuilds landing pages for gift occasions and cities with plain code, so it costs no tokens.
  • One setup on two computersKeeps the same AI setup on my laptop and my mini PC from one synced folder.
  • One page of everything still openRebuilds a single board of open items across the business from my pending lists.

Automations

  • Social comments inboxPulls comments from social and ads into one inbox every three hours, and replies go out only after I approve.
  • Business numbers dashboardPulls numbers from analytics, ads and sign-ups into one dashboard every six hours.
  • Affiliate sign-upsTurns affiliate sign-ups into outreach rows every morning.
  • Daily site checkChecks the site every day on my own machine, and wakes an AI only when something looks off.
  • Weekly receipt scanSearches both my inboxes for receipts every Monday and writes the report.
  • Queue gateLets an hourly AI worker stop at once when there's nothing waiting for it.
  • Shared sales and marketing viewGathers the sales and marketing numbers into one view for both co-founders.
  • Inbox sortingSorts new email into labels using AI, as it arrives.
  • Control panel for scheduled jobsA page on my computer where I can see, pause and run every scheduled job.
  • Twice-monthly skill reviewTwice a month an AI lists my skills and we decide which ones to keep.

Want to tell me what challenges you're facing?

Testing a way of working before trusting it

The problem

A month of design work with AI kept failing in the same ways. I was guessing at fixes, changing three things at once and never knowing which one helped. The rule I wrote down was simple: don't guess fixes, find the causes from evidence. This skill turns that rule into a routine I can repeat on any AI failure.

How it works

I start from the chat records and diagnose in rounds. Each fix becomes a hypothesis with a pass line written before any test runs. Fresh chats do the work, and blind reviewers score it against answer keys they can't see. I change one thing per version, and anything a plain program can check moves out of the AI step. I stop when every hypothesis has a verdict.

Results

  • Diagnosed in 3 rounds, tested in 7 versions: "All 16 hypotheses got a verdict".
  • A no-AI checker caught 93% of planted defects in 13s with 0 false alarms.
  • A build chat that let that checker do the checking used 30% fewer tokens with no false "done".

What it costs to run

The whole first investigation cost about 5% of weekly usage. After that, each worker run costs about 1% of weekly usage plus its audit. Every fresh chat starts 13 to 14% full, so I plan around that.

Where I used it

It came out of the Vizi design rework. It now sits underneath my other design and build processes, including the redesign and build-to-match workflows.