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

I had a file sitting on my desktop that Claude Code needed to see—a spreadsheet, a PDF, or a screenshot someone sent me—but a terminal had nowhere to drop it. Typing the path was the only option. In WSL, that meant rewriting `C:\Users\me\Desktop\report.xlsx` as `/mnt/c/Users/me/Desktop/report.xlsx` by hand every time. I set up two folders at the root of my Claude Code workspace: `_inbox/` for files going to Claude and `_outbox/` for files coming back to me. The names are from the workspace’s point of view, so the direction is never ambiguous. I also added a single line to `CLAUDE.md` so Claude knows where to leave things: "Save deliverables meant for me (reports, exports, drafts) to _outbox/." That one line handles the entire return trip. For the desktop handoff, I installed a small window pointed at the workspace folder. Disclosure: the window is mine—claude-work Desk, open source and free, at github.com/tact0225/claude-work-desk. Setup takes about two minutes and requires no terminal. Anything dropped onto it is copied into `_inbox/`. If you’d rather not install anything, you can drag files into `_inbox/` with Explorer or Finder; every other step still works. Now I drag files onto the window instead of typing a path. The file lands in `_inbox/`, and the window logs it with a timestamp so I can see that it actually arrived. Then I tell Claude, "check _inbox"—no paths and no `/mnt/c` rewriting. When Claude finishes, it saves the results to `_outbox/`. The window watches that folder and marks anything new in the tree until I open it, so finished work announces itself. I no longer interrupt Claude to ask, "Is it done, and where did you put it?" Step-by-step: 1. I created `_inbox/` and `_outbox/` at the root of my Claude Code workspace, using the workspace’s point of view to define the direction of each folder. 2. I added `"Save deliverables meant for me (reports, exports, drafts) to _outbox/."` to `CLAUDE.md`. 3. I installed claude-work Desk and pointed its desktop window at the workspace folder. Alternatively, I can use Explorer or Finder to place files directly in `_inbox/`. 4. I drag files onto the window, which copies them into `_inbox/` and logs their arrival with a timestamp. 5. I tell Claude, "check _inbox". 6. Claude saves finished results to `_outbox/`, where the window marks new files until I open them.

The available task apps don’t meet my needs, so I’m building a personal dashboard to manage my tasks from email.

AI coding tools can build quickly, but they can also build the wrong thing quickly. Starting implementation from a vague feature request leaves important decisions about scope, architecture, edge cases, success criteria, and expected behavior to be made implicitly during coding. I created a spec-generator agent that sits between an idea and implementation. I give it a feature request, product vision, or rough description of what I want to build. It investigates the existing project, identifies missing decisions and constraints, researches external dependencies when necessary, and turns the request into a detailed specification that another AI agent can implement without having to guess what I meant. The finished specification becomes the source of truth for the rest of the development workflow. Step-by-step: 1. I give the spec-generator the feature or product idea I want to build, along with any existing requirements, vision documents, or constraints. 2. I have it inspect the existing project before proposing a solution. It needs to understand the current architecture, conventions, capabilities, and relevant prior decisions rather than designing the feature in isolation. 3. I have it identify ambiguities and missing decisions, including questions about users, behavior, scope, dependencies, edge cases, data requirements, integrations, and what is explicitly out of scope. 4. I have it research external technologies, APIs, libraries, or platform capabilities when the design depends on facts that cannot be determined from the repository alone. 5. I have it translate the idea into a layered specification: first the product purpose and desired outcomes, then the technical architecture, and finally the detailed implementation requirements. 6. I have it define measurable success criteria and acceptance tests so that “done” means something concrete rather than simply “the code was written.” 7. I have it persist the finished specification in the project so developers or coding agents can treat it as the source of truth during implementation. 8. I pass the specification through a separate review or validation step before coding begins, resolving gaps or contradictions in the spec rather than discovering them halfway through implementation. Instead of asking an AI coding agent to interpret a rough idea while it writes code, I separate figuring out what should be built from building it.

If you have a large jar of pennies or other coins, spread them out and take a picture. Upload the picture to your AI app and ask it to identify any coins that may be valuable. This is much easier than checking them one by one. Step-by-step: 1. Spread the coins out so they are visible. 2. Take a picture of the coins. 3. Upload the picture to your AI app. 4. Ask the app to identify any coins that may be worth more than their face value. 5. Check the identified coins individually to verify their value.

Ten days ago, I posted about keeping a `HANDOFF.md` so an AI film project doesn't lose the decisions it has already made. This is the other half, and it turned out to be the expensive one: the decisions that haven't been made yet. Credit where it belongs: Tony Ojeda posted a spec-generator agent that sits between an idea and implementation. The rule I borrowed is his: the agent inspects what already exists before proposing anything. I applied it to film production instead of code. I pointed an agent at my production documents for a short film I hadn't started generating and asked it to identify what was still undecided, what each item affected, and what would break if it were decided late. It came back with ten open decisions. One of them was worth the whole exercise. My environment description is locked verbatim across all 40 shots so the world stays identical. The film is called *The Thaw*. Whether the ice visibly melts during the film is written down nowhere. If I decide that in week three, all 40 keyframes get regenerated at once. I would have found out around shot 12. The counterintuitive part is who writes the list: not me. Asking the person who already has the whole film in their head what's missing gets you very little, because they have all of it—and that's exactly why they can't see the hole. The list has to come from something that only knows what's written down. Step-by-step: 1. I put the open questions in section 0 of the handoff, above everything else, so it's the first thing read and the first thing emptied. 2. I have the agent write that list, not me. It reads every existing document for the project and returns only what it cannot know from them. 3. I have it return three things for each item: what's undecided, which shots it affects, and what breaks if it's decided late. The third column sets the priority. 4. I have it sort by what costs the most to change afterward, not by what's easiest to answer. 5. I keep one hard rule: while an open question affects a shot, that shot doesn't get generated. The question gets decided, or deferred in writing with the cost of being wrong stated. 6. Every answered item leaves section 0 through one of two doors: into the closed canon or into the rejected list. Nothing is simply deleted. 7. I ask specifically about the things that go missing every time: the rule of the world; the physical scale of anything impossible, such as whether the character can touch or climb it; any object appearing in more than one shot; screen direction; how it ends; who speaks and in what voice; and the delivery format. 8. When it finds nothing real, it says so. A list padded to look thorough is worse than an empty one. The version I'd used for a year ran at the end of a session and recorded what got decided. Running it at the start, focused on what hasn't been decided, is the same document pointed the other way—and it's the direction that saves money.

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.

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.

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.

Getting answers from company data usually requires someone who knows SQL, understands the database, and has enough business context to interpret the results. This creates a bottleneck: business users depend on analysts for questions they should be able to explore themselves. I turned Claude Code into a self-service data analyst by giving it direct, read-only database access and configuring its behavior through a `CLAUDE.md` file. The file gives Claude business context, explains which analytical tables contain different types of information, tells it how to investigate questions, and defines how results should be presented. Users can then ask business questions in plain English. Claude determines what data it needs, queries the database, investigates the results, creates visualizations, and explains what it found. Step-by-step: 1. Create a dedicated analysis folder and add a `CLAUDE.md` file that defines how Claude should operate as a data analyst. 2. Give Claude enough business context to understand the company, its terminology, important metrics, and how the business operates. 3. Document which analytical tables or views it should use for different types of questions. Curated analytics tables work particularly well because Claude doesn't need to decipher the entire production database. 4. Give users read-only database permissions and explicitly instruct Claude to perform read-only operations, such as `SELECT` queries only. Never give the agent permission to modify production data. 5. Tell Claude how to use the command line to query the database. Include instructions to help users install or configure it if it isn't available. 6. Define an analytical process for Claude to follow. Rather than simply generating one SQL query, instruct it to investigate the user's question, examine the results, and run additional queries when necessary to understand what is happening. 7. Define the expected output: answer the question, explain the important insights, and create appropriate visualizations to make the findings easy to understand. 8. Open the folder in the Code tab inside the Claude Desktop app, which I find to be the best interface, and ask questions naturally, such as, "Why did revenue decline last month?" Claude handles the investigation from there. Instead of building and maintaining a custom analytics application, you can turn a general-purpose AI coding agent into a capable self-service analyst with access to your existing data warehouse. Users ask questions in plain English while Claude handles the SQL, investigation, visualization, and explanation, giving nontechnical users a more direct way to explore company data.

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.

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.

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.

I’m learning Chinese online and record all my lessons. I asked Claude Code to transcribe the recordings and walked through the process of using the Whisper API with its guidance. Then I asked Claude Code to analyze the transcripts and identify mistakes I could fix that would make a big difference. It found that my teachers had not corrected several phrases I was repeating. Claude Code taught me which phrases to practice, and I’m now making fewer mistakes. Step-by-step: 1. I recorded all of my online Chinese lessons. 2. I asked Claude Code to guide me through transcribing the recordings with the Whisper API. 3. I asked Claude Code to analyze the transcripts for mistakes that would make a significant difference if corrected. 4. I reviewed the repeated phrases my teachers had not corrected. 5. I practiced the phrases Claude Code identified, which helped me make fewer mistakes.

I turned my company’s business continuity (BCEP) policy into an app that tracks storms, sends SMS updates, and automatically triggers policy actions. When a storm, tornado, or other emergency is reported within range of one of our office locations, the app sends SMS alerts to affected employees. It also triggers policy actions to prepare for office closures and safety check-ins, while maintaining an audit trail and compliance reporting. Step-by-step: 1. The app monitors reports of storms, tornadoes, and other emergencies within range of our office locations. 2. It identifies the affected employees and sends them SMS alerts. 3. It automatically triggers policy actions to prepare for office closures and safety check-ins. 4. It maintains an audit trail and generates reporting for compliance.

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 connected Claude Code to Apify's API to scrape high-performing content from IG/TikTok for ad creative inspiration, and to ElevenLabs' API to automatically transcribe videos — so I can analyze not just visuals, but the exact hooks, pacing, and language top creators are using. From there, I developed a scriptwriting system that takes rough thoughts on a hook and angle and turns them into ad scripts, drawing inspiration from winners and applying proven copywriting principles. After generating, it also grades itself against a 12-point rubric. If it doesn't score at least 90%, it rewrites until it does. I then feed it back in and say, "This is the final version." It analyzes the changes I made and updates its understanding of my style. Step-by-step: 1. I connected Claude Code to Apify’s API for collecting high-performing Instagram and TikTok content. 2. I connected ElevenLabs’ API so the workflow could automatically transcribe each video. 3. I analyzed the winning examples for their hooks, pacing, visual patterns, and exact language. 4. I fed the system a rough hook and angle and had it draft ad scripts using those proven patterns. 5. I created a 12-point grading rubric and required a rewrite whenever a script scored below 90%. 6. After making my own final edits, I fed the approved version back into the system so it could learn my style.

My AI digest looked perfect and was quietly wrong. What actually fixed it. Every run succeeded. Every dashboard was green. And the content was still wrong. My digest invented "AI Moat Brief", a newsletter that does not exist. It reported scan counts nobody measured. It resurfaced week-old stories as fresh headlines. Here is what broke, and what fixed it. The sorting used to happen in my head: skimmed subject lines, unopened tabs, quiet guilt. The Signal is one email at 08:00: a single Make scenario calling Claude Sonnet through OpenRouter. It reads the last 24 hours of my RSS feeds and newsletters, keeps what touches what I am actively building plus the domains I need to stay current in, and arrives in the language I actually think in. Core items end with what it means for my work. Five to ten minutes, and I know where to go deep today. Structurally it looks like this, minus the content, rendered in English for this post (Image 1). No real edition is shown; section names and sample lines are illustrative. The dangerous failures were never pipeline failures. They were content failures, and the cause is structural: an LLM summarizing newsletters that already summarize primary sources is third hand by construction. Every hop strips attribution and adds confidence, and when data goes missing the model fills the gap the way LLMs do: fluently. Valid HTML, confident tone, green pipeline, wrong content. Image 2 is that whole failure class in one frame. Three rules closed the gaps I caught, all live in production: Step-by-step: 1. Verbatim or nothing. A source name is copied character for character, and a link exists only if that exact URL is in the input. The model copies; it never composes. 2. The model never generates metrics. Every count the report shows is injected by the pipeline after the model returns. 3. Recycled news gets demoted. A recap of recaps gets one line at most, and is dropped when the underlying story falls outside the collection window. Rules 1 and 3 lean on the prompt, and that is why the counters exist. The pipeline writes a hidden HTML comment into every email it sends: items, links, urls, cost, finish status. That line caught what I could not see. In one run, the published-links counter and the leftover-urls counter read 45 and 435: the only sign a new cleanup step was a silent no-op. Another morning the model stopped at 15,999 tokens against a 16,000 cap, one token from an email cut off mid-sentence. On the morning I wrote this they agreed, 21 links and 21 urls, and boring is the goal. Image 3 is that morning's actual comment, with the same two counters from the no-op run. The run itself has a dead man's switch on Healthchecks.io, so a missing 08:00 email reaches me before I notice. Honest limits: the $0.31 per report is a fresh measurement I am still validating, and I have not proven these rules hold as the source set scales. There is more behind every part of this; I would rather share it where it is wanted. Ask and I will put it in the comments: the three rules in full, the exact cost and what drives it, what this replaced in my day, how it compares to what is on the market, or the ugliest of the 15 documented bugs. I am sharing this because I doubt I am the only one building fragile things behind the scenes, and monitoring text is harder than monitoring uptime. What content-level checks do you run on LLM output, the kind pipeline monitoring cannot see? Real thresholds and embarrassing failures especially welcome.

I built AllegraMente, a complete, free iOS cognitive training app, solo with Claude Code. It includes 11 exercise areas, 83 articles in five languages, and no tracking. My workflow starts with a new feature or content idea, a new exercise type, or an in-depth article about how memory works. Planning and execution stay separate, and the instruction document serves as the contract. Because everything is specified upfront, Claude Code almost never goes off track. Step-by-step: 1. I plan the feature with Claude in chat, define the data models and UX, and fact-check every scientific claim against primary sources before writing anything. 2. I package the result into one self-contained Markdown instruction document containing file paths, specifications, localization keys for all five languages (IT/EN/ES/FR/DE), edge cases, and acceptance criteria. 3. I create a Git restore point. 4. I give the document to Claude Code, which implements the feature end to end using SwiftUI, SwiftData, and MVVM. 5. A small script sends me a Telegram notification when the task is complete. I review the diff and test the app on a device. 6. I ship by creating an archive with `xcodebuild` and uploading it to the App Store with Transporter. This process is how I shipped 11 exercise areas, 83 articles in five languages, and a complete editorial system as a solo developer.

My husband and I run a short-term rental business managing two properties we own in Harpers Ferry, WV. A major part of the job is using PriceLabs, a dynamic pricing and revenue management tool that tracks our properties’ performance against the market, including occupancy, prices, and revenue, and recommends price changes when needed. Previously, we had to log in and review multiple dashboards to make informed decisions. Now, every two days we receive a concise morning briefing that summarizes how the month is going and what needs attention. It’s one of the first things I read in the morning, so I know what to adjust in real time. Step-by-step: 1. I connected the data sources Claude needs through MCP connectors: PriceLabs for reservations, pricing, and market data, and Gmail for drafting the output. 2. I wrote the instruction prompt Claude runs each time. This took the most time to develop. 3. I defined the format and length: a short, numbers-first brief of about 200 words, beginning with “How This Month Is Going” and “What Needs Attention,” with no filler or pep-talk tone. 4. I solved delivery by having the routine draft the briefing as an email with a recognizable subject prefix, such as “Iconic Chalet Briefing — Mon, Aug 10.” Because Claude’s Gmail connector can create drafts but not send emails, a separate time-triggered Google Apps Script watches for drafts with that subject prefix and sends them automatically. 5. I registered the workflow as a scheduled Routine. That combination makes the process feel automatic from end to end.