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

I built a weekly interactive training-course generator for my 10-year-old son and eventually landed on a much simpler final version than where I started. I wanted a way to teach him practical safety and life skills, starting with how to swim confidently and what to do if he gets into trouble in the water. I needed something more engaging than simply talking at him, but writing a polished, interactive lesson from scratch every week was not sustainable. First, Claude and I designed a single interactive HTML course as a proof of concept. It was a swim-safety course with a branded look, including a custom color palette, fonts, and a progress tracker styled like pool lanes. The course was divided into modules: a welcome screen, a comfort-and-basics lesson, a step-by-step skills walkthrough, a safety checklist, a “what to do if something goes wrong” module, a quiz, and a certificate at the end. The “what to do if something goes wrong” module was the most important part. Once the course worked, I wanted to reuse the same format for a new topic every week. Claude first built a version that called the Claude API live from inside the page to generate new content on demand. However, it only worked while the page stayed open inside Claude.ai, and occasionally a section failed to generate cleanly. We pivoted to a simpler approach. Instead of using a live tool, Claude documented the entire course format—including the visual identity, module structure, tone, and content rules—as a standing “brief” document. Each week, I open Claude Cowork, paste in the brief and that week’s topic—bike safety, fire safety, or whatever is next—and Cowork returns a finished, fully self-contained HTML file. There is no app to babysit and no live API call; I can simply open the file and hand it to my son. The result is a repeatable, no-maintenance weekly workflow for turning any topic into a polished interactive lesson for my kid. Step-by-step: 1. I identified a need for more engaging lessons on practical safety and life skills, starting with swimming and water safety. 2. I worked with Claude to create a proof-of-concept interactive HTML swim-safety course. 3. I structured the course into a welcome screen, comfort-and-basics lesson, skills walkthrough, safety checklist, emergency-response module, quiz, and certificate. 4. I tested a live-generation version that called the Claude API from inside the page, then noted that it only worked while open inside Claude.ai and that sections sometimes failed to generate cleanly. 5. I had Claude document the course’s visual identity, module structure, tone, and content rules in a reusable brief. 6. Each week, I open Claude Cowork, provide the brief and a new topic, and receive a finished, self-contained HTML course file. 7. I open the file and give the interactive lesson to my son without maintaining an app or making live API calls.

Everyone I know who runs a second brain uses Obsidian. The app is free, but sync is a subscription, and most AI integrations quietly assume you have it. I went another way: Joplin, which is free and open source, with an agent that reads my notebook through Joplin’s REST API, files my INBOX every morning while I sleep, and answers questions strictly from notes I actually wrote. It costs nothing beyond a VPS I already run, and the notebook still opens like a notebook. I use Hermes Agent on the VPS, Dropbox to sync notes between my devices, and Python scripts to connect the notebook and the agent. Every capture goes through `joplin_capture.py` and lands in a single INBOX folder with a source and timestamp attached. Captures can come from a Discord link, a thought from my phone, or a page from the web clipper. The process takes under ten seconds and requires no filing decisions at capture time, because filing at capture time is where second brains die. Joplin already ships with a REST API. I enable it with one setting and one token; the notebook then exposes HTTP on localhost:41184 with token authentication on every call. The same server powers the official web clipper, so this enables infrastructure I use anyway. There is no plugin, cloud service, or subscription. `joplin_filer.py` runs daily at 07:00 and uses a deterministic classifier to score each INBOX note against my existing folders. It uses token coverage rather than Jaccard, which dilutes single-token folders. Confident matches above 0.5 are moved into place: a hosting page goes to the hosting folder, while a security note goes to the security folder. Low-confidence notes stay in INBOX with the `needs-review` tag. Every move is logged to a FILER LOG note in the `__SYSTEM` folder, making the process auditable. The filer never deletes anything. I ran it in dry-run mode for a week before letting it touch a single note, and I recommend doing the same. When I want to know what I have learned, `joplin_ask.py` searches the corpus, reads the top notes in full, and answers with the note titles attached. It answers strictly from retrieved content. If the top hits are irrelevant, I refine the query before concluding there is nothing. It never invents a source, which matters when you write about security for a living. After each working session, `joplin_agent_log.py` prepends a digest to an AGENT LOG note in `__SYSTEM`. The log is newest first, append only, and syncs to my devices like everything else. The agent’s memory records what we did, decided, and deferred in the same place as the notes. The whole build is on GitHub: github.com/ciberjohn/mysecondBrain. It includes five Python scripts and the `joplin-brain` skill, which is the operating manual in a format another agent can load and follow. Step-by-step: 1. I enabled Joplin’s built-in REST API with one setting and one token. It serves HTTP on localhost:41184 with token authentication on every call and also supports the official web clipper. 2. I pointed Hermes Agent on my existing VPS at the Joplin REST API. 3. I routed every capture through `joplin_capture.py` into a single INBOX folder, attaching the source and a timestamp. Captures can come from Discord, my phone, or the web clipper. 4. I configured `joplin_filer.py` to run daily at 07:00 and score INBOX notes against my existing folders using token coverage rather than Jaccard. 5. I moved matches with scores above 0.5 into their folders, while leaving low-confidence notes in INBOX with the `needs-review` tag. 6. I logged every move in a FILER LOG note in the `__SYSTEM` folder and ensured that the filer never deletes anything. 7. I ran the filer in dry-run mode for a week before allowing it to move a note. 8. I used `joplin_ask.py` to search the corpus, read the top notes in full, and answer questions with the source note titles attached. When results were irrelevant, I refined the query. 9. After each working session, I used `joplin_agent_log.py` to prepend a digest to the newest-first, append-only AGENT LOG note in `__SYSTEM`. 10. I used Dropbox to sync notes between my devices and the REST API to move notes between Joplin and the agent—two separate pipes carrying the same notes in different directions.

I love playing poker, both online and live. One month, I performed poorly. Although it felt like the cards were running badly, I wondered whether I had developed a problem in my game and was blaming my losses on bad luck. I asked around, including asking AI, whether a tool existed that could measure luck from poker hand histories. The unwelcome answer was that it did not. I'm not a coder, but after doing some research into vibe coding, I started building a luck-detection app in a Claude chat. Claude built the UI directly in the chat window and advised me on the formulas I was using to calculate luck for the cards dealt, my performance on the flop, and my performance when I went all in. All three metrics have strong averages, and luck is what varies them. I used a bell curve to model hand outcomes and a Monte Carlo simulator, which Claude suggested and executed, to evaluate all possible outcomes. The result astonished me because it was so useful. I immediately fixed two major leaks in my game and felt better knowing that bad luck really was the main problem affecting my results. I liked the tool so much that I decided to turn it into a full web app with Claude Code, and now an iPhone app that I may let other people use for free. I also had a lot of fun building it—except for learning how to use Xcode. That was a pain, even with step-by-step guidance from Claude. Step-by-step: 1. I reviewed a month of poor poker results and questioned whether bad luck or problems in my game were causing the losses. 2. I researched whether a tool existed that could measure luck from poker hand histories and learned that I would need to build one myself. 3. I used vibe coding to start building a luck-detection app in a Claude chat. 4. I had Claude create the UI and advise on formulas for evaluating cards dealt, flop performance, and all-in performance. 5. I used a bell curve to model hand outcomes and a Monte Carlo simulator to evaluate possible outcomes. 6. I used the results to identify and fix two major leaks in my game and confirm that bad luck was also affecting my results. 7. I expanded the project into a full web app with Claude Code and then began building an iPhone app, working through the added challenge of learning Xcode.

I built a system that reads my AI newsletters every morning and turns them into a searchable catalog of AI tools, plus a chat website where I can ask questions about the catalog in plain English. The system has two parts: a workflow that collects the information and a website that answers questions about it. I subscribe to several AI newsletters, and each issue mentions five or ten interesting tools. I would read about one and think, “I should remember that.” Months later, I would vaguely remember it but have no quick way to find it. I wanted a repository of these AI tools that I could search easily. The collector is a scheduled Claude Code Routine that runs once a day. It searches Gmail for newsletters from the last 24 hours and reads each email in full. It extracts every AI tool’s name, description, category, official link if present, and source newsletter. It skips non-AI items and pure ads but keeps sponsors that are genuine tools. Before adding anything, it checks for duplicates. New tools are added under the appropriate category in alphabetical order. If an existing tool has fresh details, its description and “last updated” date are refreshed. Tools mentioned by three or more sources receive a “Highly Mentioned” tag, which is a useful signal for what is catching on. The workflow also creates categories when new tools do not fit into an existing one. The workflow commits and pushes the catalog to a private GitHub repository, then posts a summary to Slack. The catalog is a single Markdown file—plain text, human-readable, and versioned in Git, with no database. The chat website displays the tool count, category count, and last-updated date, along with clickable example questions. If I ask, “Is there anything for voice AI?” it returns a written answer listing every match with descriptions and working links. The site is a React single-page app on Netlify with two small backend functions: one returns the statistics, and the other handles chat. When I ask a question, the backend fetches the Markdown file from the private repository, sends it to Claude along with my question, and returns the answer. To recreate it, you’ll need a GitHub account, Netlify (the free tier is fine), an Anthropic API key, and Claude Code. The routine prompt is the most important part. It names the exact newsletters, lists the fields to extract, and explicitly says: never invent a URL, never delete an entry, and only add or update. Vague instructions produce files that degrade over time. I learned a few things the hard way. Newsletters deleted before the workflow runs may cause it to report “nothing new,” so the logic should also check Trash or Deleted items. Tokens expire, and mine quietly expired, which caused the search site to stop working. Choose a long expiration period and record the date. Also, explicitly say “never invent a URL,” or the workflow may produce plausible links that go nowhere. It now runs every morning without me. When I need something, I ask a question and get an answer in seconds instead of trying to remember which newsletter, and which month, mentioned the tool I’m thinking of. Step-by-step: 1. I created a private GitHub repository with a starter Markdown file containing “Last updated” and “Total tools” fields, category headings, and consistent fields for each tool. 2. I wrote a Claude Code Routine prompt that names the newsletters, specifies the fields to extract, and instructs the workflow never to invent a URL, never to delete an entry, and only to add or update tools. 3. I scheduled the routine to run daily with Gmail access. 4. Each day, the routine searches Gmail for newsletters from the previous 24 hours, reads them, extracts AI tools, skips non-AI items and pure ads, preserves genuine tool sponsors, and checks Trash or Deleted items when necessary. 5. The routine checks for duplicates, adds new tools alphabetically under the right category, updates existing tools with fresh details, creates categories when needed, and applies the “Highly Mentioned” tag to tools found in at least three sources. 6. The routine commits and pushes the Markdown catalog to the private GitHub repository and posts a summary to Slack. 7. I built the frontend with Vite and React, including a statistics header, a scrollable message list, an input box, and example questions. 8. I added two backend functions: one for statistics and one for chat, with the GitHub fetch handled by a shared helper with a short cache. 9. I created a fine-grained, read-only GitHub token limited to the single repository. 10. I deployed the site to Netlify with the required keys stored as environment variables rather than in the code. 11. When I ask a question, the backend fetches the Markdown catalog, sends it to Claude with my question, and returns the matching tools, descriptions, and links.

I teach and direct a required general education public speaking class at a small college. I’ve built the course around critical inquiry, critical thinking, and public advocacy of a localized problem. Over the years, I’ve noticed that students are increasingly reluctant to engage with the underlying problem. They are often content to identify a problem with enough certainty that they assume their perspective is obviously shared by everyone else. They may also believe that their preferred sources are more certain or credible, leading them to build a case based only on their limited perspectives. With the help of ChatGPT, I built an AI tool that guides students through the problem- and solution-discovery process. It begins with a general question: “what is your topic and what is the problem?” Students often respond with a one-word or incomplete answer, such as “poverty,” “crime,” or “the high cost of education.” These answers do not identify the topic’s deeper dimensions, the extent of the harm, or who is affected by the issue. The AI pushes back on these statements and helps students explore the issue in greater depth. It consistently asks, “what do you mean by x?” I constrained the AI to draw most of its knowledge from the coursepack I wrote for the class, which outlines the assignments, lessons, and instructional content. This keeps the tone of the interaction and the examples provided to students aligned with the overall feel of the course. The AI does not create speeches, make outlines, or find sources for students. Instead, it asks questions that help them refine the direction of their speeches. Whenever possible, the AI also identifies alternative viewpoints from sources traditionally associated with the student’s own perspective. For example, if a student is advocating a progressive viewpoint, the AI may identify statements or research from progressive sources that disagree with that perspective. If the student is advocating a conservative viewpoint, it may identify statements or research from conservative thinkers that challenge the student’s position. This helps students recognize the complexity of ideas and understand that people on the same political, religious, or ideological side do not necessarily agree on every topic. As is often the case when I build GPTs, the 8,000-character limit requires me to move many instructions into a document that I upload to the GPT’s resources. ChatGPT is helpful when I decide which content belongs in the configuration and which content can go in an uploaded document. Step-by-step: 1. I designed the public speaking course around critical inquiry, critical thinking, and public advocacy of a localized problem. 2. I identified a recurring challenge: students often named broad topics such as “poverty,” “crime,” or “the high cost of education” without exploring the depth of the issue, the degree of harm, or who is affected. 3. With help from ChatGPT, I built an AI tool that begins by asking, “what is your topic and what is the problem?” 4. I configured the AI to push back on incomplete answers by repeatedly asking, “what do you mean by x?” 5. I constrained the AI to draw most of its knowledge from my coursepack, including the class assignments, lessons, and instructional content. 6. I instructed the AI to guide students with questions rather than create speeches, make outlines, or find sources for them. 7. I configured it to identify alternative viewpoints, including disagreements from sources traditionally associated with the student’s own political, religious, or ideological perspective. 8. Because of the 8,000-character limit, I moved some instructions into a document uploaded to the GPT’s resources and used ChatGPT to help decide what belonged in the configuration and what belonged in the document.

I’m 71 years old, retired from owning a large cattle-feeding operation, and fairly new to AI and software development. I’ve discovered that I really enjoy using AI to build practical tools in Replit. My latest project is an app for our church to help us oversee a $13.5 million renovation of a 65,000-square-foot former movie theater into our new church facility. I’m not a programmer or a construction expert, so I’m using AI to help bridge both gaps. I built the app almost entirely by describing in plain English what I wanted it to do, testing what it built, and working back and forth with AI to improve it. The app uses AI to read meeting notes, emails, texts, and general project updates and identify decisions, action items, important dates, budget changes, and project events. Nothing is accepted automatically. I review, edit, approve, or reject what AI finds before it becomes part of the project record. The app also keeps our budgets, documents, meetings, and project history together. My goal isn’t to replace our project manager or construction software. I want to see whether someone my age, with no programming or construction background, can use AI to build a useful tool for helping an owner understand and manage a complicated real-world project. Step-by-step: 1. I described in plain English what I wanted the app to do. 2. I used AI in Replit to build the app based on those descriptions. 3. I tested what AI built and worked back and forth with it to improve the app. 4. I designed the app to read meeting notes, emails, texts, and general project updates. 5. I use it to identify decisions, action items, important dates, budget changes, and project events. 6. I review, edit, approve, or reject every item before it becomes part of the project record. 7. I use the app to keep our budgets, documents, meetings, and project history together.

I used Claude and Nano Banana 2 to create a detailed landscaping plan for my property. The plan included precise recommendations for plant types and locations, soil testing, purchase lists, local suppliers, expected wholesale pricing, and photorealistic images of the mature planting beds. I refined the plan through 20–30 iterations, incorporating all of my requirements. Because I have previous experience working with landscape architects, I was able to use the AI-generated plan effectively and legitimately saved $5,000 in fees. Step-by-step: 1. I used Claude and Nano Banana 2 to develop a landscaping plan for my property. 2. I included requirements for plant types and locations, soil testing, purchase lists, local suppliers, expected wholesale pricing, and photorealistic images of the mature planting beds. 3. I refined the plan through 20–30 iterations until all of my requirements were incorporated. 4. I used my previous experience working with landscape architects to evaluate and apply the plan. 5. I saved $5,000 in landscape architecture fees.

I built a custom GPT with the personalities of Einstein, Lorentz, Planck, and Compton. Starting with Einstein’s 1920 Leiden lecture, I developed an ontology for physical space based on his description of the “new ether.” I began with E=mc2, E=hf, and my ontological modeling assumptions. I then repeatedly pushed ChatGPT to challenge those assumptions and interpretations logically and mathematically. We used numerous tool calls and reference sites to write and test the math. After many months of working on it in my spare time, the GPT now unifies equations that balance from the atomic scale to the black hole scale, with some remarkable revelations. I summarized much of the work in a paper written by my GPT and am happy to share it so others can expand, improve, and test the work. AI rocks. Step-by-step: 1. I built a custom GPT with the personalities of Einstein, Lorentz, Planck, and Compton. 2. I used Einstein’s 1920 Leiden lecture and his description of the “new ether” to develop an ontology for physical space. 3. I started with E=mc2, E=hf, and my ontological modeling assumptions. 4. I repeatedly challenged the assumptions and interpretations with ChatGPT, focusing on logical and mathematical consistency. 5. I used numerous tool calls and reference sites to write and test the math. 6. After many months of working on the project in my spare time, I summarized much of it in a paper written by my GPT. 7. I am sharing the work so others can expand, improve, and test it.

How I Use AI: Building a Client's Entire Document System From Scratch I run a boutique accounting practice, and one of my biotech clients — a preclinical oncology company — needed something I didn't have time to build by hand: a real, standardized document management system in SharePoint. Not just folders, but the rules behind the folders — a tagging taxonomy, a naming standard, guides for the team to actually follow it, and a clean way to organize documents for every vendor we work with. The kind of project that's easy to keep putting off because it's tedious, not because it's hard. So I used Perplexity's Computer agent as a genuine working partner on it, not just a search tool. Where it started I already had a first draft of a Tagging Taxonomy and a Document Management Standards document. I asked Computer to review both with an eye toward what a real accounting/finance team would actually need — GAAP-heavy, audit-ready, built for a lean biotech team that's going to scale fast. It came back with concrete recommendations (new functional areas I hadn't accounted for, cleaner naming conventions), and once I gave the go-ahead, it revised both documents into new, cleaner versions — taxonomy v1.1, standards v5.4 — complete with version histories so nothing got lost in the shuffle. Then it went further than I expected: 13 "START HERE" guide files, one for every top-level folder area, each explaining not just what goes where but why, with real examples. That's the part that actually makes a standard stick — nobody follows a rulebook they don't understand. Where it got real Here's the part I'd actually tell someone about: I tried uploading the whole folder structure to the client's SharePoint through the browser, and it failed — quietly, no big error, just close to 100 folders silently missing afterward. I was frustrated, and I said so. Computer didn't get defensive about it — it dug into why, compared the folders that made it against the ones that didn't, found the exact character-length boundary where things broke, and built me a PowerShell script that would fix it if I needed it. Then, while I was testing a fix, I discovered the real answer myself: dragging the folder from my hard drive straight into the OneDrive-linked folder in File Explorer worked perfectly, no script needed at all. When I told Computer that, it didn't just take my word for it — it went and calculated the actual path lengths involved to confirm why that method worked and the browser upload didn't, so I understood the real mechanism instead of just getting lucky once. That back-and-forth — me testing in the real world, it verifying the "why" — is honestly the most useful part of working with it. It's not just generating stuff and hoping it's right. The vendor folder win The last piece was the most tedious one I was dreading: building a dedicated document folder — vendor master file, agreements, POs, invoices, correspondence, the works — for every vendor worth tracking. I pulled a vendor spend report out of QuickBooks, sorted by dollar volume, and picked out the real vendors (CROs, law firms, key consultants) versus the noise (hotels, gas stations, one-off restaurant charges). I handed that list over, and Computer built me a script that took it from there: cleaned up messy vendor names (ampersands, apostrophes, trailing punctuation — all the stuff that breaks Windows folder names), handled the one legal name that was way too long automatically, and made sure nothing silently failed the way the original upload did. It tested the script against my actual vendor list before ever handing it to me, so I wasn't the guinea pig for its own bugs. 133 vendors, 1,463 subfolders, dropped into staging, dragged to OneDrive, and the count matched exactly — 1,474 on the nose once you add back the original template folder. That's not a "looks about right" number. That's a number I checked, twice. Why it's worth it Building this by hand for BreakthruMed Inc. — the folder architecture, the governance docs, 13 training guides, and a dedicated set of folders for 133 vendors — would realistically have taken me a couple of weeks of solid, focused work, not the few days I first assumed. Instead, it took about 28 hours spread across three weeks of back-and-forth, testing, and real-world validation, plus roughly $200 in extra usage on top of my regular subscription. That's a real cost, but a small one next to two or three weeks of my own time — and what I walked away with wasn't just a folder tree. It was a governance framework, training material my team can actually use, and two reusable scripts I'll put to work on the next client — a system I trust, because I checked it, and it checked itself

Most AI agents are built around general best practices. That’s useful, but it doesn’t mean they work the way I want them to. I’ve started using a simple calibration process to tailor my agents to my preferences. Instead of telling an agent what to do on each task, I have it interview me about how I like work done in its specific domain. A writing agent asks different questions than a research agent, and a strategy agent asks different questions than a coding agent. The goal is to make my working preferences part of how the agent operates. Step-by-step: 1. I pick an agent I use regularly, such as one for writing, research, strategy, coding, analysis, or career advice—especially where my personal preferences matter. 2. I ask the agent to interview me about how I prefer work to be done in its domain. A writing agent might ask about tone, structure, editing style, and how much pushback I want. A research agent might ask about source quality, depth, recency, citations, and how much synthesis I prefer. 3. I have the agent summarize what it learned and separate durable preferences from temporary or situation-specific ones. 4. I review the proposed changes and ask the agent to show me exactly how it wants to update its instructions or skills. I correct anything it misunderstood and explicitly approve the changes before anything is modified. 5. Once I approve the changes, I have the agent apply them to its instructions or skills so those preferences become part of how it works going forward. 6. I use the agent normally and pay attention to where it feels more aligned and where it still misses the mark. 7. When I notice recurring friction, I add or adjust the relevant preference instead of repeatedly correcting the same behavior task by task. 8. I repeat the interview periodically. My preferences, tools, and workflows change, so the agent should be able to ask which preferences are still valid, which ones I keep overriding, what has been annoying me, and what should be added or removed. The result is an agent that doesn’t just know how to do the job; it knows how I want the job done. Because every change is proposed and approved before it becomes permanent, the personalization stays intentional rather than turning into a collection of guesses about me.

I use reusable AI skills rather than relying on one long prompt or previous chat history. I start by describing the project in plain English and invoking a project-kickoff skill. It creates a live project specification containing the objective, scope, constraints, acceptance criteria, concerns, and next actions. For larger or more ambiguous work, I can opt into a scope-discovery skill. AI guides me through one important decision at a time, explains the trade-offs, recommends a sensible default, and records each accepted decision until the project is ready to implement. When delivery involves several dependent or risky steps, I can use a runbook-design skill. AI converts the agreed scope into a checkpointed implementation plan with validation, rollback, and clear points where my approval or testing is required. AI then executes the runbook, builds the solution, performs automated checks, and records what actually happened. I mainly provide direction, answer business or product questions, and complete the human acceptance checks that AI cannot genuinely perform itself. The skills live inside the project repository alongside the code, decisions, runbooks, and documentation. Codex only links to them at runtime, so the repository remains self-contained and does not depend on my local setup or previous conversations. This also makes the workflow portable. Another capable AI agent or a human engineer can read the repository, understand how the project should be managed, and continue the work without reconstructing everything from chat history. Step-by-step: 1. I describe the project in plain English and invoke the project-kickoff skill. 2. I use the scope-discovery skill for larger or more ambiguous work, working through one decision at a time until the project is ready to implement. 3. I use the runbook-design skill when delivery involves dependent or risky steps, creating a checkpointed plan with validation, rollback, and approval or testing points. 4. AI executes the runbook, builds the solution, performs automated checks, and records what actually happened. 5. I provide direction, answer business or product questions, and complete the human acceptance checks AI cannot genuinely perform. 6. I keep the skills, code, decisions, runbooks, and documentation together in the project repository so the workflow remains self-contained and portable.

I built a portal to manage lectures and applications for teaching sociology students at my university. It displays educational content, monitors attendance, supports pedagogical evaluation, and provides training in methodological skills. Step-by-step: 1. I built a portal for managing lectures and applications for sociology students at my university. 2. I added educational content for students to access. 3. I included attendance monitoring. 4. I added tools for pedagogical evaluation. 5. I incorporated training in methodological skills.

Training for a triathlon means three sports and a plan that is fiction by Wednesday. A static plan does not know I slept badly, skipped Tuesday's swim, or that Saturday's long ride wrecked me. Adjusting for that is what you actually pay a coach for. I wanted the adjusting without the retainer. So I built it in ChatGPT Work: a Project holding my plan, plus a scheduled agent run each morning that checks the plan against what my body actually did, then fixes the week. Disclosure: I built freddy, the connector feeding ChatGPT my training and recovery data, so I am not neutral here. Step-by-step: 1. Connect your sources at freddy.coach. For triathlon it is whatever records your swims, rides and runs: Garmin Connect, Polar, Suunto, WHOOP or intervals.icu. I use Oura for sleep and recovery, Garmin Connect for sessions, Hevy for strength. History backfills automatically, so the plan is built on your real training rather than what you tell it you did, which is usually flattering. 2. Add freddy as a custom connector: Settings, then Connectors or Apps and Connectors, then Add new, then custom MCP server. The URL is https://freddy.coach/mcp. Sign in and approve read access. Do it on the web; the mobile app cannot add custom connectors. 3. Connect Google Calendar and turn on write actions. This is the step people miss: write actions are off by default, so until they are enabled through action controls the agent can read your week but not change it. With writes on, ChatGPT Work creates and edits events. 4. Create a Project and put the durable facts in the project instructions: race date and distance, realistic weekly hours, immovable days, injury history, weakest discipline, and how blunt you want it. Long-lived facts only, never this week's session. 5. In the project, with freddy on, ask it to build the block: a periodised plan to race day, justified against your actual last 8 weeks rather than a textbook ramp. Keep the plan as a file in the project so every run starts from the same document, and have it write the week's sessions to the calendar with type, duration and intensity in the event body. 6. Schedule the daily run for mid morning, after you are up and your sources have synced. Last night's sleep does not exist anywhere until the watch or ring syncs, so a 5am run reports on the night before last. The standing prompt: "Using freddy, check whether I completed yesterday's planned session: pull yesterday's workouts with type, duration and intensity and compare against what the plan called for. Then pull last night's sleep and this morning's recovery including HRV and resting heart rate, plus training load over the last 7 days, compared against my own 30 day baseline rather than population norms. Then look at today's planned session on my calendar and decide whether it still makes sense. If it does, confirm in one line. If not, change the calendar event to the session I should actually do, put the reason in the event body, and update the plan file. Tell me what you changed and why, naming which source each conclusion came from. If two sources disagree, say so rather than averaging. Never compare HRV across different sources. If anything is ambiguous, such as an unrecorded session or a workout matching no planned one, ask me instead of guessing. Under 250 words." 7. Let it run a week before trusting it, and read what it changed rather than skimming. Expect to tune the instructions early: the usual failure is turning cautious after one poor night, fixed by a line saying a bad night is noise and to downgrade only on a trend or after a hard day. Two things to know. Depending on your approval settings, a run either makes the change or holds it for a tap. Know which you chose: it is the difference between waking to a changed calendar and a proposed one. And agent runs are metered, so keep the daily check narrow and save long reasoning for a weekly review. What surprised me is how good it is at catching the sessions I quietly did not do. It is easy to tell yourself you are on plan, harder when something reads yesterday's file and notes the intervals were short. Gotchas. Make it commit to one call on today's session; "listen to your body" is what you already had. Make it name the source behind each conclusion so you can tell a real finding from a confident guess. Never let it compare HRV across sources, because RMSSD and SDNN are different measurements, not different units, so mixing them looks meaningful while being nonsense. Scheduled runs auto-pause if ignored, so if the check stops arriving, look there before blaming the connector. It is not a certified coach and I would not rehab an injury with it. It is very good at holding a plan, watching what happened, and closing the gap before it becomes a lost week. Cost: freddy is free for one source, but this is cross source so it is the paid plan, $49 a year, on top of ChatGPT. Individual triathlon coaching runs a few hundred a month.

I used Claude Code to build a 13-agent workforce for generating micro-courses. Each agent has its own job description and a defined role in the workflow, which begins with document analysis and ends with a course package agent delivering a complete, interactive HTML prototype as a local file. The agentic workforce creates knowledge-check quizzes with corrective feedback. Each micro-course also includes a downloadable handout highlighting the main points. In my case, a human course builder receives the final interactive HTML prototype and uses it to update our organization’s course catalogue. The HTML file is available for everyone to use as well. This reduced the production time from three months to two hours at most. I also included a security gate that redacts information from transcripts used to create course content. I’m happy to share more—we’re talking about folders and files here. Step-by-step: 1. I used Claude Code to build a 13-agent workforce for generating micro-courses. 2. I gave each agent its own job description and defined workflow. 3. I started the workflow with document analysis before the work begins. 4. I used a course package agent to deliver a complete, interactive HTML prototype as a local file. 5. I had the workforce create knowledge-check quizzes with corrective feedback. 6. I included a downloadable handout with highlights at the end of each micro-course. 7. I sent the final interactive HTML prototype to a human course builder, who updates our organization’s course catalogue from it. 8. I added a security gate to redact information from transcripts used for course content. 9. I made the HTML file available for everyone to use.

I wanted to learn how to build websites and sell them, but I didn’t know where to start. I used AI—specifically DeepSeek—to help me plan a roadmap. Because I already had experience prompting large language models to get the results I wanted, I asked DeepSeek which areas of knowledge I would need for this path. I also asked it to prioritize each area using statistics and facts. I reviewed the areas I didn’t know and prioritized them, then told the AI that I needed free resources only. I asked it to rank the topics based on what I didn’t know or understood the least. Finally, I asked it to create a Markdown file with all the resources formatted as checklists and imported the file into Notion. Now I have a plan I’m following instead of a “someday I’ll do this, hopefully” idea. Step-by-step: 1. I explained to DeepSeek that I wanted to learn how to build and sell websites but didn’t know where to begin. 2. I asked it to identify the areas of knowledge I would need for that path. 3. I asked it to prioritize those areas using statistics and facts. 4. I reviewed the topics I knew the least about and used that information to prioritize them. 5. I specified that I wanted free learning resources only. 6. I asked DeepSeek to create a Markdown file listing the resources as checklists. 7. I imported the Markdown file into Notion and started following the resulting plan.

My father-in-law has had some close calls with phishing attacks, so I built a digital bodyguard with Claude Code to watch over their email around the clock. It’s designed to catch scam and phishing attempts that are specifically crafted to fool people: fake bank alerts, urgent “click here” links, and messages pretending to be from someone they trust. When it spots one, it pulls the message out of the inbox into a separate folder and sends me an alert so I know it happened. I wrote up the full system, including the prompting and context, in GitHub: https://onabetternote.substack.com/p/using-ai-to-guard-against-email-scams?r=6ihgge&utm_campaign=post-expanded-share&utm_medium=web Step-by-step: 1. I built a digital email bodyguard with Claude Code to monitor my father-in-law’s email around the clock. 2. I configured it to look for phishing and scam messages, including fake bank alerts, urgent “click here” links, and messages impersonating trusted people. 3. When it identifies a suspicious message, it moves it from the inbox into a separate folder. 4. It sends me an alert whenever it takes action. 5. I documented the full system, including the prompting and context, in GitHub.

Sometimes I want something good to read but don’t know exactly what. Finding the right book, article, or story means searching through existing content and hoping something matches my current mood and interests. Generative AI creates another option: instead of finding something to read, I can create exactly what I want to read right now. I created a personalized Reading Experience Generator that acts as an on-demand writer rather than a recommendation engine. When I tell it I want something to read, it asks me a few questions—one at a time—to understand what I’m in the mood for. It determines whether I want fiction or nonfiction, the tone and mood, the subject or setting, and any particular angle I’m interested in. Once it knows enough, it writes an original 1,000–2,000-word piece specifically for that moment. The key instruction is that it never recommends existing books, authors, stories, or articles. Its only job is to create something new. Step-by-step: 1. I create instructions that give the AI a single role: when I want something to read, it should write something original, not recommend existing content. 2. I tell it to begin each new reading experience by asking 2–4 questions, one at a time, and to stop asking as soon as it has enough information. 3. I have the questions establish whether I want fiction or nonfiction, my desired mood or tone, the subject, setting, or genre, and any particular angle I’m interested in. 4. I explicitly prohibit recommendations of existing books, authors, articles, or stories. This prevents the assistant from turning the experience into a conventional recommendation engine. 5. I define a target length of roughly 1,000–2,000 words—long enough to become immersed without requiring a major time commitment. 6. I tell the AI to begin writing immediately once it understands what I want. There should be no outline, explanation, or preamble; the next thing I see should be the piece itself. 7. When I want something different, I start again. The AI repeats the short interview and creates a completely new reading experience based on what I’m interested in at that moment. Instead of choosing from a fixed library of things other people have already written, I get an effectively unlimited supply of original reading material personalized to my interests and mood. The interesting shift is that I’m not using AI to help me write. I’m using AI as the writer, and I’m the audience.

I built a workflow to track my monthly credit card expenses and keep them within my budget. Tracking my expenses is important to me because I want to reach my financial goals through consistency and healthy habits. However, entering each expense manually into Google Sheets was tiring and took several hours. I used Make to automate the process. The workflow reads the email from my bank every time I use my card, gathers the necessary information, converts it to JSON, and adds it to Google Sheets. It runs every six hours, every day, so I no longer need to spend my weekends reviewing expenses. Now I have more free time to build something else and only need a couple of minutes to review Google Sheets and make sure everything is working properly. Step-by-step: 1. I set up a workflow in Make to monitor emails from my bank whenever I use my credit card. 2. The workflow gathers the necessary expense information from each email. 3. It converts the information into JSON format. 4. It adds the expense data to Google Sheets. 5. The workflow runs every six hours, every day. 6. I spend a couple of minutes reviewing Google Sheets to make sure everything is working properly and that my expenses remain within budget.

I’m a commercial excellence consultant for industrial B2B businesses, and very few of the clients I speak with have a current view of the competition in their market. Nobody has mapped the competitive landscape recently—sometimes they never have. Clients can often name the companies in the market, but they can’t explain what those competitors do differently or why a customer would choose one over them. That gap is expensive. The mid-market manufacturers I work with, typically in the $75 million to $300 million range, usually don’t have a strategy team to close it. The alternatives are consulting rates for research that goes stale as soon as it’s delivered or a generic template that says the same five things about every market. Neither option is necessarily wrong, but neither is very useful. So I built a Claude Skill: an instruction set that runs live research every time instead of pattern-matching to a generic answer. The input is simple: the company name, its brand voice, the research scope, the geography, and a known competitor list if one is available. Before researching a single competitor, the Skill states the decision the report needs to inform—for example, whether to enter a vertical, how to price against a rival, or where to direct sales next quarter. It checks the client’s own website and capabilities next; an early version once recommended something the client already had. It then maps the competitive field across five tiers: direct, adjacent, disruptor, new entrant, and aspirational for PE-backed clients. It checks Asia-Pacific specifically because that’s the blind spot I’ve seen missed most often. Market size carries a confidence flag instead of false precision. Findings become battlecards phrased the way reps actually talk, rather than in analyst language. The report also includes a threat ranking with a timeline attached, then closes with three opportunities, three risks, and four to six moves for the quarter. Every recommendation is filtered through the original decision instead of being included simply because the research was interesting. The output is two files: an interactive HTML report and a matching PDF. Both are built entirely in HTML and CSS rather than with canvas charts, which can break in exactly the ways that matter—blank on load or missing from the PDF. None of what makes this useful is the AI itself. The important work is naming the decision before researching a competitor, checking what the client already has, tagging confidence instead of faking precision, and writing like a rep rather than an analyst. That’s the difference between a report that gets skimmed once and one that gets acted on. This is one piece of a bigger system I run for industrial manufacturers applying AI to their commercial function. I teach the underlying version of this workflow live. Step-by-step: 1. I provide Claude Skill with the company name, brand voice, research scope, geography, and known competitor list, if available. 2. I define the decision the report needs to inform, such as entering a vertical, pricing against a rival, or directing sales next quarter. 3. I have the Skill check the client’s website and capabilities before researching competitors. 4. I map the competitive field across direct, adjacent, disruptor, new entrant, and, for PE-backed clients, aspirational competitors. 5. I check Asia-Pacific specifically to address a commonly missed blind spot. 6. I assign confidence flags to market-size estimates rather than presenting false precision. 7. I turn the findings into sales-rep-friendly battlecards and add a threat ranking with a timeline. 8. I close the report with three opportunities, three risks, and four to six quarterly moves tied back to the original decision. 9. I deliver the result as an interactive HTML report and a matching PDF, using HTML and CSS instead of canvas charts.