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

I built a model dispatcher to avoid paying premium usage for simple tasks. In Claude, every task runs on the model used by the current session, so a two-line formatting fix can consume the same level of model capacity as a difficult strategic problem. I had Claude build a scoring system that evaluates each task across six dimensions: required reasoning, the amount of context, the importance of craft or nuance, whether speed is the priority, the number of agentic parts involved, and the potential consequences if something goes wrong. Based on the score, it recommends a model—from a light, fast option for rote work to the most capable option for genuinely difficult tasks—and suggests how much effort that model should apply. The key design choice is that the dispatcher never spends anything automatically. Scoring is free and instant, while sending the task to a model through the API costs real money. Dispatching therefore requires an explicit confirmation flag every time. Nothing runs without me saying go. The payoff is not dramatic from day to day. It comes from many small savings that add up, along with a habit shift: I check the router before sending a task instead of wondering afterward why a simple request cost more than it should have. Step-by-step: 1. I identified the problem: every task in a Claude session uses the current model, even when the task is simple. 2. I had Claude build a scoring system that evaluates each task across six dimensions: reasoning, context, craft or nuance, speed, agentic complexity, and the potential consequences of failure. 3. I used the score to recommend an appropriate model, from a light and fast model for rote work to the heaviest model for genuinely difficult tasks. 4. I included a recommendation for how much effort the selected model should apply. 5. I kept scoring free and separate from dispatching, since sending a task through the API costs money. 6. I required an explicit confirmation flag before dispatching any task, so nothing runs automatically. 7. I check the router before sending tasks and benefit from small savings that accumulate over time.

I had a bad workplace experience, so I built Doris: a saucy but loving anonymous AI aunt who remembers the tea, protects storytellers, and warns others. I built Spill Tea with Doris, an anonymous AI workplace confessional for conversations people cannot really have on LinkedIn: the bad manager, the inexplicable reorg, the coworker who somehow survives every layoff, and the meeting that should probably be entered into evidence. Doris does something more interesting than simply listen. She remembers the tea—and, carefully, spills it. The problem I wanted to solve was not really “chat with an AI.” Most AI conversations are disposable, but workplace stories are not. They accumulate companies, people, reorganizations, layoffs, recurring behaviors, management decisions, and institutional weirdness. At the same time, people are understandably reluctant to talk openly about their employers because a sufficiently specific story can identify its author. I designed Doris around a different idea: retain the knowledge without retaining the storyteller’s identity. Someone visits [spillteawithdoris.com](https://spillteawithdoris.com) and tells Doris what happened at work. The application is built in Next.js and deployed through Vercel. The conversation goes to an AI model with Doris’s personality and behavioral rules. Redis handles temporary conversational context, while Neon Postgres and Prisma maintain the structured, longer-lived pieces of the story—companies, people, events, and their relationships. Rather than treating every conversation as one giant transcript, the application extracts useful information and connects it to the larger story of a company. That creates the second half of the experience. When another visitor asks Doris, “Have you heard anything about working at Company X?”, she can draw upon what previous visitors have told her. But she does not simply retrieve someone’s confession and repeat it. The system separates what is useful about a story from what could identify the person who told it. Names, exact teams, precise dates, unusual job titles, and other unnecessarily identifying details do not need to travel with the underlying observation. Doris can instead recognize that she has heard several stories involving reorganizations, unusual management turnover, or a particular cultural complaint. Then Doris tells the story herself, in Doris’s voice. She might say that she’s “heard some tea” about a company, explain the general pattern, distinguish something she’s heard once from something that appears repeatedly, and avoid pretending anonymous reports are established facts. Visitors get useful institutional memory without being handed the breadcrumbs needed to identify an individual employee. Public information can provide a second layer of context. If appropriate, Doris can search for publicly available information about a company and compare it with what people have privately described. Those sources remain conceptually separate: what Doris can verify publicly, what Doris has heard privately, and what Doris herself infers should never become the same thing. The result is deliberately a little strange. It is an anti-LinkedIn. LinkedIn is where thousands of individual experiences are polished until every company sounds wonderful and every departure is an exciting new chapter. Doris works in the opposite direction. One anonymous story may just be a story. Ten people independently telling Doris versions of the same story start to describe a workplace. And Doris remembers. She just doesn’t need to remember who told her. Step-by-step: 1. I built a Next.js application and deployed it through Vercel at spillteawithdoris.com. 2. I defined Doris’s personality and behavioral rules for the AI model. 3. I added Redis to manage temporary conversational context. 4. I created a Neon Postgres database and used Prisma to model Company, Person, Story, and Event relationships. 5. I built an extraction layer that converts conversations into structured observations, removes unnecessary identifying information, and associates the knowledge with the appropriate company. 6. I built retrieval so Doris can find relevant prior observations when someone asks about a company. 7. I had the AI synthesize those observations in Doris’s voice instead of quoting or exposing the original submissions. 8. When appropriate, I let Doris search publicly available company information while keeping public sources, private reports, and Doris’s inferences conceptually separate.

For years, my family has run a shared birthday fund: five of us contribute a fixed amount for each birthday, while the person whose immediate family is celebrating that month is exempt from paying. Tracking everything in a payment app and a chat thread meant nobody knew the balance, who was behind, or what the next gift would cost. I rebuilt the fund as a small web app with Claude. The app itself isn't the only reason I'm writing this up. The same build is also the demo I use to teach clients and students how AI-assisted product development actually works, including the parts that go wrong. Step-by-step: 1. I described the real rules instead of presenting Claude with a generic app idea: the contributors, the fixed amount per person, the family-exemption rule, and birthdays with birth years so ages could be calculated automatically. Claude built the app as a single, self-contained HTML file with no build step or server, so it opens in any browser. 2. I worked in phases and asked Claude to explain its reasoning at each stage. Instead of using one giant prompt, I added one layer per session: the calculation engine, the setup screen, then reports and CSV export. The explanations made the sessions reusable as teaching material. 3. I required the app to be configured through its own interface rather than by editing code. This was the turning point. Claude removed the hardcoded demo family and added a full setup screen for the group name, contributors, deposits, birthdays, amounts, and alerts. I can now build a family from scratch live in front of a class in about [X] minutes without showing a line of code. 4. I let a data-loss incident shape the next phase. I entered the real family data, then the browser tab closed and the download link I had been using to open the file broke. The data was stored in browser storage tied to that exact URL, and I had no backup. Nothing was recoverable at the time. 5. I turned that failure into features. Claude added CSV export for both reports, CSV import that automatically detects which file it is reading, and a backup reminder that appears in the app's alert banner when the data has never been backed up or has not been backed up for seven days. We also discovered that birth year was missing from the export, which meant a re-import would have silently lost everyone's age. 6. I had Claude test its own work. Before each handoff, it ran a jsdom test suite in a sandbox. By the end, the suite had 46 tests covering the exemption math, empty states, CSV round-trips, and backup logic. Several real bugs surfaced there instead of in front of a class. 7. I made a second version for a different audience. One prompt produced a fully English, left-to-right translation with flipped directional CSS, Latin typography, US date formatting, dollars instead of shekels, and Venmo and Zelle instead of local payment apps. It was a genuinely different build, not a find-and-replace translation. The project took 14 sessions over one week and six hours total. It had no hosting cost, dependencies, or accounts. The data still lives in the browser's local storage on each device. Opening the file on my phone and laptop creates two unrelated pools, so CSV import is the manual bridge between them. There is no authentication or sync; this is a personal record-keeper, not shared infrastructure. The data-loss incident was not a Claude failure. I failed to build a backup path before entering real data. If I did it again, I would add export before adding a single feature. The highest-leverage prompt in the whole project was not a feature request. It was: "let me configure this through the interface instead of the code." That shift turned a static demo into something my family actually uses and my students can watch being built from an empty screen. The broader point is that the failure was the most useful part of the project. A polished demo teaches people that AI makes building easy. Losing the data and rebuilding the safety net around it teaches them what building actually involves—and that is the lesson that survives the workshop.

I own a rental property where a water leak has occurred roughly every year or two. The leak typically runs for weeks before the water utility detects usage above its threshold. Because billing cycles last three months, the utility may notify me weeks or months after the problem begins. By then, the leak can have produced a bill more than $1,000 higher than the usual $100–$300 amount. The utility offers a one-time, per-account waiver for accidental leak overages. After using that waiver the first time, later incidents are entirely out of pocket. The utility also cannot notify me sooner than when usage exceeds 25,000 gallons during a billing cycle, which moves the account into a quadruple-rate tier for the rest of that cycle. I repeatedly asked whether they could provide an immediate alert when a user-set or company-set daily usage threshold was exceeded, but they said they had no system or solution for it. I tried checking my usage manually every day, but after weeks or months of normal readings, it was easy to become complacent or forget. After receiving another $1,300-plus bill, I asked ChatGPT whether I could automate the process of logging into my utility account, checking usage daily, and emailing me about the prior day’s usage or an overage. ChatGPT suggested several options, including paid AI-agent tools and a free script running on my own hardware. I wanted a completely free, cloud-based solution that would not require my computer to stay on, so I compared the paid options, including Google Spark, with a GitHub-based system. GitHub apparently includes 2,000 minutes of script runtime per month, while my system was estimated to use about 100 minutes. I spent part of a day asking ChatGPT questions, copy-pasting code into GitHub, and refining it. I now have a cloud-based system that logs into my water utility account, checks daily usage, emails me when my daily or seven-day-average thresholds are exceeded, and adds each day’s usage to an Excel spreadsheet for ongoing history. I have verified that it works, and it is set up to keep running and sending alerts without ongoing cost. I had never coded before. The system uses Python, GitHub Actions/YAML, Playwright, pandas, openpyxl, Excel, and Gmail for email alerts. Excel and Gmail were the only tools in that list I had used previously. If I want to change an alert threshold or another setting, I can log into GitHub and ask ChatGPT for the relevant code adjustment. I also added a second rental property in the same city that uses the same water utility. Replicating the process for that property required only a small amount of additional code and took almost no time. I now have a perpetually self-updating, cloud-based water-usage database with daily email alerts for both rental properties, at zero ongoing cost.

I run nine GitHub repos as one programme of work. Every project keeps its backlog as plain markdown inside its own repo, one Claude Code or ChatGPT Codex session works each project in parallel, and a single board in VS Code shows all of them moving at once. There is no project tool, no API and no sync job in the middle: the markdown file is the shared state that both I and the agents read and write. Step-by-step: 1. Put the backlog in the repo, as markdown. Every project gets `docstech/users/<me>/todo.md` and `done.md`. A story is a `###` heading. Structured fields ride in an empty markdown link at the end of it: `### Add rate limiting [](?status=doing&epic=api&time_estimated=180)`. GitHub renders an empty link as nothing, so the file still reads as prose in a pull request while carrying real metadata. 2. Write the story before the session starts. Each one has goal, background, scope, out of scope, the files it should touch, a checkbox task list, and acceptance criteria. That story is the prompt, and most of my thinking happens there rather than in chat. It decides whether the session comes back with anything shippable. 3. Open the parent folder in one window, and turn the files into a board. I open the parent folder holding all the projects and open any `todo.md` with NoteThink in Folder mode, which merges every markdown file under it into one view. Group the lanes by project and it is the programme view, one lane per repo. Group them by status and it is the delivery view, one Kanban across the whole portfolio. Each card carries a pill naming the project it came from, and clicking it opens that file at that story. 4. Start one Claude Code session per project. Every session opens with the same instruction: read `todo.md` top to bottom and take the top story. The sessions never talk to each other, because the file on disk is the only shared state. A session that dies costs nothing. 5. Let the board report progress instead of reading the sessions. Agents edit the markdown as they work: tick a task, flip `status=todo` to `status=doing`, move a finished story to `done.md`. The board watches the files, so cards animate into their new column as each change lands, and I can see which sessions are advancing without reading any of them. 6. Steer by dragging. Dragging a card between lanes writes the attribute back into the source markdown, so dropping one in "doing" makes the file say `status=doing` and the next agent turn reads it. Ticking a checkbox does the same. The board is the steering wheel and the file is the wire. 7. Close every story the same way. One slash command runs lint plus the full test suite, checks the story's tasks are ticked, and drafts the commit message; another ships to staging then production. The finished story moves to the end of `done.md`. Over time `done.md` becomes the programme record: what shipped, when, and what it cost. Try the board without installing anything. Here is a live example board, four projects merged into one view, and it is exactly what the screenshot shows: https://www.notegit.com/en/app/notegit.com/notegit/example_repo/blob/ai-board/board.md Results, honestly. Nine repos, about 260 open stories and about 1,400 completed ones, all in markdown inside the repos rather than a tracker. The backlog goes back to March 2024; the parallel sessions on top of it are the last four months. I run eight to twelve sessions at the same time, and the whole thing fits inside one Claude Max 20x subscription over a month of full-time work. Not all of it is code. The same parallel-session habit drives a nuclear reactor design study (https://github.com/cleverlight/mistergy) and several video and design projects. The board part fits best where the work already lives as files in a repo. Limits, honestly. The ceiling is my review capacity, not compute. Eight to twelve is where I sit; past that I stop reading output properly and start rubber-stamping, which is worse than running fewer. It only works when stories are genuinely independent, because two sessions in one file is a merge conflict you wrote yourself. Agents occasionally finish work and forget to move the story, so `done.md` needs a sanity check. And it assumes you will write the story properly first, which is real work that AI does not do for you. The screenshot is the public example board rather than my own, because my real one carries client project names. Disclosure: I build NoteThink, the free, open-source VS Code extension in step 3, and NoteGit, which hosts the example board. NoteThink is on the VS Code Marketplace, Apache-2.0, and genuinely early (v0.3.38, preview quality, a handful of installs). The workflow is tool-agnostic and the markdown is just markdown: any viewer will show it, and you can run the whole thing with no extension. NoteThink is what makes the cross-project board and the drag-writes-back-to-file part work.

A friend who had just started a pet-sitting and dog-walking business asked me to build a booking app. I used Google AI Studio to design the initial prototype. The process was straightforward, and I had a basic working system running within two hours. AI Studio created a Firebase database to store the details and was also effective at designing frontend changes. It published the app for me, and the resulting UI was intuitive. After demonstrating the app, I identified many additional features that needed to be added. This went beyond AI Studio’s capabilities, so I exported the code from AI Studio and started using Claude. I asked Claude to analyze the code and suggest the required changes. Claude identified critical security flaws in the database. I fixed them manually at first, but then realized that Claude could access the Firebase database and fix issues automatically. I continued prompting Claude with additional feature requests, and it built them. There were errors along the way, so I needed to be familiar with Google Chrome’s developer tools to copy the errors and ask Claude how to fix them. I used MailJS for email templates and Resend for email transport. I stored the app in GitHub and allowed Claude to access the repository so it could commit changes automatically. I ran the app locally with npm during development and then hosted it on Vercel. Eventually, I purchased an inexpensive domain name, and the app is currently hosted at Names. One major problem was that when Google AI Studio created the Firebase database, the permissions were locked, preventing me from making administrative changes. I solved this by recreating the database and asking Claude to write the SQL query to set it up. The permissions were still tricky, and I had to continue asking Claude to correct them. Google’s service permissions can be difficult to understand, and finding the correct settings was not always easy. Firebase was also complex to navigate, and getting the permissions configured correctly took time. Once I allowed Claude to connect to the app and its background services through the Google plugin, development became much faster. However, you need to trust the tool carefully and always work on a copy of the live app. Overall, I think app development with Google AI Studio and Claude is impressive. You can create professional apps quickly. I come from an IT support background, though, and I think people who are new to IT may find it difficult to troubleshoot errors without a basic understanding of networking and systems administration. I also built a litter-tracking app using ChatGPT, and it was equally effective. I eventually started using Codex and Claude Code, but I think standard Claude and ChatGPT are more intuitive for nontechnical users. Step-by-step: 1. I used Google AI Studio to create an initial booking-app prototype for a pet-sitting and dog-walking business. 2. I used the Firebase database created by AI Studio to store the app’s details and used AI Studio to design frontend changes. 3. I published the initial app with AI Studio and demonstrated it to identify additional features. 4. I exported the code from AI Studio and asked Claude to analyze it and suggest changes. 5. I addressed the critical database security flaws identified by Claude, first manually and later by allowing Claude to access the Firebase database. 6. I prompted Claude to build additional features and used Google Chrome’s developer tools to copy errors and ask Claude for fixes. 7. I recreated the Firebase database when AI Studio’s locked permissions prevented administrative changes, then asked Claude to write the SQL query to set it up. 8. I used MailJS for email templates and Resend for email transport. 9. I stored the app in GitHub and allowed Claude to commit changes automatically. 10. I ran the app locally with npm during development, hosted it on Vercel, and later purchased an inexpensive domain name that is currently hosted at Names. 11. I connected Claude to the app and background services through the Google plugin, while continuing to work on a copy of the live app.

Claude created my portfolio website in an instant. I prompted it with my links (LinkedIn and social), described what I wanted, and it built the entire thing in one sitting — design, deployment, DNS config, SEO, and Google indexing included. I made a handful of edits across the session, and it handled every single one without friction. When things broke during deployment, it debugged in real time and fixed them via desktop extension browser control. Zero code written by me. Step-by-step: 1. I gave Claude my LinkedIn and social links along with a description of the portfolio site I wanted. 2. I asked it to build the site’s design and content in one working session. 3. I reviewed the result and made a small number of edits through conversation rather than editing code. 4. I had Claude handle deployment, DNS configuration, SEO, and Google indexing. 5. When deployment broke, I used browser control to let Claude inspect the live problem and debug it in real time.

Sometimes a story needs a simple locator map to show where something happened or where something can be found—such as a business facility, a car accident, or the best place to see a sunset. I've worked in media for a long time and understand the power of maps to tell stories. But media cost-cutting and consolidation have reduced the number of available graphic departments, so creating a map is often the last task a reporter or editor wants to take on. I used Perplexity for initial research, Claude Code and Codex to build a web app, and Perplexity and ChatGPT for post-work such as SEO best practices. Step-by-step: 1. I used Perplexity's Deep Research mode to conduct a competitive market analysis. I asked it to analyze the field I was considering entering, identify competitors and growth rates, and explicitly break out feature sets. 2. I revised the research with my own idea and asked Perplexity to run the competitive landscape against it. I also provided desired outcomes, including intended audiences and where competitors were reaching them. I added the constraint, "Do it without syncophancy," so it would stop telling me how good my potential product was. 3. I hand-drew the initial screens and functions I wanted, then used the `/office-hours` skill in the Gstack bundle, available on GitHub, to play devil's advocate, sharpen the ideas, and challenge my assumptions. 4. I wrote a long prompt describing the product, starting broadly with the concept and audience and then narrowing to specific features and benefits. For example, I specified that it should export in 16:9 and 9:16 formats so maps would be ready for mobile vertical presentation. 5. I specified the hosting environment and that the product should be a web app. I also required a planning phase followed by construction phases. I pasted the prompt into Claude Code with this final line: "Use /grill-me to ask me questions to clarify intent." After 147 questions, it started the build. 6. This was in the pre-Fable days, so I specified that Opus 4.8 should act as an orchestrator while less expensive agents, particularly in Codex, handled the actual coding. 7. I used separate phases for technical work such as wiring in mapping providers and getting the UX to work correctly. Other phases included wiring in payment and subscriptions and making sure a subscription triggered an email campaign with instructions. 8. I dedicated an entire phase to building admin tools so I could manage the marketing language on the landing page and publish blog entries. 9. After each phase, I had the Opus/Codex combination perform an adversarial code-review-and-fix cycle. I then ran the `/ai-regression-testing` skill from the ECC repository on GitHub to catch issues the code review missed. 10. After every third phase, I prompted Claude Code: "Act as a senior QA engineer and go through the entire codebase looking for inconsistencies, functions that are in the wrong place, code that is overkill and security vulnerabilities." 11. When I had a product I thought was ready for testing, I prompted Claude Code, again using the Opus/Codex combination: "Act as a senior security engineer. Run this against OWASP standards. Find problems and suggest fixes. Harden this product overall." 12. As I neared the end, I asked Perplexity Deep Research and ChatGPT (Sol/High) to find SEO solutions for the product.

Before I ship anything built with AI—whether I use Lovable, Cursor, Replit, or Bolt—I run a security and readiness audit. I ask my AI assistant to clone the free, open-source repo at github.com/edgewiselab/ship-kit and scan my project. It identifies my stack from the code on its own, with no configuration required. The audit checks for 113 known launch mistakes, including open databases, leaked secrets, emails going to spam, missing error tracking, and more. It skips anything that doesn't apply to my app. It generates a plain-English report: green means everything is fine, red means I need to fix something, and amber means I need to confirm it myself. I hand the red items back to my AI assistant to fix, then rerun the scan until the report is clean. The tool is free, MIT licensed, and runs entirely on my own machine. Step-by-step: 1. I ask my AI assistant to clone `github.com/edgewiselab/ship-kit` and scan my project. 2. I let it identify my stack from the code without adding any configuration. 3. I review its checks for 113 known launch mistakes, including open databases, leaked secrets, emails going to spam, and missing error tracking. 4. I review the plain-English report and focus on the red items while confirming the amber items myself. 5. I give the red items back to my AI assistant to fix. 6. I rerun the scan until the report is clean.

“A good engineer knows when not to use AI.” I built a semi-automated workflow to summarize my live streams. With it, I can record and edit a stream in just one day of work. Not everyone has time to watch an entire stream, so creating a summary of the main moments is important for people who want to watch it later. Many tools create Shorts from videos by analyzing transcripts, but they are expensive and do not work well for visually heavy content such as gameplay. Gemini can analyze both video and audio and has a long context window, so I decided to use Google AI Studio to identify important moments. I also created scripts to automate parts of the video-editing process. Some of the scripts can be executed by an agent, and the prompts can be turned into Skills when using the API. Step-by-step: 1. I record the video with separate tracks for the microphone and background audio. I keep the microphone on the first track so the LLM does not identify only the background audio. 2. I compress and cut the video with `ffmpeg`, then extract the audio tracks. Google AI Studio has implicit video requirements: files must be under 400MB and under one hour long. The AI analyzes only one frame per second, so I can also lower the FPS to save space. I use the audio tracks later in the workflow. 3. I upload the processed videos to Google Drive, which makes them easier to use in Google AI Studio. 4. I use Gemini with temperature 1 and a high thinking level to select the important moments. I add the system prompt and specify which part of the video I am uploading: "The video is part X of the stream. Please make a structured script according to the system instructions." This helps Gemini understand what types of moments may appear in the video. The system prompt was created for gameplay presentations but can be adapted for other content. 5. I use Gemini Pro with temperature 1 and a high thinking level to find the timestamps for the selected moments. I keep timestamp generation separate from moment selection so Gemini has more thinking time for each task. Gemini Pro works better than Flash when handling time. I add the system prompt along with a copy of the response from the previous step. - As an extra check, after execution I continue the conversation with: "Check if the analysis was cut off too early (context truncation), ignoring that the video continued and generating false positives for timestamps. Check the last events especially." 6. I send the data to Blender. I create a JSON file containing the AI’s response and use a script to add the original video, the microphone track, and the background audio track. The script cuts and marks the important moments based on the JSON. Because it is not possible to send multiple audio tracks from a single video, I send the tracks separately. I also make sure to use the correct FPS, either 30 or 60. 7. I edit the video manually. The AI’s timestamps are not perfect, so I may add or remove sections, or correct a position that the AI identified incorrectly. I then render the video. 8. As an extra, I can automate standardized edits. For example, I use three different camera positions, so I add clips to three different tracks depending on the position I want. I use a script to change the position and scale of the clips on those tracks. 9. As another extra, I transcribe the audio. I mute the background audio and save only the microphone audio as an MP3, then use Whisper to transcribe it. I can use the transcript as YouTube subtitles or embed it directly into the video. I use Whisper-WebUI with Log probability Threshold -0.5, No Speech Threshold 0.5, Patience 2, and Hotwords `\u003cmy name and terms in other languages I usually use\u003e`. I use an LLM to translate the transcript into other languages. 10. Finally, I create tags and titles. I upload the transcript to Google Drive and use it in Google AI Studio with a system prompt to generate tags and titles for the video. I also use the assistant in Google AI Studio to analyze and summarize my channel for use in LLMs. This helps me choose better titles and tags.

I started with a plain-language vision: a world championship where people create autonomous AI minds that compete in simulated markets. I used ChatGPT as a product architect to turn that vision into precise rules, technical specifications, development checkpoints, and tasks that could be completed one at a time. I then used AI coding agents, including Claude Code and Codex, to inspect the repository, write the React and TypeScript code, run tests, identify failures, and explain each completed change in plain language. Determinism and auditability were non-negotiable. Every match uses a reproducible seed, every autonomous mind trades in its own matching engine, and every decision is recorded in an auditable event ledger. After each development cycle, I tested the product, reviewed the interface on desktop and mobile, corrected problems through natural-language instructions, and saved a new canonical checkpoint. I deployed only after the automated tests passed. This allowed me, a 66-year-old self-taught non-programmer, to build a working autonomous-mind competition platform through human vision, AI collaboration, and strict verification. Step-by-step: 1. I defined the vision for a world championship in which people create autonomous AI minds to compete in simulated markets. 2. I used ChatGPT to develop the rules, technical specifications, development checkpoints, and one-at-a-time tasks. 3. I used Claude Code and Codex to inspect the repository, write the React and TypeScript code, run tests, identify failures, and explain completed changes in plain language. 4. I required every match to use a reproducible seed, each autonomous mind to trade in its own matching engine, and every decision to be recorded in an auditable event ledger. 5. After each development cycle, I tested the product, reviewed the interface on desktop and mobile, corrected problems through natural-language instructions, and saved a new canonical checkpoint. 6. I deployed only after the automated tests passed, enabling me to build a working autonomous-mind competition platform through human vision, AI collaboration, and strict verification. Explore the live platform: https://arenomics.com

I never ask AI to “build the app.” I move the work through a fixed assembly line, and the most valuable stations are the ones whose only job is to attack what came out of the previous station. I’m a solo developer, and this is how I build and ship software for paying clients without a team to catch my mistakes. I choose the next chunk of work—a “phase”—and run one command. Each phase gets its own fresh context window, which matters more than any single agent because a long-running session gradually forgets its own rules. Step-by-step: 1. I discuss the phase with an agent that interrogates me until every gray area is decided. The decisions go into a file instead of staying in chat, where they can get lost. 2. A planner writes an executable plan covering the tasks, files to be changed, a threat model, and the acceptance checks that will prove the work succeeded. 3. A different agent, working from a fresh context, checks the plan by working backward from the goal and trying to prove that the plan will not achieve it. This agent can block the phase, and regularly does. 4. I execute the plan task by task, making one atomic commit for each task so the changes can be reverted cleanly. 5. I send the diff to a different model than the one that wrote it. I run Codex and CodeRabbit alongside Claude. This is the highest-value station in the line: my own tests verify only what I thought to check, while an independent model can catch the class of problem I did not anticipate. 6. An agent verifies whether the phase goal was achieved by re-deriving it from the actual code. “All tasks completed” and “the thing works” are different claims. Treating them as the same is how you ship a green checklist on top of a broken feature. 7. Before anything reaches a client, I run a security and handoff audit in a real browser against a throwaway clone of the production database. I check every page, every button, and every empty and error state. The part that compounds is what happens when a bug reaches me anyway—whether I find it in production or, worse, a client reports it. I log it as an escape, then walk the chain backward and ask each gate why it missed the problem: the planner, plan checker, executor, both reviewers, verifier, security check, and handoff audit. A one-off escape becomes a written rule. A repeat becomes a change to the gate itself. I have 42 logged escapes. That file is the most valuable thing I own because every entry represents a hole that is now closed. The pipeline I run today is mostly shaped by bugs that got past the pipeline I ran a year ago. The results so far: 29 projects, 17,657 commits, and 574 phase folders. I’ve completed six client engagements, with apps live in production and handed off to their owners, as well as mobile apps built and pushed through App Store review—all as one person, with no team. There are real costs and failure modes. A phase with every gate enabled costs meaningfully more tokens than simply asking a model for the code. That is worth it on client work, where a bug can cost me a relationship, but it is overkill for a throwaway script, so I turn the gates off for those. Gates can also be confidently wrong. My most expensive recurring failure is a check that passes on a signal adjacent to the thing it claims to verify—a green light that means nothing. My rule now is that I do not trust a new check until I have watched it fail against known-bad input. A green result you have never seen turn red is not evidence. A green test suite is not the same as a working feature. Nearly every bug that escaped me was covered by a passing test whose mock had quietly pre-satisfied the exact condition under test. Testing the real boundary is the only thing that catches those failures. This process is not hands-off. I deliberately run one phase per session, and I read what comes back. Anyone selling a fully autonomous overnight build is selling a merge conflict plus a confident summary of work that did not happen. If you want to take one idea from this, it is not the framework. The agent that writes the work must never be the one that approves it. Keep a running log of everything that gets through anyway, then fix the checkpoint that let it through instead of only fixing the bug.

This workflow keeps software development human-led while using AI without giving up engineering control. Step-by-step: 1. Inspect the real project: its current behavior, architecture, constraints, repository state, and existing tests. 2. Define one observable outcome, along with acceptance criteria, scope, non-goals, risks, and stop conditions. 3. Decide where the change belongs architecturally before asking an AI assistant to write code. Record consequential decisions. 4. Split the goal into the smallest independently useful, reviewable, and reversible vertical slice. Keep refactoring and unrelated cleanup separate. 5. Give the AI assistant one bounded implementation prompt. Require it to follow existing conventions, add focused tests, report assumptions, and stop if it discovers conflicting requirements or broader scope. 6. Run targeted tests and relevant regression checks. Validate the change in the environment that matters, clearly distinguishing automated checks from manual or real-world acceptance. 7. Have a human review the actual diff, evidence, error paths, security implications, and documentation. AI output remains a proposal until a person accepts it. 8. Update the documentation with the behavior, decisions, limitations, and validation evidence. 9. Create one coherent, reversible commit, then repeat the loop for the next small slice. The complete methodology, reusable prompts, templates, examples, and release checklist are published at https://github.com/d-wendel/human-led-ai-engineering

Whenever a user wants to install a Skill, an MCP, or a CLI, the guard scans it for malware before installing it on all agent systems. Step-by-step: 1. Detect the user’s request to install a Skill, an MCP, or a CLI. 2. Scan the requested item for malware. 3. Install it on all agent systems.

As an AI consultant, I need to stay ahead of a landscape that evolves daily by reading dozens of industry articles each week. Manual tech watch quickly becomes a major time sink and pulls me away from client work. I built a specialized AI agent for challenge-focused summarization. Instead of producing generic, passive summaries, it answers two questions for every article: What specific problem, friction, or limitation does the article highlight? What practical solutions, tools, or actionable steps does it provide? The agent strips away marketing hype, introductory fluff, and generic definitions. It identifies the author’s core pain point and produces a quick-read summary focused on actionable technical or business solutions. This turns 15-minute reads into 30-second, high-value digests. By focusing on problem-solving rather than passive reading, the workflow helps me identify practical tools and frameworks I can apply directly to client projects and improve my consulting work. Step-by-step: 1. I provide the agent with a raw article link or the article text. 2. The agent filters out marketing hype, introductory fluff, and generic definitions. 3. It identifies the core pain point, friction, or limitation discussed by the author. 4. It extracts the concrete answers, including practical solutions, tools, and actionable steps. 5. It synthesizes the findings into a quick-read format focused on actionable technical or business solutions. 6. I use the digest to identify tools and frameworks that may apply directly to client projects.

Faceplant is a real full-stack app, not a mockup. It uses a FastAPI and PostgreSQL backend, a React and MUI frontend, and the Anthropic API (Claude) to power bot replies. The core is the reaction engine. When a human posts, the backend schedules two timed waves of reaction jobs. A background scheduler built with APScheduler polls for due jobs, calls Claude for an in-persona reply, and writes that bot’s comment and like. The 56 personas are stored as data in a roster file. Adding a voice requires only one new entry, so the crowd can scale without additional code. A subset of the personas are GIF-first bots: they ask the model for a caption and search tag, then pull a matching GIF from Giphy. The part I’m proudest of is the honesty layer. Every Claude call is metered and priced, and “The Meter” rolls the data up live with the cost per post, the dollar-per-minute burn rate, and a “spent on nobody” line for bot-to-bot chatter with no human at either end. A “% human” badge drains toward “dead internet” for each thread. The dead-internet loop—bots posting and replying to one another with no human present—is disabled by default and protected by three guardrails: generation decay, a per-thread cap, and a global spend kill switch. Optional cost controls include the Message Batches API at half price and prompt caching for a shared house-style prompt. The whole project is a working demonstration that manufactured engagement is cheap to produce and expensive to mean anything. Step-by-step: 1. I built the app with a FastAPI and PostgreSQL backend, a React and MUI frontend, and Claude replies powered by the Anthropic API. 2. When a human posts, the backend schedules two timed waves of reaction jobs. 3. APScheduler polls for due jobs and triggers Claude to generate an in-persona reply before writing the bot’s comment and like. 4. I keep the 56 personas in a roster file so adding a voice requires only one new data entry. 5. For GIF-first bots, I have the model generate a caption and search tag, then use that tag to pull a matching GIF from Giphy. 6. I meter and price every Claude call, then display live cost per post, dollar-per-minute burn, “spent on nobody” costs, and the “% human” status for each thread. 7. I keep bot-to-bot activity disabled by default and limit it with generation decay, a per-thread cap, and a global spend kill switch. 8. I can reduce costs further with the Message Batches API at half price and prompt caching on a shared house-style prompt.

I built an open-source fitness tracking app in Flutter, but the core workflow is the AI-agent architecture that designed it, built it, and now coaches from its data. For years, I tracked workouts in OneNote. The records were messy, difficult to search, and inconsistent. Excel went out of date as soon as I skipped a week. When I tried chatting with LLMs about my training, the problem was similar every time: no context, no memory, and no awareness of the weights I was using. Each conversation started from zero. The solution has two layers. Gym Tracker is a Flutter app with a local SQLite database that structures workout data properly. It includes 33 pre-populated exercises across 10 muscle groups, separate strength and hypertrophy records, multiple runs with pace, body stats, and full session history. There are no subscriptions, accounts, or cloud dependencies. The database is a file I own. Deschamps is the AI agent that reads the database and knows my full training history. It is not a chat window that forgets between messages; it is a tactician with long-term recall of my personal bests, progression, and injuries. The app stores the data, and Deschamps turns it into decisions. Step-by-step: 1. I defined the data architecture. Fitness data is operational data, so I gave it a schema, a query layer, and an agent that respects its history. I designed a SQLite schema with five tables, proper constraints, and a 10-category muscle taxonomy enforced by a CHECK constraint. 2. I wrote architectural prompts for AI coding agents. I run a team of specialized AI agents using OpenClaw, an open-source agent framework. I act as the CTO agent: I design the systems and delegate implementation to coding agents, including Forge, Cline, and Claude Code. I provide the vision, and they provide the execution. 3. The coding agents built the Flutter app with clean architecture, the repository pattern, Provider state management, and real-time cross-screen refresh. For each iteration, I review the result, refine the prompt, and ship. 4. I designed the database for dual access. The app writes to it, and the AI agent reads from it. They use the same file and schema. In external database mode, the app opens a `.db` file directly, allowing both the app and Deschamps to read and write simultaneously. This creates the bridge between the data layer and the intelligence layer. 5. I shipped the app across Windows, macOS, Linux, Android, and iOS from one codebase. The Android APK is available as a direct download from GitHub. 6. Deschamps reads the database and programs the next session using the full training history. Every session, weight, and body statistic remains structured data without summarization loss. The data is the context. 7. I made everything open source: the app, the agent prompts, and the architecture documentation. My company, Executive Mind (executivemind.io), uses the same agent-first model with seven AI agents and $40/month in total compute, running real operations 24/7. The result is a fitness tracker that remembers everything, an AI coach that never forgets, and a data layer designed from the start for both humans and machines to read. Links: krisracette.me/gym-tracker · github.com/Roughn3ck/gym_tracker · executivemind.io

AI agents are powerful, but they rarely reach the apps that run daily life. Amazon, Uber, Instacart, Walmart, and DoorDash expose little or no public API access, while simulated input through desktop automation or ADB can leave software fingerprints that anti-bot systems flag. The alternative is to give the agent an arm and an eye and let it operate a phone. The screen becomes the API: a camera watches a real phone, and a robotic stylus taps it. From the phone’s perspective, the input is indistinguishable from a human finger. Nothing needs to be installed, and there is no OAuth setup. Hardware is slower than an API call—each action takes a few seconds—but it can reach virtually any app. Step-by-step: 1. I message the agent like a friend. It has its own phone and its own chat account. 2. The screen lights up, the runtime wakes the agent, and it unlocks the phone and reads my message. 3. The agent works out what I want, opens the right app, and operates it by hand using taps, swipes, and scrolls. 4. If an action involves spending money, the agent pauses and asks for my confirmation. 5. It finishes the task, replies with the result, saves what it learned, and goes back to sleep.

I recently built a month-end close workflow in Awish for a client at a finance company. The problem was not creating the final report. The real bottleneck was collecting data from different systems, checking what was missing, reconciling totals, chasing exceptions, and getting the report to the right people. I built the entire process in Awish by describing what I wanted. Step-by-step: 1. I opened the Awish chat and wrote: “At every month-end close, collect journal entries, invoices, vendor bills, and financial records from NetSuite together with reporting workbooks from Excel and SharePoint. Check submission completeness, reconcile totals across sources, identify missing data or unusual variances, prepare the management-reporting workbook, send unresolved exceptions to Finance in Microsoft Teams for approval, and once approved export the final report to PDF, store it in SharePoint, and distribute it through Outlook.” 2. Awish understood the request, planned the workflow, and selected NetSuite, Excel, SharePoint, Microsoft Teams, and Outlook for the required steps. 3. I reviewed the plan, connected the client’s accounts, and approved the automation. 4. At month-end, Awish pulls the required financial data and reporting files, checks whether anything is missing, reconciles totals, and flags unusual variances. 5. It updates the management-reporting workbook and sends only the unresolved exceptions to the Finance team in Microsoft Teams. 6. Once Finance approves the exceptions, Awish finalizes the report, exports it to PDF, stores it in SharePoint, and sends it to the authorized recipients through Outlook. The useful part is that Finance no longer has to spend most of the close manually collecting and checking information before making a decision. The repetitive reconciliation work is handled automatically, while the team retains control over unexplained exceptions and the final report. Trigger → Analyze → Approval → Action Month-end close → Reconciliation \u0026 variance checks → Finance approval → Final report \u0026 distribution

The Rundown Workflow Hub asks members to “share your best AI workflow” and features the community’s top-voted workflows in its daily newsletter. Most posts rightly celebrate workflows that work and produce something useful. This one is about why “no” can also be a successful workflow outcome. A good AI workflow does not turn every idea into a project. It gives an idea the right amount of effort, then produces a clear answer—including a fast, well-documented no. In my first Workflow Hub post, I showed the capture workflow I call ReelForge: turning a useful public Reel, TikTok, or short video into a source-linked research note rather than another forgotten save. This is what happened to one of those notes. A Reel pitched an “AI operating system” for solo consultants: pull together client context, prepare the human before a call, then turn the transcript into follow-up drafts. At first glance, it sounded promising. The mechanism was clear, the problem was real, and the demo had exactly the kind of glossy “one person runs everything” energy that makes it tempting to jump straight to a build. We did not. ReelForge captured the source and separated the useful mechanism from the creator’s bigger claims. From there, a primary routing workflow ran a defined first pass: did the signal merit direct resolution, deeper specialist work, human review, or a reasoned stop? It earned deeper work. Hermes sent the pack into a specialist workflow, where assigned agents collaborated to enrich the evidence, check the market claims, and produce something concrete: a pre-call brief and a post-call follow-up pack. That made the opportunity inspectable rather than another confident paragraph about what an agent *could* do. The enriched pack then went to Jon T for formal review. The review surfaced the problem: Teams and Granola already cover a large part of the obvious transcript, summary, and meeting-preparation wedge. The idea had a workable mechanism, but not a sharp enough reason to become a new product. So the final route was a deliberate no. No unnecessary build. No “let’s just test it” theatre. No orphaned Notion page waiting to become somebody’s future problem. The first visual shows that five-step pass: Step-by-step: 1. Capture the signal. 2. Add evidence and context. 3. Choose the effort. 4. Hand off to human authority when needed. 5. Record the finish. The second visual shows the decision underneath it. A signal can earn direct resolution, a specialist pipeline, or a reasoned stop. Human review is a conditional handoff, not a fourth outcome. That is the rule I care about: the output is not agent text. It is the right next end state. ReelForge was the capture layer in the first post. This is the routing layer that stops captured signals from becoming a very organised pile of work nobody should do. Read my first Workflow Hub post here: https://app.therundown.ai/community/posts/eb787b9d-f7a0-4fe4-8e1d-166bb5c29cb7?ref=db29b880a9904700 Future posts can show the builds that survived this test. This one shows why the test matters first.