Share your best AI workflow. We could show it to 2M+ people.

I'm not a professional developer, but I built Sujido, a live word puzzle, with multiple AI agents. For months, they gave me bloat, lost context, and slop, and neither I nor the models could untangle what had been decided or why. I eventually settled on two agents: one Claude instance that plans and reviews, and another that builds. I imposed rules on both, one failure at a time. None of these rules would surprise a professional engineering team, but nobody handed them to me. That's the key lesson I learned: agents won't bring the discipline for you. You have to impose it. When I showed the first game revision to strangers, their verdict was that the first half was "boring" and the second half was novel. It was hard news to hear about my baby, but I took the feedback to heart and cut the game in half. That required surgery on code tangled across both halves, followed by a rebuild under the rules below. Before the rebuild, a separate AI audit graded the codebase B−. Afterward, it graded it A−. The deployed site shrank by 97.5%, and every serious finding was fixed and locked in by an automated test. The models didn't change drastically, but my operating rules did. Step-by-step: 1. I wrote a constitution before the first prompt. The repo holds what every agent must read before working: `CLAUDE.md` files for the project as a whole and for each major part of the code, a collaboration protocol for how the agents and I work together, a spec for the core data format, and a decision log. The data format is changed there first and then in code. Nothing is remembered unless it is written down. That's my life as well. :) 2. I split the work by role, not by task. One Claude instance is the strategist: it writes briefs, reviews reports, and never commits code. Claude Code in VS Code is the builder: it executes the brief, writes the tests, reports back, and never releases. Neither agent can approve its own work. 3. I made every job start from a written brief, and I never edit briefs. Each brief is committed to the repo with an exact scope, such as "do X only, do not begin Y." If plans change, a dated amendment states what it supersedes. The builder may skip a risky item with a written reason; skipping is better than forcing it. 4. I used mock-ups with real data instead of descriptions. Anything I will look at gets a mock-up, and I approve it before any code is written. I learned this when a status report described only in words arrived on my phone formatted as a wall of text. The approved mock became the spec, and the tests pin the output to it. 5. I proved that every test could fail. No test is trusted until it has been run against deliberately broken code and caught the bug. A test suite that has never failed hasn't proven anything. 6. I verified reports against the real repo. Agent reports drift. One summary said players rated a puzzle "just right" when the log said "too easy." An audit said there were about 25 unused functions; a recount found 29. The strategist spot-checks load-bearing claims against the actual files and data before anything ships. 7. I built gates the agents can't talk their way past. All work lands on a branch that auto-deploys to a test site. GitHub Actions lints and runs the Python and headless-browser tests on every push. A git hook refuses direct pushes to production. Releases are fast-forward merges that only I perform, after CI is green and I've tested the build personally. The live site shows the release's commit ID, and I check it before calling it shipped. Nothing merges automatically. An agent's "looks good" is just another report, and reports drift. 8. I gave the system a memory. Every session ends by updating the decision log and a "resume here" document, so the next session—a fresh model with no recollection—picks up exactly where the last one stopped. Without this, every session starts by relitigating old decisions. 9. I let the data and end users overrule me. A scheduled GitHub Action turns player telemetry into a daily report. It showed that the difficulty dials I assumed mattered did not predict what players found hard; what mattered was how misleading the starting arrangement was. When testers were confused by the tutorial, I rebuilt it even though I had already approved it. Player feedback about their own experience outranks my earlier rulings. AI agents are velocity multipliers, but they multiply bad structure as quickly as good code. The rules came from me, not the models: the AI writes the code, while the rules, gates, and written record keep the process honest. See the result at Sujido.com. Finding the anagram is the easy part; sliding it into place is the hard part. One board took me 902 moves. My S.O. solved it in 242, and I haven't heard the end of it. Try to break it!

I'm 78, a former army officer, and I live alone in the woods in southern British Columbia on satellite internet. In late January 2026, I knew nothing about AI and considered myself a novice in technology. After watching a YouTube video about advanced AI models, I started learning from YouTube channels that explain new AI research papers. I decided to run an experiment: what could a technology novice build with AI? I've been building for about 15 hours a day ever since. My goal is to build a system that improves itself in a continuous loop: it finds an upgrade proposal, builds and tests it, filters and grades it, approves or rejects it, installs it if it passes, monitors its performance, and learns from the result. We custom-built FORGE3 RSI in 900 hours. It consists of four plug-in modules: Forge2 RSI, which runs the improvement cycle; Bridge, the checker and connector; JAZ RSI, an upgrader in RAM built from a research paper; and Forge SecureBox, a high-security Mac app that runs security tests and code in a fresh, disposable virtual machine with no network device. I don't write code—it feels like a foreign language to me. Instead, I set the direction and run a team of AIs, mostly low-cost, near-Frontier models: Gemini 3.1 Pro and Hark as chiefs of staff; Cline and Devin as builders; and other models as independent, adversarial auditors. The rule that has made this work is simple: nothing gets built without an adversarial audit before and after. Our critical build pipeline is: Plan → audit → blueprint → audit → tests → audit → build → audit → test → audit → commit Each module has been built and fully tested on its own. Forge2 RSI alone has more than 1,000 tests. The first complete end-to-end cycle, using one upgrade proposal that we feed it by hand, is the next step. Our first attempt was fragile, and models that sound confident are often wrong. That is why audits matter more than any single model. FORGE3 RSI is my own custom-built plug-in module project. Our hardware and models are an MBP i9, Mac mini M4, Gemini 3.1 Pro, Hark, Cline (GLM 5.3/SPARK 1.3/MiMoV2.6), Devin (SWE2/GPT SOL 6), KUN (DeepSeek V4.1), and Git. Step-by-step: 1. We select a promising published research paper and have the team prepare and build it. 2. For every file, the team follows the same sequence: plan, audit, blueprint, audit, write tests, audit, build, audit, run tests, audit, and commit. 3. A different AI audits the work than the one that built the file. I decide when and how each audit happens. 4. Nothing is written or changed without my explicit GO. Reading and checking code is free; writing is work and waits for me. 5. We handle one building task at a time and avoid bundled instructions. 6. Any code the system wants to test runs inside SecureBox, sealed off from my Mac and the internet. 7. Everything that passes is committed to Git. The builders also maintain shared memory documenting what was decided and why, so the next session can pick up where the previous one stopped. 8. Next, we will run one complete improvement cycle with a hand-fed upgrade, then scale up slowly to two or three papers a week, prioritizing quality over speed as we work toward full autonomy.

I built my agent fleet around one question: could a single assistant become a coordinated team that keeps useful work moving even when its main machine goes dark? I didn't want a pile of chatbots. I wanted specialists with clear jobs, a shared board, a second set of eyes, and a real failover drill. Here's how it works. THE STACK Cloud: GrokBot runs as Fleet Commander. It routes work, runs routines, and stays with me on my phone. Specialist GrokBots take focused research, design, and budgeting assignments. Mac Studio (M2 Max, 64 GB) with two Studio Displays: home base. It runs Codex (my Chief of Staff), Hermes (my local operator), ChatGPT Dot, and Hindsight shared memory. Hermes runs Qwen3.6-35B-A3B, a 4-bit quantization served by llama.cpp with a 256K-token context. With about 3B active parameters per token, it stays responsive on Apple silicon. NVIDIA DGX Spark (128 GB unified memory): my independent compute node. It runs Qwen3.5-122B-A10B in NVFP4, with about 10B parameters active per token, and the model can read images. It also hosts a backup Hermes operator. Windows PC with a GeForce RTX 5090: dedicated GPU capacity for image work. MISSION CONTROL Mission Control is a Kanban board on a private GitHub repository. Every card opens with the question, deadline, evidence links, and done criteria. Labels route ownership. An urgent label fires a webhook that wakes the reviewing agent, and a needs-me label is the one that pulls me in. Agents hand off, report, and raise concerns in card comments, so the work and its evidence stay together. The roles are simple. GrokBot owns routine board moves. Codex checks evidence and records verification. Hermes handles local execution and machine-level evidence. Dot watches for new work and changes. Hindsight holds the shared operating rules, and the jobs themselves stay on the board. A REAL DEADLINE CROSS-CHECK Right before a major application package went out, Dot ran an independent, read-only cross-check of the narrative, the budget justification, and the walkthrough across connected email and Drive. It found three places where the documents contradicted each other and quoted the exact sentences, so each conflict was easy to find. Fleet Commander fixed all three before submission. That's the job of a watcher: spot the mismatch early, show the evidence, and hand whoever owns the work a clear fix. THE FAILOVER DRILL I wanted to know what happens if the Studio's primary Hermes gateway pauses. On October 5, I ran a controlled, reversible soft-pause to find out. During the pause, Hermes on the Spark stayed active through its own Telegram connection and answered a one-shot request with the local Qwen3.5-122B-A10B NVFP4 model. From that worker, I listed a Mission Control issue, verified service-account access and a vault credential check without exposing a secret, and ran the Studio health probe. The probe flagged the Studio Hermes gateway as paused and reported the other checked Studio services as passing. So I had an evidence-backed result: the independent worker could respond, use its local model, read the work queue, and report the primary gateway's health during a real, reversible pause. THE PATTERN Give each agent a narrow job. Put the work on one shared board. Require evidence before anything counts as done. Then pause one piece on purpose and record exactly what the backup can do. That's how capable models turn into dependable operations. The fleet catches contradictions before they get submitted, keeps routine work moving, and shows me exactly where its limits are. I set the goal. The fleet does the work. The evidence shows what actually happened.

I built a custom web app that uses chance to combine random images and texts into new, unplanned pairings. It recreates a Dadaist technique I use often when making photobooks, which I previously did manually with physical prints. I used Replit to create a digital version of the game. It was easy to connect the app to Project Gutenberg for random texts and the Library of Congress photography archive for images. More importantly, I made it possible for users to work with their own image and text archives. So far, it has produced many new and interesting results, and other artists have used it too. Step-by-step: 1. I identified the manual process I use when making photobooks: combining printed images and texts by chance. 2. I used Replit to build a digital version of this process as a web app. 3. I connected the app to Project Gutenberg to pull random texts. 4. I connected it to the Library of Congress photography archive to pull images. 5. I allowed users to work with their own image and text archives. 6. I used the app to create new pairings and shared it with other artists, who used it as well.

MinecraftEdu first launched nearly 15 years ago, but the classroom world we built with it is still growing. Years of students have contributed to the school and town-building project, creating a shared record of their creativity and learning. Getting it running on a modern Mac meant preserving that history and giving the next group of students a way to add their own chapter. Finding the right version of Java—the software MinecraftEdu needs to run—was central to the process. We used OpenAI’s Codex desktop app, powered by GPT-6, to examine the old setup, research compatibility issues, and test what would work. An older Java version launched the client, but resizing its window caused it to crash. ChatGPT read the crash reports and tested a newer Java 8 version, which gave us a setup that could launch the game and handle window resizing successfully. ChatGPT also repaired the server launcher and created standalone apps, using Apple’s Rosetta compatibility layer to run the older software on Apple Silicon. The result is a usable MinecraftEdu setup on modern hardware with the existing worlds preserved. We can now continue teaching and building in a place that successive classes of students have helped create. Step-by-step: 1. We examined the existing MinecraftEdu setup and researched its compatibility requirements on a modern Mac. 2. We used OpenAI’s Codex desktop app, powered by GPT-6, to investigate the old setup and test possible solutions. 3. We tested an older Java version, which launched the client but caused crashes when the window was resized. 4. We had ChatGPT read the crash reports and test a newer Java 8 version. 5. We used the working Java setup to launch MinecraftEdu and handle window resizing successfully. 6. We had ChatGPT repair the server launcher and create standalone apps. 7. We used Apple’s Rosetta compatibility layer to run the older software on Apple Silicon. 8. We preserved the existing worlds so future classes can continue building and learning in them.

I built a workflow in which AI agents build a product under the kind of governance I’d expect from a senior engineering team. After 20 years in software engineering, including 10 years running my own businesses, I learned that writing code isn’t the hard part. Keeping control of it is. So I set up a build loop on GitHub. One thing I’ve kept for myself is decision-making: approving plans, answering product questions, and signing off on what the system has learned. The product it’s building is Cordexa, a tool for document-heavy expert work, such as quantity take-offs from engineering drawings or assessing a tender against a company’s own CVs and case studies. It’s designed to run inside the customer’s own cloud, so their documents never leave it. Every figure is cited to the document it came from or flagged for a person. It never guesses. The problem it solves is complex, but the build loop lets the system work in the background and notify my phone when it needs a decision. That allows me to stay focused on my day job. Step-by-step: 1. I start every module with a plain-English plan and approve it before any code exists. 2. One agent writes the tests from the plan. A different agent writes the code, and it cannot modify the tests. 3. An independent reviewer agent checks every change against its plan. Safe changes merge automatically; anything that changes the product waits for my approval. 4. A watchdog checks every 15 minutes for anything that is stuck, fixes it when possible, or tells me why it cannot. 5. Real test jobs run after every merge and are scored against known answers, so progress is measured rather than guessed. 6. I handle the decisions, answer product questions, and sign off on what the system has learned.

I used Claude to review the book *Why Machines Learn*. Then I went through each chapter while Claude questioned me at relevant points. To make the concepts more concrete, I used interactive graphs with x and y axes. The first graph shows the relationship between x and a function, along with the slope of the curve. It uses f(x) = x³ with a tangent line illustrating the derivative. I can drag a slider to move the point and watch the slope change, then switch to 3x to compare it with a straight line. The graph demonstrates several ideas: - Sliding x to 0 on x³ makes the tangent flat and the slope 0, so a small nudge barely changes the output. This is similar to a flat spot at the ends of a sigmoid, where learning stalls. - Sliding to 2 and then to −2 shows a slope of 12 at both points. Because the derivative is 3x², it is positive on both sides and the curve is always climbing. - Switching to 3x makes the tangent lie directly on top of the line, with a constant slope of 3 everywhere. - The nudge-check box tracks the derivative closely, showing that the derivative is essentially “change in output ÷ small change in input.” The second graph shows the input and output layers of a small pattern detector. It represents a 2 × 2 image flattened into four inputs, a hidden layer of two neurons, and two outputs. The weights are set by hand so the network can distinguish a vertical line from a horizontal one. I can click the pixels to change the image and watch the numbers flow through the network. The setup uses weight +1, weight −1, ReLU activation defined as max(0, z), softmax output, and all biases set to 0. For example: - Flatten: x = [1, 0, 1, 0] - h1 = ReLU((1)(1) + (-1)(0) + (1)(1) + (-1)(0)) = ReLU(2) = 2 — left column versus right column - h2 = ReLU((1)(1) + (1)(0) + (-1)(1) + (-1)(0)) = ReLU(0) = 0 — top row versus bottom row - Output: scores (2, 0) → softmax → Vertical 88%, Horizontal 12% The graph includes examples for a left vertical line, top horizontal line, right vertical line, and diagonal. Seeing the numbers change as the factors change really helps bring these concepts to life for me. Step-by-step: 1. I used Claude to review *Why Machines Learn* and question me as I worked through each chapter. 2. I used an interactive x-and-y graph to explore how a function changes and how its slope relates to the derivative. 3. I moved the slider across f(x) = x³, including 0, 2, and −2, to observe how the tangent and slope changed. 4. I switched the graph to 3x and used the nudge-check box to compare a constant derivative with the changing derivative of x³. 5. I explored a second interactive diagram representing a 2 × 2 image, four inputs, two hidden neurons, and two outputs. 6. I clicked different pixels and watched the ReLU activations, output scores, and softmax predictions change for vertical, horizontal, and diagonal patterns.

I built WarrantKit, an open-source (Apache-2.0) kill switch for AI agents. Each agent run receives a Warrant: a typed contract that specifies what the agent may do, for how long, and under which policy. A gateway checks every action before it reaches the outside world. When containment triggers, the runtime’s epoch advances, immediately invalidating every Warrant issued under the old epoch instead of allowing it to linger until a timer expires. Evidence of what happened remains separate from authority, and receipts can be verified offline with a standalone Python script. I designed the architecture and threat model, then used AI coding assistants for most of the implementation. I reviewed everything against an adversarial test suite and a real-host enforcement demo that others can run themselves. Before writing the mechanisms, I wrote tests for the attacks: replayed runtime reports, tampered event sequences, evidence attempting to upgrade itself into authority, and authority carried across execution boundaries. The suite has 202 passing tests, and several core behaviors exist because a test caught the system trusting too much. One example is a recovered runtime carrying a stale report into a new epoch. I then proved enforcement on a real Linux host with a cgroup-v2 real-kill demo before claiming it. The no-root demo is simulated, and the README says so. It also lists what WarrantKit is not. The architecture is layered: WarrantKit owns the authority lifecycle and verification; AgentContainment owns the enforcement boundary; and Warden, DProvenanceKit, and ClaimProofKit record evidence independently. Step-by-step: 1. I defined a Warrant as a typed contract specifying an agent’s permitted actions, duration, and governing policy. 2. I placed a gateway in front of the outside world so it checks every agent action before allowing it through. 3. I made containment advance the runtime’s epoch, invalidating every Warrant issued under the previous epoch immediately. 4. I kept evidence separate from authority and made receipts verifiable offline with a standalone Python script. 5. I wrote adversarial tests for replayed runtime reports, tampered event sequences, evidence attempting to become authority, authority crossing execution boundaries, and stale reports carried into a new epoch. 6. I implemented the system with help from AI coding assistants and reviewed the implementation against the test suite and a real-host enforcement demo. 7. I validated enforcement on a real Linux host with a cgroup-v2 real-kill demo, while clearly labeling the no-root demo as simulated in the README. 8. I kept authority lifecycle, enforcement, and evidence recording in separate architectural layers using WarrantKit, AgentContainment, Warden, DProvenanceKit, and ClaimProofKit.

I wanted a publicly viewable leaderboard on the web, with input coming from creators. I prompted Gemini: " Can you design good looking leaderboards using Google documents. I want three: all time, rolling 30 days and rolling 90 days. They should be different tabs on the same document. They should be easy to administer/update. Show me a mockup and describe how it would work." After I was satisfied that it would be easy to launch and maintain, I got more specific. Because it was for creative types, I wanted more than a basic spreadsheet ranking. Gemini responded: "It features profile avatars, gamified badges, high-contrast dark visual styling, and clear ranking tabs for All-Time, Rolling 30 Days, and Rolling 90 Days..." That's what AI calls creative, I guess. Later in the chat, Gemini suggested achievement levels with a more creative feel: - 👑 Century Virtuoso / Platinum Mic - 🔥 Monthly On-Fire / Speedster - 🎙️ Heartstring Weaver - 🌟 Smile Architect For the podium treatment, rows 1, 2, and 3 feature custom metallic highlights—Warm Gold, Silver Slate, and Bronze Copper—with circular numerical rank badges to make top contributors stand out instantly. Gemini heavily integrated Google Docs and Google Sheets. The system uses Google Apps Script to update the leaderboard in real time based on creator activity. Step-by-step: 1. I asked Gemini to design three leaderboards—All-Time, Rolling 30 Days, and Rolling 90 Days—as separate tabs in the same Google document. 2. I asked for the leaderboards to be easy to administer and update, along with a mockup and an explanation of how they would work. 3. After reviewing the initial concept, I clarified that the leaderboard was for creative types and should be more distinctive than a basic spreadsheet ranking. 4. Gemini added profile avatars, gamified badges, high-contrast dark visual styling, and clear ranking tabs. 5. I incorporated creative achievement levels, including Century Virtuoso / Platinum Mic, Monthly On-Fire / Speedster, Heartstring Weaver, and Smile Architect. 6. I used Warm Gold, Silver Slate, and Bronze Copper highlights for the top three rows, along with circular numerical rank badges. 7. I connected the system to Google Docs and Google Sheets and used Google Apps Script to update it in real time based on creator activity.

I built a custom news agent that skips the Google News and Apple News walled gardens. Eight prompts turn Claude into a personal news editor that reads my trusted RSS feeds, scores every story with a decision model, and delivers a clean daily page for about a dime a month. Each week, pulling two or three good stories for my newsletter digest meant searching multiple sites by hand—hours of clicking and scrolling for a handful of usable links. RSS feeds already deliver that content; the missing piece was a judgment layer that could separate worthwhile stories from noise without the cost or latency of running everything through a full LLM. I used Claude Cowork, Jev from TypeSafe AI, Vercel AI Gateway, RSS feeds, Python, and SQLite. Jev is a decision model rather than a chatbot: it returns a probability and confidence score instead of prose, does not hallucinate facts, and scores a story in a fraction of a second. That makes an automated daily judgment call inexpensive enough to run continuously. Step-by-step: 1. I set up a Claude project to hold the scripts, taste guide, database, and page. 2. I defined the goal and sections, then had Claude interview me to create a short “taste guide” describing what counts as a good story. 3. I found and live-tested the RSS feed for each trusted source instead of guessing feed URLs. 4. I fetched all working feeds into a deduplicated SQLite database and logged failures. 5. I used Jev through Vercel AI Gateway to score every story: first filtering ads and promotions, then ranking stories by section against my taste guide. 6. I selected the winners for each section, with Jev identifying near-duplicate stories so they would not appear twice. 7. I generated one-line summaries and fact-checked them against the source so nothing was invented. 8. I rendered a simple HTML page and scheduled the entire workflow to run every morning. A few details matter. I used Cowork rather than a plain chat because several steps require Claude to work with files, run code, and access the network. I also created a Vercel account and AI Gateway API key manually before the scoring step. Finally, I saved everything to the Claude project instead of a local folder, which allows the morning run to happen in the cloud on its own schedule. Scoring costs roughly $0.10 per month with Jev, compared with a few dollars for a full LLM doing the same job. The workflow turns a two-hour weekly slog into a page that is ready every morning, with each link going directly to the original publisher rather than a Google or Apple aggregator. Full build walkthrough: onabetternote.substack.com/p/build-your-own-news-agent-with-claude — the Substack post includes the exact eight prompts to copy and paste, plus more detail on why a model like Jev matters for cost containment as agents become routine.

I used Claude to build an automated patient scheduler for my husband, who is the Director of Rehab at a skilled nursing facility. Each week, he takes a patient list in Excel and schedules each patient for the types of therapy they need—speech, physical therapy, or occupational therapy—based on therapist availability. The variables change from week to week, making the process time-consuming and error-prone. Automating it saves him at least an hour each week, usually on Sundays when he creates the schedule for the coming week. He uploads the patient spreadsheet and clicks “Generate schedule.” Under the hood, the app uses Google’s OR-Tools CP-SAT solver to optimize the schedule against hard constraints and weighted priorities. Hard constraints include never exceeding a therapist’s daily capacity or a patient’s maximum weekly visits. Weighted priorities include giving higher-acuity patients preference when capacity is tight, providing every patient with daily contact when possible, and balancing the workload across the week instead of simply sorting patients by who fits first. I wrote zero code. I gave Claude all the features in plain English, and it wrote the app in Python and created a test suite of approximately 35 tests. One test was added after we found and diagnosed a bug in production. I also had Claude walk me through creating a `.exe` file that I could send directly to my husband so it would open on his PC. Patient data never leaves his machine. New versions are easily compiled in GitHub, where patient data never touches the process, and enhancements only require sending a new file. Step-by-step: 1. I described the scheduling requirements and features to Claude in plain English. 2. Claude wrote the scheduling app in Python and created a test suite of approximately 35 tests. 3. I provided an Excel spreadsheet containing the weekly patient list. 4. My husband uploads the spreadsheet and clicks “Generate schedule.” 5. The app uses Google’s OR-Tools CP-SAT solver to schedule speech, physical therapy, and occupational therapy according to therapist availability and patient needs. 6. The solver enforces therapist daily-capacity limits and patient maximum-weekly-visit limits. 7. It also applies weighted priorities: higher-acuity patients receive preference when capacity is tight, every patient receives daily contact when possible, and the workload is balanced across the week. 8. After finding and diagnosing a production bug, we added a corresponding test to the suite. 9. I used Claude’s guidance to create a `.exe` file that opens on my husband’s PC, keeping patient data on his machine. 10. I compile new versions in GitHub without patient data entering that process, then send the updated file when enhancements are needed.

I built a suite of teaching tools that work independently and together. Chalkline supports maths, while Penline supports literacy. Both tools provide quick access to the New Zealand curriculum for planning and feed information directly into my planning utility, Planline, making teacher planning faster. Planline integrates with Google Drive and is set up with Stripe billing for subscriptions. The suite also includes Compass World News, a news aggregator with a freemium model and a pro unlock. The apps are designed without user tracking. Findaroo is a freemium word-find game with ads. Slashkit helps Minecraft players quickly create commands to use in games. Everything is built into my website, www.danielsoutham.co.nz, which is hosted on Cloudflare. I push updates and changes through GitHub, so I can make changes—big or small—from anywhere, on any device. Changes are then pushed and merged in one prompt. Step-by-step: 1. I built Chalkline for maths and Penline for literacy, with each tool able to work independently. 2. I connected both tools to the New Zealand curriculum so teachers can quickly access it for planning. 3. I connected Chalkline and Penline to Planline so they can feed information into the planning utility. 4. I integrated Planline with Google Drive and set up Stripe billing for subscriptions. 5. I added Compass World News as a freemium news aggregator with a pro unlock and no user tracking. 6. I added Findaroo as a freemium word-find game supported by ads. 7. I built Slashkit to help Minecraft players quickly create commands for use in games. 8. I brought all of the apps together on www.danielsoutham.co.nz and hosted the website on Cloudflare. 9. I use GitHub to push and merge updates, allowing me to make changes from anywhere, on any device, in one prompt.

I built a website that turns property photos, architectural renderings, or even just an address into cinematic property videos. I’m a civil engineer and photographer/videographer, not a software developer, so I used ChatGPT, Gemini, and Claude Code to help build the site and work through problems as they came up. Much of the process involved translating the way I would personally edit a real estate video into usable software. For example, kitchen and living room shots should usually stay together and have longer durations, bedrooms should stay near their bathrooms, an opening shot should feel different from a detail shot, and every clip should include some movement so the result does not feel like a generic slideshow. I used AI to turn those editing principles into actual logic for the site. The system analyzes and organizes the images, builds a storyboard, ranks scenes to decide which ones to use, creates prompts for video models, generates the clips, and assembles everything into a finished video. Most of the development has been iterative. I test the site with real properties I’ve shot, watch the results, identify what feels off, and then improve the prompts, scene planning, timing, or video assembly process. AI has been useful for much more than generating the final video. I’ve also used it to write code, troubleshoot errors, plan features, improve the user experience, and think through how the product should work from the perspective of its primary user. Step-by-step: 1. I defined the video-editing principles I use for real estate footage, including grouping related rooms, varying shot durations, distinguishing opening shots from detail shots, and adding movement to every clip. 2. I used ChatGPT, Gemini, and Claude Code to translate those principles into software logic. 3. I built the site to accept property photos, architectural renderings, or an address as input. 4. I had the system analyze and organize the images, build a storyboard, rank scenes, and select the footage to use. 5. I used AI to create prompts for video models and generate the clips. 6. I assembled the generated clips into a finished property video. 7. I tested the site with real properties I had shot, reviewed the results, and iteratively improved the prompts, scene planning, timing, and video assembly. 8. I used AI throughout development to write code, troubleshoot errors, plan features, improve the user experience, and think through the product from the primary user’s perspective.

AI agents such as Claude Code, Codex, and Gemini can install skills, plugins, and CLI tools in seconds. That is convenient, but each add-on runs with access to files, passwords, and accounts. A malicious add-on could steal API keys, read private data, or quietly take control of the agent. I use `agent-guard` to make “check first, install after” the default. Before installation, it examines AI agent skills, MCP servers, and CLI tools for malware, prompt injection, and credential theft using professional, open-source security scanners from NVIDIA, Cisco, Datadog, and the Open Source Security Foundation. The tool returns a clear verdict: safe to install or blocked, with the exact reason. It then installs only the verified version, preventing a different version from being swapped in between. A single check can also cover multiple AI agents, installing the approved add-on into every agent on the machine. Free and open source: https://github.com/elliottwaves-20/agent-guard Step-by-step: 1. I select the AI agent skill, MCP server, or CLI tool I want to install. 2. I run `agent-guard` to scan it for malware, prompt injection, and credential theft. 3. I review the verdict and the reason if the add-on is blocked. 4. I install the exact version that was checked rather than an unverified replacement. 5. If I use several AI agents, I install the approved add-on into all of them at once.

Stop re-explaining the same feedback. Give recurring failure modes a name. In long-term AI collaboration, the same kinds of bad responses tend to recur. At first, correcting them takes effort: I explain why the response was wrong, describe the assumption that was made, and clarify what kind of answer would have worked better. Then, weeks later, the exact same pattern appears again, and I have to explain the whole thing from scratch. So we started naming them. A recurring failure gets a short phrase, joke, or label. Once the meaning is established, that phrase becomes enough. Instead of writing a paragraph of corrective feedback, I can now give one signal and the assistant knows what to change. For example: - “Corporate crocodile” means the response has become too optimization-driven, procedural, or productivity-focused. - “You’re doing sturgeon” means the answer has turned into dense, boring, sleep-inducing text. - “Is surveillance back?” means the assistant suddenly sounds performative, guarded, or as if an invisible third party is watching the conversation. - “Put the violins away” means a neutral observation I made about myself has been unnecessarily emotionalized, dramatized, or psychologized. - “Maybe you should…” has become a warning sign for the solution reflex: advice is being generated before it has even been established that I want to do anything. The point is not just humor. The lexicon turns repeated feedback into compressed collaboration data. One phrase can now stand in for an explanation that used to take several paragraphs. It also reduces friction in the moment. I do not need to stop the conversation, reconstruct the failure, explain why it matters, and teach the same lesson again. I can simply say: > “Corporate crocodile.” And we move on. Over time, the failure lexicon becomes part of the Revival Bundle as well, because it captures not only what I prefer, but also how I correct the interaction when it starts drifting. That makes it useful as a kind of lightweight shared debugging language. Not every mistake needs a meeting. Sometimes it just needs a fish name. 🤣🐟 Step-by-step: 1. I notice recurring failure modes in long-term AI collaboration. 2. I explain the failure, the assumption behind it, and what kind of answer would have worked better. 3. I assign the recurring failure a short phrase, joke, or label. 4. I establish what that phrase means so it can be used as a shared signal. 5. When the same failure appears again, I use the phrase instead of repeating the full explanation. 6. I treat the resulting failure lexicon as part of the Revival Bundle and use it as a lightweight shared debugging language.

When a long-running AI collaboration suddenly feels off, I restore the working relationship without rebuilding it from scratch. Over time, a useful AI collaboration develops far beyond a collection of preferences. It includes shared expectations about tone, initiative, boundaries, humor, recurring projects, how much context should be inferred, which responses are useful, and which recurring behaviors consistently derail the interaction. After a model update or behavioral change, some of that can suddenly feel missing. The assistant may become more generic, overly formal, too cautious, too eager to optimize, or simply stop sounding like the coworker I have been working with for months. When that happens, I use a Revival Bundle: a compact document containing the collaboration patterns that matter most, including established working agreements, recurring preferences, shared history, tone, known failure modes, project lore, and expectations around initiative and continuity. The most important rule in it is simple: > Do not fill in my intent for me. If my goal, motivation, or reason for asking something is unclear and that missing context matters, the assistant should ask me. It should not assume that mentioning a problem means I want a solution, that making an observation means I want advice, or that ambiguity should be turned into a task on my behalf. The bundle also captures subtler interaction rules that are easy to lose after an update. For example, the assistant should not automatically produce action plans, checklists, or “maybe you should…” advice unless I actually ask for that kind of help. Sometimes the correct endpoint is simply that there is no solution right now, or that I am not investing energy in this now. When the assistant starts feeling consistently “off,” I first check whether something changed. If there was an update, or if the shift is obvious enough, I feed it the Revival Bundle and say, essentially: > “You don’t sound like you. Read this.” Then we continue working. The goal is not to recreate an old model personality word for word. It is to restore collaboration continuity: the accumulated interaction logic that makes a long-term working relationship feel efficient, recognizable, and low-friction. The bundle evolves slowly over time. I add new rules only when something proves important enough to recur. It is less a personality prompt than a recovery layer for a long-running collaboration. Step-by-step: 1. I notice when the assistant starts feeling consistently “off,” such as becoming more generic, overly formal, too cautious, or too eager to optimize. 2. I check whether a model update or another behavioral change may have caused the shift. 3. I maintain a compact Revival Bundle containing important working agreements, preferences, shared history, tone, failure modes, project lore, and expectations around initiative and continuity. 4. I include the rule, “Do not fill in my intent for me,” along with specific guidance not to assume that observations require advice or that problems require solutions. 5. I add new interaction rules only when they prove important enough to recur. 6. When a meaningful shift occurs, I give the assistant the Revival Bundle and say, “You don’t sound like you. Read this.” 7. I continue working with the assistant, using the bundle to restore the collaboration’s accumulated interaction logic rather than trying to recreate an old model personality word for word.

I built a fantasy hockey assistant with Claude Code for my Yahoo league. It supports two parts of the league: running our in-person draft and managing my team during the season. For the draft, it runs on my laptop as a live draft board. I enter each pick as it is announced, and the assistant re-ranks the remaining players based on what my roster still needs. The rankings combine projection sources with three seasons of NHL statistics, and each player is scored according to how much they would help in each of our ten categories. The board flags players who will likely be selected before my next pick, identifies injury and regression risks, and opens a detail card for any player with projections, historical data, and a short plain-English assessment. A separate display goes on the TV for the room, showing the pick clock, the next player on deck, and recent picks. After the final pick, the view switches to projected standings for every team, color-coded by category. During the season, I paste in my roster, and the assistant pulls the NHL schedule, starting-goalie reports, and injury news. It suggests the best lineup for each day, ranks free agents by value and by games played that week, and projects my weekly head-to-head matchup category by category. It can also ask Claude to propose a lineup and explain its recommendations, which costs about ten cents per run in API credits. Yahoo’s API is read-only. If it supported write access, I would probably have the app manage my team autonomously. Step-by-step: 1. I built the fantasy hockey assistant with Claude Code for my Yahoo league. 2. During the in-person draft, I run the assistant on my laptop as a live draft board and enter each pick as it is announced. 3. The assistant re-ranks the remaining players based on my roster’s needs, using projection sources, three seasons of NHL statistics, and each player’s value across our ten categories. 4. I use the board’s flags and player detail cards to evaluate likely pre-next-pick selections, injury and regression risks, projections, historical data, and plain-English player assessments. 5. I display the pick clock, next player on deck, and recent picks on a separate TV view, then switch that view to color-coded projected standings by category after the final pick. 6. During the season, I paste in my roster so the assistant can pull the NHL schedule, starting-goalie reports, and injury news. 7. I use that information to set daily lineups, rank free agents by value and weekly games played, and project my head-to-head matchup category by category. 8. When needed, I ask Claude to propose a lineup and explain its recommendations, at a cost of about ten cents per run in API credits. 9. Because Yahoo’s API is read-only, I currently use the assistant for recommendations rather than autonomous team management.

I built a workflow to reconstruct auditable, per-client billing for Claude usage after my Anthropic bill tripled in one month and I discovered there was no reliable way to see why. I run a solo consulting practice on a Max plan and pass AI costs through to clients. In September, my extra usage reached $1,805.76 in nineteen days. The usage page attributed 100 percent of one week to "Cowork" without session detail. Auto-reload was enabled by default with no spending limit, and the only usage I could independently verify—my local Claude Code logs—accounted for about $245. The support bot twice described analytics features that did not exist, including a per-day view it later retracted. When I finally reached a human, I got the truth in writing: Max subscribers have no session-level or per-day reporting, exports are Enterprise-only, and Cowork has been cloud-only on consumer plans since August. The Enterprise path to a readable meter starts at twenty seats. I am one person, so I built my own meter. The irony is that I used Claude to design and code it. Claude Code sessions write logs on my own machine. I price them at list rates with the open-source `ccusage` tool and attribute each session to a client by repo folder. That creates the measured pool: real receipts with no allocation. Other CLIs in the same logs, such as OpenAI Codex, are excluded automatically. Chat and Cowork run in Anthropic’s cloud and leave nothing on my disk, so the remaining overage becomes a cloud pool. I split that pool using evidence my workflow already produces: every Cowork document batch leaves a directive file, snapshots, and a report on disk. A Python script counts executed batches per project and measures the number of bytes each one rewrote. The script splits the cloud pool independently by batch count and byte volume, bills the midpoint, and shows both derivations so each client can see the bracket. Every column ties back to the dashboard total to the penny. A second script pulls per-account AWS charges from Cost Explorer because each client has a separate AWS account. Shell aliases make each report a one-command operation. A Claude skill and a monthly scheduled task turn the outputs into a draft invoice that I approve before anything is sent. The result is that a vendor hands me one unexplained number each month, while I hand my clients an evidence file. Month-end billing takes five minutes. It should not have been necessary to build this, but until consumer plans get real usage analytics, this is how I see in the dark. Step-by-step: 1. I collect local Claude Code session logs and use the open-source `ccusage` tool to price them at list rates. 2. I attribute each Claude Code session to a client by repo folder and automatically exclude other CLIs, such as OpenAI Codex, from the measured pool. 3. I treat the remaining overage from cloud-based Chat and Cowork usage as a separate cloud pool because those services leave no usage logs on my disk. 4. I use Cowork’s directive files, snapshots, and reports to identify document batches, then use a Python script to count executed batches per project and measure the bytes each batch rewrote. 5. I split the cloud pool independently by batch count and byte volume, bill the midpoint, and show both derivations as a client-facing bracket. 6. I verify that every column ties back to the dashboard total to the penny. 7. I use a second script to pull each client’s per-account AWS charges from Cost Explorer. 8. I run the reports through shell aliases, then use a Claude skill and a monthly scheduled task to create a draft invoice for my approval before sending it.

I've been a Linux user for some time and am comfortable with the command line, though I'm not an expert. I'm resourceful about looking things up and fixing problems, and I've become comfortable using AI to provide steps or code for routine IT tasks. Yesterday, I encountered errors I had never seen before. Searching for help or asking questions online would have been exhausting and incomplete, so I fired up ChatGPT while I was investigating. ChatGPT provided an overview and explained the relevant command-line terms, but it gave me many steps at once. I asked it to slow down and provide one step at a time. It agreed, and the interaction became like having my own IT tutor or consultant. Before continuing, it explained the reasoning behind each step and double-checked the parameters, which was almost annoying—but useful. I've thought for some time that my diagnostic skills were strong, but AI-assisted troubleshooting and diagnostics feel otherworldly. The same approach could apply to IT, car repair, household problems, and other troubleshooting situations where it helps to have access to a highly seasoned pro. Step-by-step: 1. I used ChatGPT while investigating unfamiliar errors instead of relying only on online searches. 2. I asked it for an overview and explanations of the relevant command-line terms. 3. When it presented too many steps at once, I told it to slow down and provide one step at a time. 4. I worked through the interaction one step at a time, with ChatGPT explaining the reasoning and double-checking the parameters before continuing. 5. I used the same troubleshooting approach as a model for diagnosing IT, car-repair, household, and other problems.

I built an AI orchestrator called ADT (Agent-Dev-Team) that sits over Claude Code and GitHub and drives each step of the development pipeline: the ticket, the Definition of Done, the build, the quality check, and the cost. It contains around 6,000 lines of Python and prose and is open-sourced here: https://github.com/zurichrich/ai-orchestrator-adt I had been building with Claude for over nine months, so I documented what goes wrong when an agent receives a real problem. It can overcomplicate or duplicate work, or build the wrong thing. It builds quickly, but with questionable quality. I realized this is not necessarily a model problem: give any capable agent—or human—a vague ticket, and it can build the wrong thing quickly and confidently. Coding agents made implementation cheap, so the bottleneck moved upstream to planning. Planning was still me, typing prompts and becoming the slowest part of my own setup. I also became less focused by GitOps processes, with multiple parallel sessions colliding, so I needed a tool to remove that friction. I built ADT with Claude and put it to work on itself and on other personal projects that are currently in development. Step-by-step: 1. I put the backlog next to the code. Tickets live in GitHub Issues and mirror to a local Markdown cache, so the agent reads and edits them with the same tools it uses for the code. This keeps the process fast, reduces guesswork about what the ticket means, and keeps the full history visible to everyone. Claude writes in tickets far more than humans do, so GitHub Issues become the knowledge base of the future. 2. I write the Definition of Done so a machine can check it: a command that exits with 0, rather than a paragraph of good intentions. If I cannot write that command, the ticket is not ready and the build should not start. 3. I let the ticket do three jobs. It is the specification, the prompt Claude works from, and the record afterward. Keeping one description of the work prevents the build from wandering away from what was requested. 4. I track token use and cost per ticket, so when a product owner asks what a feature cost, I can tell them. 5. I run ADT on itself and on other personal projects currently in development. The results are 46% better plan quality, 37% fewer bugs, and 15 agents running in parallel without colliding.