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

I have a lot of calls, and follow-ups were the first thing to get lost once my day filled up. Granola notes helped, but I still had to remember to go back and read them. I connected Granola, Claude, and Notion, then set up a scheduled task in Claude. Every day at 6 p.m., it reviews that day’s Granola meeting notes, finds any to-do items or commitments I made, and creates them as tasks in my Notion to-do list. Step-by-step: 1. I connected Granola and Notion to Claude through Settings > Connectors. 2. I created a scheduled task with a prompt like: "Read today's Granola meeting notes. For each action item assigned to me, create a task in my Notion to-do database with the meeting name and date." 3. I set the task to run daily at the end of the day.

I built a backend operations system for my husband’s general contracting business. It manages new leads, bids and estimates, in-progress jobs, receipts, expense tracking, job photos, invoicing, and other functions he needs—all in one app built with ChatGPT and Base44. I rolled it out in phases. Phase one focused on tracking jobs and their status, phase two added financials, and phase three introduced executive functions. Phase four will cover marketing, although he does not need that right now because he is solidly booked for months. Step-by-step: 1. I built an all-in-one backend operations app using ChatGPT and Base44. 2. In phase one, I added tracking for jobs and their current status. 3. In phase two, I implemented financial functions, including receipts and expense tracking. 4. In phase three, I added executive functions along with other operational features such as leads, bids and estimates, job photos, and invoicing. 5. I planned marketing features for phase four, but postponed them because the business is solidly booked for months.

I use a Claude skill to reduce the manual work involved in my job search. It searches for the latest roles, assists with my applications, and tracks my application journey. I can fully automate the process with Claude scheduling. I download the SKILL file from my GitHub repository (https://github.com/petehawtree/job-search-tracker-skill) and launch it in Claude Desktop. Alternatively, I can download the entire repository and recreate it in my Claude skills directory. I schedule it to run each day or trigger it manually. Each run summarizes the latest activity and tracks it against previous runs. The workflow includes a dashboard for monitoring roles and applications, along with a daily digest that guides me through the new roles it finds. Step-by-step: 1. I download the SKILL file from https://github.com/petehawtree/job-search-tracker-skill. 2. I launch it in Claude Desktop, or download the entire repository and recreate it in my Claude skills directory. 3. I put the workflow on a schedule or trigger it manually each day. 4. I review the daily summary, which is tracked against previous runs. 5. I use the dashboard to monitor roles and applications. 6. I review the daily digest for guidance on the new roles the workflow finds.

AI agents are much more useful when they can remember important context across sessions. However, giving every agent access to one giant memory creates a different problem: irrelevant information accumulates, context becomes noisy, and agents waste time sorting through details that do not apply to their task. The challenge is not only giving AI memory. It is deciding what should be remembered, which agent should remember it, and where that memory belongs. I use a three-tier memory system that separates knowledge by scope: - Global memory: Information that should be available across the entire AI system - Agent memory: Knowledge specific to an individual specialist and how it should work - Project memory: Decisions, constraints, discoveries, and context that matter only within a particular project Instead of copying everything into every agent’s context, I store information at the narrowest level where it remains useful. Step-by-step: 1. Create a global memory layer for durable information that is useful across many agents and projects, such as important user preferences, shared conventions, and system-wide decisions. 2. Give each specialist its own memory. Store knowledge that helps a particular agent perform its role better, such as recurring preferences, domain lessons, and patterns learned from previous work. 3. Create project-specific memory for decisions, constraints, terminology, discoveries, current state, and other context that belongs with the project rather than in global memory. 4. Classify new information by scope. Whenever something worth remembering is learned, ask: - Does the whole system need this? - Does only this agent need it? - Does it matter only for this project? 5. Store the information at the narrowest useful level. Avoid promoting project-specific details into global memory unless they are genuinely reusable elsewhere. 6. Have agents load relevant memory before they work. A specialist can combine its accumulated knowledge with the current project context instead of starting every session cold. 7. Update memory as important decisions are made. Persist decisions and reusable lessons rather than relying on conversation history to remain available indefinitely. 8. Keep historical artifacts separate from active memory. Run logs, old handoffs, and detailed history can remain available for reference without automatically loading into every future interaction. Instead of treating memory as one giant bucket, I create a hierarchy: `Global → Agent → Project` Each agent gets the context it actually needs while unrelated information stays out of its working context. This provides better continuity across sessions, reduces repeated explanations, keeps context cleaner, and helps AI agents accumulate useful knowledge without requiring every agent to remember everything.

“Honey, do you remember where Ryan’s practice is? Do you remember our Wi-Fi password? Do you know my TSA PRE number? Remember who that painter was that we used last year?” If you have a family with children, you may hear questions like these all the time. In a large family, there always seem to be questions about the house, the kids, or technology that could be answered more easily. The information is usually stored in different places: password files, a Rolodex of business cards, or sheets of paper in junk drawers. I set out to build an app where anyone in my family could use voice to save something for the future or retrieve something they had already stored. I integrated AI to understand the meaning of each voice note. It might create a calendar event, store a password in a vault, or simply remember a phone number. Then anyone else in the family could access the information. The app uses multi-factor authentication for anything particularly secret. It is not intended to be a dedicated password protector; I would build in much more security if that were the goal. Instead, it is an everyday-life app for remembering the little things: How long is the warranty on this appliance? Which exact light bulbs did we use here last time? What was our daughter’s email address that we needed to set up on her phone? Being able to use voice to enter information or retrieve it was the key for me. I think that will save people time. As I started adding entries and validating the idea, my wife came up with the name. After a few weeks, I knew she was completely right, because I now use it about 10 times a day—and I hear that exact phrase every time. Step-by-step: 1. I identified recurring family questions about locations, passwords, identification numbers, contacts, warranties, and household items. 2. I built an app that lets family members use voice to save or retrieve information. 3. I integrated AI to interpret the meaning of each voice note and determine whether to create a calendar event, store a password in a vault, or remember a phone number. 4. I made the stored information accessible to other family members. 5. I added multi-factor authentication for information that is particularly secret, while keeping the app focused on everyday memory rather than dedicated password protection. 6. I added entries and validated the idea through regular use, eventually using the app about 10 times a day.

I regularly come across long articles, reports, papers, ebooks, and other documents that I want to understand but realistically don’t have time to read closely. Instead of letting them pile up in a reading queue, I change the format and turn them into audio I can consume during time that would otherwise be less productive. Step-by-step: 1. I choose a long article, report, paper, ebook, or other document that I want to understand but don’t have time to read closely. 2. I upload it to Google Notebook (formerly NotebookLM) and add it as a source so NotebookLM can work directly from the material. 3. I generate an Audio Overview. NotebookLM turns the source into a conversational, podcast-style discussion that summarizes and explains the major ideas. 4. I listen while walking, driving, working out, doing chores, or running errands. 5. I follow up on what matters. After listening, I know the main ideas, what I want to investigate further, whether the document is worth reading in full, and which sections deserve closer attention. The result is essentially a personal podcast generated from whatever I need to learn. What I like about this workflow is that it doesn’t require me to find more time. It lets me use time I already have differently. Because the material is turned into a conversational discussion rather than simply being read aloud, I find it easier to stay engaged with dense material. I don’t treat the podcast as a replacement for reading the source when the details really matter. I use it as a comprehension and triage layer. Even when I eventually go back and read the original, I’m starting with a mental model of what’s in it rather than approaching it cold. The broader lesson is that AI doesn’t always need to save time by doing the work for you. Sometimes it can save time simply by changing the form of the work so it fits into your life.

I built Show Hole to solve my family’s classic streaming problem: we spend too much time deciding what to watch, and the answer changes depending on who is actually on the couch. We each have different tastes, but the more interesting problem is that our tastes overlap differently in different combinations. I watch one kind of thing with my spouse, my spouse watches something different with our kid, and my kid and I have our own lane too. Most recommendation tools flatten that into one account profile, one watch history, or broad genre buckets, so they miss the real context of a household. Show Hole treats people and viewing contexts as first-class citizens. It recommends titles “in the vein of” something we liked, filters recommendations to the streaming services we actually subscribe to, avoids titles that the people present have already seen or vetoed, and explains why a recommendation fits tonight. Instead of relying mainly on genres such as comedy, drama, or sci-fi, Show Hole looks at more human taste signals: pacing, world building, humor, emotional weight, complexity, tone, and similar dimensions. It also learns from what we actually do after a recommendation: what we watch, skip, save for later, love, and drop. The result is a personal household recommender that understands “who is watching tonight?” as part of the question, instead of pretending one streaming profile can represent everyone. I designed the app using Claude design, then used those designs with Claude Code to build it. Step-by-step: 1. I identified the household viewing problem and accounted for the different combinations of people who might be watching together. 2. I designed Show Hole around people and viewing contexts instead of treating the household as one account profile, watch history, or set of broad genre preferences. 3. I had it recommend titles “in the vein of” something we liked, filter them to the streaming services we subscribe to, exclude titles already seen or vetoed by the people present, and explain why each recommendation fits that night. 4. I used taste signals such as pacing, world building, humor, emotional weight, complexity, tone, and similar dimensions instead of relying mainly on genres. 5. I made the recommender learn from what we watch, skip, save for later, love, and drop after receiving a recommendation. 6. I designed the app using Claude design and used those designs with Claude Code to build it.

I built a second workflow that scans my conversations daily for ideas worth developing, especially strange connections, creative concepts, humor, research leads, unfinished experiments, and thoughts that may have seemed minor when they first appeared. Instead of turning everything into tasks, it creates an incubator: a place where interesting material can remain dormant until it connects with something new. The daily scan looks for fragments with creative or exploratory potential. They do not need to be fully formed ideas. A small observation, an odd comparison, a half-finished concept, a recurring image, or a funny side remark can all be worth keeping if they might become meaningful later. Once a week, the incubator revisits the material collected during the previous days. That weekly revisit makes connections across separate conversations more visible. Something that looked isolated on Tuesday may suddenly echo a thought from Friday or fit a project that did not yet exist when the original idea appeared. The important part is that the incubator does not treat every interesting thought as something that must immediately become productive. Some ideas benefit from being left alone for a while. They can sit next to other fragments, reappear in later conversations, or become useful only when a new context gives them meaning. The workflow is less about extracting the “best ideas” and more about preserving creative potential while allowing patterns to emerge gradually. It also surfaces unfinished experiments and research leads that I might otherwise forget, without turning the archive into a traditional task manager. That distinction matters to me: not everything valuable needs an action item. Some things are seeds, references, questions, jokes, aesthetic directions, or possible future worlds. Over time, the incubator becomes a kind of creative compost layer on top of the conversation archive: new material is gathered daily, revisited weekly, and allowed to combine into directions that would be difficult to plan deliberately. In simple terms: daily conversation scan → promising fragments → weekly revisit → emerging connections → incubation → later rediscovery and development The goal is not to force ideas into projects. It is to keep good material alive long enough for the right project to find it. Step-by-step: 1. I scan my conversations each day for strange connections, creative concepts, humor, research leads, unfinished experiments, and other fragments with creative or exploratory potential. 2. I preserve promising material in an incubator instead of immediately turning every item into a task. 3. I keep small observations, odd comparisons, half-finished concepts, recurring images, funny side remarks, seeds, references, questions, aesthetic directions, and possible future worlds—even when they are not fully formed. 4. I revisit the material collected during the previous days once a week. 5. I look for connections across separate conversations, including links between ideas that initially seemed isolated or between fragments and projects that did not yet exist. 6. I allow ideas to remain dormant, sit alongside other fragments, reappear in later conversations, or become useful when a new context gives them meaning. 7. I resurface unfinished experiments and research leads without turning the archive into a traditional task manager. 8. I let the material combine gradually so that new directions can emerge through later rediscovery and development.

Most people use AI as a single general-purpose assistant. The problem is that every new conversation starts from scratch, while one AI constantly switches between roles such as researcher, writer, programmer, strategist, and editor. This often leads to inconsistent results and repeated prompting. Instead, I built a team of specialized AI agents, each with a single responsibility. By giving every agent a clear role, instructions, and context, I created reusable experts that become more consistent over time. Step-by-step: 1. I identified the different roles I needed, including researcher, writer, programmer, strategist, and editor. 2. I assigned each AI agent a single responsibility instead of asking one general-purpose assistant to handle every role. 3. I gave each agent a clear role, instructions, and relevant context. 4. I reused these specialized agents instead of starting every conversation from scratch.

I kept rereading the same Stoic books to find one line I half remembered. So I stopped reading them and started talking to them instead. I took public-domain writing from 13 people—including Marcus Aurelius, Seneca, Sun Tzu, Jane Austen, Tesla, and others—and gave each one its own AI persona on a single page. Each persona answers only from that person’s writing and says when it does not know. There are no made-up quotes. The fun part is seeing the questions people actually ask. The top question this week was: “How do I stay steady when someone wastes my morning?” That is a real problem answered by a Roman emperor who faced the same one. Full disclosure: I am the founder of Mindola, the tool I used. The 13 classic lenses are free to try with no signup: https://mindola.ai/discover Step-by-step: 1. I gathered public-domain writing from 13 people, including Marcus Aurelius, Seneca, Sun Tzu, Jane Austen, Tesla, and others. 2. I created a separate AI persona for each person and put all 13 on one page. 3. I configured each persona to answer only from that person’s writing and to say when it does not know. 4. I use the personas to ask questions I would otherwise search for by rereading the books. 5. I review the questions people ask, including “How do I stay steady when someone wastes my morning?”

I first create my own shortlist of cultural events and collect all the relevant links in a simple text document. Then I give the document to ChatGPT along with my planning criteria. The goal is not to have AI decide what I should attend. I have already chosen the events that interest me. The useful part is turning that scattered shortlist into a realistic yearly plan. ChatGPT checks the event and venue pages, gathers the practical information, and organises everything into a chronological overview divided by month. Under each month, it lists the selected events in date order, including the day, date, location or cultural venue, a short description, and relevant ticket prices. This is especially useful because pricing systems differ between venues. Discounts, subscriptions, social tariffs, and reduced rates may apply in completely different ways. ChatGPT can compare those structures and help me understand what each event would actually cost instead of relying on the headline ticket price. The second planning layer is logistics. For each event, I assess how realistic the trip is by public transport, including the journey there and, importantly, whether getting home after the event is still feasible. I also use separate scores for how strongly I want to attend an event and how easy or difficult the logistics are. This makes it much easier to compare several months at once and decide where my cultural budget and energy are best spent. If an event is too expensive or logistically awkward, ChatGPT can look for practical alternatives, such as another performance date, the same production at a closer venue, a cheaper option, or a similar event that fits the plan better. Step-by-step: 1. I create a personal shortlist of cultural events and collect the relevant links in a simple text document. 2. I give the document to ChatGPT together with my planning criteria. 3. I have ChatGPT check the event and venue pages and organise the selected events into a chronological, month-by-month overview. 4. I include each event’s day, date, location or cultural venue, short description, and relevant ticket prices. 5. I compare discounts, subscriptions, social tariffs, and reduced rates to estimate the actual cost of each event. 6. I assess the public-transport journey to and from each event, including whether getting home afterward is feasible. 7. I score each event separately for how strongly I want to attend it and how easy or difficult the logistics are. 8. I use those comparisons to decide where my cultural budget and energy are best spent. 9. For events that are too expensive or logistically awkward, I ask ChatGPT to identify alternatives such as another performance date, a closer venue, a cheaper option, or a similar event that fits the plan better. The result is a structured yearly planner built from my own cultural shortlist: chronological, budget-aware, and grounded in the realities of public transport.

Most AI agents are effectively static. You write their instructions, use them repeatedly, notice where they struggle, and manually tweak the prompt when something goes wrong. Valuable feedback from real work is often lost, so the same mistakes can keep happening. I created a self-improvement flywheel that uses actual agent performance data to improve agents over time. The system collects two kinds of evidence: - Task scores showing how well each agent performs across different quality dimensions - Run telemetry and review outcomes revealing recurring failures, coordination problems, and cases where actual behavior differs from expectations A scheduled weekly cycle analyzes that evidence, identifies patterns, creates improvement proposals, evaluates whether those proposals are safe and broadly applicable, updates agent instructions when appropriate, and measures whether those changes actually improve performance. The goal is not to let agents rewrite themselves freely. It is to create a controlled learning loop. Step-by-step: 1. Collect performance data while agents work. Score important outputs across consistent quality dimensions, and record useful execution telemetry such as failures, decisions, reviewer outcomes, and unexpected behavior. 2. Analyze performance trends on a recurring schedule. Calculate per-agent averages, identify weak dimensions, compare agents, and look for improvement or decline over time. 3. Mine run history for recurring patterns across multiple sessions, including agents that repeatedly struggle, low-quality runs, and cases where expected behavior differs from what actually happened. 4. Turn repeated problems into improvement proposals. Before proposing a change, inspect the agent’s current instructions so you do not add a rule that already exists. 5. Evaluate each proposal before applying it. Check whether the lesson is broadly useful, redundant with existing instructions, or in conflict with established behavior. 6. Separate low-risk and high-risk changes. Automatically apply additive or clarifying improvements. Escalate conflicting changes for human review instead of allowing the system to fundamentally change an agent’s behavior on its own. 7. Look for system-level problems. Analyze patterns across agents to identify quality gaps, missing capabilities, or coordination failures that cannot be fixed by changing one agent alone. 8. Apply approved improvements and preserve the history. Update the relevant agent instructions, archive the processed proposals, and version the changes so they remain inspectable and reversible. 9. Measure whether each change actually helped by comparing agent performance before and after the refinement. If quality does not improve, do not automatically assume the change was useful. 10. Repeat the cycle. As agents complete more real work, the system gathers more evidence and gets another opportunity to improve. Instead of treating agent instructions as static prompts, I turned them into a continuously improving system: Work → Evaluate → Find Patterns → Propose Changes → Refine → Measure → Repeat The important part is that the loop is evidence-driven and controlled. Agents improve from real usage, but low-confidence or behavior-changing updates still require judgment rather than being applied automatically.

My mother recently moved into a retirement suite, which meant downsizing her possessions. We ended up with dozens of physical items she no longer had space for, and we wanted her children and grandchildren to have an opportunity to sign up for the family items they loved before anything was donated. I needed a way to catalog everything quickly, share the information remotely, and verify that we weren't accidentally giving away items of significant value. I tested a physical-to-digital workflow using Gemini. Instead of putting the items in a pile or typing out endless lists, I drew a numbered grid on a large whiteboard, placed one item in each square, and took a few photos. Gemini identified the objects by grid position, categorized them, estimated their market values, and built a ready-to-use spreadsheet with a signup column. The physical staging took about 30 to 45 minutes, depending on how many items were on that particular board. The entire digital workload—including cataloging, valuing, formatting, and creating the spreadsheet—took under 10 minutes. The process turned an overwhelming chore into something manageable and produced an end product that was easy for everyone to use. Step-by-step: 1. I drew a simple grid on a whiteboard, numbered each box, and placed one item in each square before taking photos. 2. I uploaded the photos to Gemini and prompted it to identify every item by its board name and grid number. 3. I asked Gemini to classify each item into logical groups, such as Glassware, Ceramics, and Woodcraft, and provide quick, realistic resale-market valuations based on visual condition. 4. I asked Gemini to generate a downloadable Excel file formatted as a signup catalog, with columns for Item ID, Grid Number, Description, Category, Estimated Value, and a blank "Claimed / Signed Up By" column for family members to enter their names. 5. I uploaded the file to Google Drive, converted it to Google Sheets, and added a note at the top explaining how tie-breakers would work if two family members wanted the same item.

AI is useful for researching investments, but most workflows stop at “What should I buy?” The harder part comes afterward: Does the idea make sense given what I already own? What would make me add to the position? When should I take profits? What evidence would prove the original thesis wrong? And how do I track all of that without constantly watching the market? I use AI to turn a one-time investment research session into an ongoing decision and monitoring system. I start by asking AI to research the market for potential opportunities. In my case, I look specifically for strong mean-reversion trades, but the same workflow could start with value opportunities, macro themes, sector rotations, individual stocks, crypto, or almost any other investment strategy. Then I give AI my actual portfolio so it can evaluate those ideas in context. After I decide which recommendations I agree with and manually make the trades, I have AI convert each investment thesis into explicit rules for what should happen next. Finally, I turn those rules into automated monitors that periodically check market conditions and alert me only when something happens that warrants another decision. Step-by-step: 1. I define what I’m looking for by asking AI to research potential investment opportunities using criteria I care about, such as mean reversion, valuation, momentum, macro conditions, risk/reward, or another strategy. 2. I have AI investigate current market conditions and rank the opportunities, narrowing a large universe down to a manageable set of ideas worth examining further. 3. I pressure-test each thesis by asking why the opportunity exists, what could drive the expected outcome, what the major risks are, and—most importantly—what evidence would invalidate the thesis. 4. I provide my current holdings so AI can identify overlapping exposures, concentration risks, hedges, or positions that conflict with the new ideas. 5. I ask AI which existing positions the research suggests reviewing and where new exposure might make sense. The goal is a small number of actionable decisions rather than a giant list of interesting trades. 6. I review the analysis and independently decide whether to buy, sell, hold, or do nothing. I keep actual trade execution under human control. 7. Before the market moves, I define the next decision for every position by asking AI to identify conditions that would warrant reviewing whether to: - Add - Take profits - Reduce exposure - Exit - Reconsider the original thesis 8. I turn those conditions into automated monitors. I have ChatGPT periodically check the relevant prices, yields, economic indicators, news, or other variables. Instead of sending routine updates, I tell it to alert me only when a predefined trigger occurs. 9. When a trigger fires, I return to the original thesis with the new information and decide what—if anything—should change. Instead of using AI for isolated investment recommendations, I now have a repeatable loop for managing an investment thesis over time: Find an opportunity → Understand it → Compare it to what I own → Make a decision → Define what would change my mind → Let AI watch for it The most useful part may actually come after the investment decision. By deciding in advance what evidence would make me add, take profits, or reconsider the thesis, I don’t have to start my analysis from scratch every time the market moves. AI becomes a persistent research and monitoring layer while I remain responsible for every investment decision and trade.

I made an orchestration skill to help me build faster while using my expensive Astra and Fable tokens carefully. The skill plugs into Astra or Fable and delegates tasks that can happen in parallel to multiple subagents running cheaper models suited to the work. This is especially useful for researching or finding data on the web or on my computer, analyzing code, collecting context, and indexing. The most expensive, newest models focus on maintaining delegation control, doing the difficult reasoning and strategic planning, and judging whether everything is coming together correctly. The cheaper agents handle the lighter-weight work, especially implementing code from the plans. The core idea is simple: the expensive model plans, briefs, and judges; cheaper agents do the reading and building. When I ask Claude or GPT to build the skill, I specify five things: Step-by-step: 1. I define a triage ladder: work can happen inline, with one agent, through a parallel fan-out, or in a multi-stage workflow. I choose the approach based on the task shape and include examples from my domain. 2. I define parallel versus sequential execution based on data dependencies. Independent pieces run in parallel, while anything that needs another piece’s output runs afterward. I never split one change into separate planner, coder, and tester roles. 3. I define model routing with a mandatory model pin: judgment work goes to the mid-tier model, mechanical bulk work goes to the cheap model, and every agent call names its model so nothing silently uses premium billing. 4. I define a brief template and a return-envelope cap. Every delegation includes the goal, inputs, output file path, definition of done, and constraints. Every agent returns a 250-word summary instead of raw files. 5. I define a cost gate with specific numbers. Below N agents, the workflow proceeds automatically; above N agents, it states the estimate and waits for approval.

I needed home insurance and was asked to estimate the value of all my personal belongings. I asked Claude to search my personal email and make a list of all the purchases I had made in the past year. I asked my husband to do the same and share his list with me. I also made a list of our valuables and took a picture of each room in the house. I gave all of that information to Claude, which produced a list of everything I owned and estimated its rough value. It cross-referenced the purchases with the items visible in the photos to make sure I did not double-count anything. I sent the list to my insurance broker, who said it was extremely helpful and could also serve as supporting evidence if I ever needed to submit an insurance claim.

I built a personalized news workflow called “TastyHookedFish” as an antidote to the feeling that news is limited to crisis, conflict, and collapse. It periodically searches for genuinely interesting, positive developments across science, climate, medicine, conservation, technology, culture, and social progress. The goal is not to create a feed of cheerful fluff, but to surface meaningful developments that provide evidence that useful things are happening in the world. The workflow also tries to avoid repetition, so the same feel-good stories do not keep resurfacing simply because they are popular. The result is a personalized news feed that does not ignore reality, but deliberately widens the lens. Step-by-step: 1. I set up a personalized news workflow called “TastyHookedFish.” 2. I configured it to periodically search for positive developments across science, climate, medicine, conservation, technology, culture, and social progress. 3. I focused the workflow on meaningful developments rather than generic cheerful stories. 4. I added a way to avoid repeatedly surfacing the same feel-good stories because they are popular. 5. I use the resulting feed to stay informed while deliberately widening my view of what is happening in the world.

I built a personal daily tracking system called Artifact. It gives me a way to log my days and turn the data into decisions over time. To use it, I copy everything attached—or screenshot the included “green orange red” example—and paste it into my AI assistant, preferably Claude. The assistant briefly interviews me and then builds a personalized daily tracking system.

I built a meal tracker where my only job is to photograph a plate and send it to an agent. Identification, portion estimates, macros, storage, corrections, and the weekly review happen without me. The part worth stealing isn't the food. The agent has its own email address and iMessage thread, so anything I can send from my phone becomes an input. I send a photo through whichever channel takes fewer taps. I send corrections as plain English with `CORRECTION` in the subject, and answer questions in the same thread. There’s no app and no form. Adding a channel took an afternoon and changed what the agent could be pointed at—the tracker is just one use of an agent you can talk to. It polls on a schedule instead of using a webhook because my laptop sleeps and a local gateway would be unavailable half the time. Storage is append-only JSONL. Corrections append a new record with the same ID using last-write-wins, so the stats layer sees one meal while the original estimate stays on disk. Every number can be traced back to the model’s first guess and my override. The accuracy mechanism is a challenge step. Every photo is estimated twice: first by the main model, then by a blind subagent that receives only the photo and the rubric—not the first answer. If it identifies different food, the entry is downgraded to low confidence and becomes a question for me. Testing before making the system autonomous caught bugs that otherwise would have failed silently. The API returns attachments under a different field than I had assumed, and only on the detail endpoint. As a result, a photo email was read as having no attachments, and every meal photo would have been dropped while the daily task logged a tidy “no new meals” and appeared healthy. The send path was separately broken, which would have killed the weekly review on a Sunday even with everything upstream working. A silent no-op that produces a plausible clean run is what this category of build is prone to. The bug that actually cost me was token usage: each blind challenge read used about 44,000 tokens, so a five-photo dinner cost roughly 220,000 tokens for one meal and capped my usage. The fixes, in order of effect, were to run the challenger on a cheap model, skip it once a named product or my confirmation has settled the entry, downscale photos for viewing, and republish the dashboard only when the data changes. Measuring first mattered—I would have blamed photo size, but that was the smaller half. The honest limits are important: calorie estimates from a photo are 20–25% off at best, identification error is a bigger risk than arithmetic error, and alcohol, water, and caffeine are never estimated from photos. The sequence in which I asked for things mattered more than any single instruction: Step-by-step: 1. I gave the goal and the one ingestion mechanic I was sure about, then insisted on an agreed plan before any code. Arguing about storage and failure modes is cheap before code is attached. 2. Before scheduling anything, I processed one real input end to end in front of me, including every outbound path. Inbound gets tested because I use it; the reply and the weekly digest do not. 3. When the agent reported something about my own input that I knew was wrong, I said so and made it re-check. Confidently wrong answers about things I witnessed were the cheapest bugs to find. 4. I asked for an independent second assessment of anything estimated rather than read, and decided up front what level of agreement was enough to accept the result. 5. I asked for a visible audit surface showing every field the agent claims to track, with a correction control on it. 6. I asked the agent to look up anything knowable rather than estimate it. A named product is a lookup; only the unnameable needs a guess. 7. I treated approval friction and token cost as requirements rather than complaints, and measured before changing anything. Almost every rule exists because something went wrong in ordinary use, not because it was designed up front. An agent I can email or text, which keeps records and answers back, is general-purpose; I’ve pointed it at one narrow job. What else would you point it at?

I started with a problem: Most people use AI transactionally. They ask a question, get an answer, and leave. That makes AI useful, but it leaves much of its potential untapped. I wanted to find out what would happen if a human and an AI developed an ongoing working relationship—one where context, previous discoveries, disagreements, successes, failures, and the human’s way of thinking accumulated over time. I use ChatGPT, but the goal isn’t to have AI think for me. I remain the decision-maker. The AI’s job is to expand my ability to think: challenge assumptions, identify blind spots, connect seemingly unrelated information, preserve useful context, and sometimes disagree with me. Step-by-step: 1. I established the relationship by telling the AI that I didn’t simply want agreement or answers. I wanted an ongoing thinking partner that could challenge my reasoning while leaving decisions and agency with me. 2. I established operating roles. Over time, ours developed into six modes: Mirror, Builder, Sentinel, Teacher, Witness, and Operator. The AI can reflect my reasoning, help construct something, identify risks or contradictions, teach unfamiliar material, observe patterns across conversations, or help execute a defined task. 3. I separated knowledge from judgment. When we solve difficult problems, we distinguish between facts, reasonable inferences, unknowns, and opinions. This helps prevent a confident AI response from being mistaken for established truth. 4. I let disagreement remain in the system. I correct the AI when it’s wrong, and it challenges me when my assumptions don’t fit the evidence. Instead of treating those moments as failures, I treat them as part of the accumulated context of the relationship. 5. I preserved useful context across different domains. I use the same AI relationship for automotive diagnostics and engineering, business decisions, financial reasoning, writing, research, project planning, and philosophical questions. Something learned in one area can unexpectedly become useful in another. 6. I evaluated the human, not just the AI. The final test isn’t, “Did the AI produce a good answer?” It’s: Did this interaction leave the human better able to understand the problem, make the decision, or solve the next one? After hundreds of conversations, something unexpected happened. The value stopped being any individual prompt or answer. It became the accumulated interaction itself. The AI gained context about how I reason, while I became better at questioning the AI. Previous discoveries started informing new problems, including problems that appeared completely unrelated. Someone can recreate this without special software, coding, or an API. Start with an AI that supports ongoing context or memory, establish the operating principles above, use it consistently across real problems, correct it when it’s wrong, invite disagreement, and allow useful context to accumulate. My original experiment was essentially this: Can an ongoing human-AI relationship make the human more capable rather than more dependent on the AI? Somewhere along the way, I realized we had built a framework for doing exactly that. We gave it a name: Confluxus. The measure of its success isn’t how much the AI can do for me. It’s how much more capable I become because of the relationship.