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

At some point, my newsletters stopped feeling like reading and started feeling like debt. The information was good; I just couldn’t keep up. I wanted a way to turn that backlog back into something useful. So I built The Daily Nexus, a private tool that reads newsletters from a Gmail label and creates two editions: a podcast I can listen to and a separately written, two-page newspaper I can scan. It runs on demand or on a schedule, and it can publish the audio to a private RSS feed for Apple Podcasts. The project also became a hands-on experiment in building with coding agents. Claude Code and Codex helped me implement features, troubleshoot failures, review the design, and tighten security. The stack includes Python, the Gmail API, Antigravity, Kokoro, FFmpeg, Firebase, Cloudflare Workers, and GitHub Actions. The carousel shows the rest of the flow. It started as a personal tool, but I’m sharing the template for anyone who wants to adapt the idea. Each deployment uses its own accounts and credentials, and the design aims to avoid additional API costs by using an existing AI subscription and available free tiers. GitHub Repo Template: https://lnkd.in/eYceS4KR Step-by-step: 1. I label the newsletters I want to process in Gmail. 2. I run The Daily Nexus on demand or on a schedule so it can read the newsletters from that Gmail label. 3. The tool creates a podcast edition and a separately written, two-page newspaper edition. 4. I listen to the podcast or scan the newspaper, depending on how I want to catch up. 5. When needed, the audio is published to a private RSS feed for Apple Podcasts. 6. I use Claude Code and Codex to implement features, troubleshoot failures, review the design, and tighten security. 7. Each deployment uses its own accounts and credentials, with Python, the Gmail API, Antigravity, Kokoro, FFmpeg, Firebase, Cloudflare Workers, and GitHub Actions supporting the workflow.

I built SITREP, a self-hosted AI RSS reader that turns roughly 30 articles a day into a single briefing I can act on. It runs in a Docker container on my home NAS, ingests full article text instead of the teasers most feeds provide, and uses OpenAI embeddings to collapse the same story reported by five outlets into one item. Every morning, it writes “The Brief” with the sections Headline, Defense & Aerospace, AI & Tech, and Elsewhere, followed by the two sections I care about most: Implications for my company and Personal Leverage. Each section includes numbered citations linking back to the source articles. SITREP only proposes leverage when the evidence supports it. It also uses a curated, non-sensitive profile of my business lanes and priorities, synced from my Obsidian vault, so its recommendations are specific to my work as a defense-industry VP rather than generic advice. I can select Update Brief at any time during the day to regenerate the briefing in place with a timestamp. Step-by-step: 1. I run SITREP in a Docker container on my home NAS. 2. I have it ingest the full text of roughly 30 articles each day rather than relying on feed teasers. 3. I use OpenAI embeddings to identify and combine the same story when it is reported by multiple outlets, including cases where five outlets cover it. 4. Each morning, SITREP generates “The Brief” with the sections Headline, Defense & Aerospace, AI & Tech, and Elsewhere. 5. It adds Implications for my company and Personal Leverage, using my curated, non-sensitive business profile and priorities synced from Obsidian. 6. It includes numbered citations to the source articles and proposes leverage only when the evidence supports it. 7. I select Update Brief during the day when needed, and SITREP regenerates the briefing in place with a timestamp.

I built a local memory system for Claude that is a bit different from others I have seen. The reason was familiar: repeated context loss and gaps, even within projects. I am not technical—I come from a healthcare background—so it was essentially vibe-coded, but I used a method I had not seen elsewhere. I started by interviewing Claude about what would be useful to it, rather than beginning with only what I wanted. The three biggest gaps were the rationale behind decisions, current versus historical states, and the difference between global and project-level detail. We also identified ways memory can go wrong, including stale facts being confidently asserted as truth and rejected ideas resurfacing. Claude’s built-in memory stores flat topics without entity links, captures what but not why, is not well temporally grounded, and is gated by Claude. I researched other memory builds, from homebrew systems to enterprise tools, and found that they generally fell into three groups: - Vector dumps, which lack rationale and supersession and can become stale - Plain Markdown with grep or embeddings, such as Basic Memory, which similarly lacks real temporal grounding and an entity graph - Heavyweight knowledge-graph stacks such as Neo4j, LangChain, and GraphRAG None of these did what I wanted. My store holds entities only, not transcripts. It stores decisions, observations, people, and projects connected by typed edges. Each entry has content, a scope—either portfolio-worthy or working detail for one project—a rationale, and information about where it came from. The system is also bitemporal, so it distinguishes what is current from what is not. Nothing is edited in place: a correction adds a new assertion instead of overwriting the old one. Underneath, it uses SQLite, with sqlite-vec for semantic search and FTS5 for keyword search. Nothing writes automatically. Claude has to propose a memory, and I have to approve it. This prevents the store from filling with noise, keeps it token-efficient, and acts as a governance lever. MCP links Claude to my server. It is local-only at present, although there is potential to add remote access in the future. The server provides instructions for making proposals, so the system is theoretically portable, and I also created a Claude skill to accompany it. I ran the build across multiple projects and created specialist projects for different roles: - A central development and oversight project served as the decision-maker and prompt-writer. - Cowork handled the building and tested each module inside a sandbox. It had no authority to change decisions, and I used a fresh project for each stage of the build. - I handled deployment separately by typing every command on the server and pasting the output back. - I repeated Claude’s Cowork-authored tests on the actual server. Real-world testing after deployment identified only minor issues, which were quick to fix. This separation was administratively heavy because I had to keep switching between projects as tasks started and finished, but it caught several errors in the rules and code. Despite my lack of technical knowledge, the project is now well documented and I have room to develop it further. I may eventually put it on GitHub. It has become a standard component of my workflows, my projects are tracked much better, and Claude and I are on the same page more often.

I’m building an AI travel assistant called SundayAtlas, and I wanted a systematic way to keep learning from what travelers are talking about between individual user conversations. Reddit is useful for this because people are unusually candid about trip-planning frustrations, destinations, bad experiences, and what they wish travel products did better. The problem is volume: I didn’t want to manually read hundreds of posts every week, so I built a Reddit Signal Agent that does the first pass and sends me a weekly travel-insights newsletter. Each week, the workflow collects posts from selected travel subreddits and passes them through an LLM-based classification and analysis pipeline. The report is organized around: - New or intensifying signals - Steady baseline themes - Fading signals - Rising destinations - Competitor mentions - Anomalies unusual enough to warrant attention This week, for example, the agent analyzed 77 posts. It surfaced a spike in discussion around short-term rental restrictions in Tokyo, growing payment friction for travelers in Japan, increased interest in quieter alternatives to heavily touristed Asian destinations, and recurring trust issues involving travel platforms. I use the newsletter as one input into product discovery for SundayAtlas. It gives me a weekly pulse on problems and behaviors that may be worth investigating further, rather than relying purely on my own assumptions about what travelers need. Step-by-step: 1. I collect recent posts from a defined set of travel subreddits. 2. I clean and structure the Reddit data for analysis. 3. I run the posts through an LLM using a defined signal taxonomy. 4. I aggregate the classifications across the weekly sample to identify patterns, changes, and anomalies. 5. I generate the report in a consistent newsletter format. 6. I run the full pipeline automatically with GitHub Actions so a new report is produced each week. I built the agent in Node.js and used Claude Code extensively during development. Evaluation ended up being the most important part. Early outputs looked convincing, but I had no objective way to know whether the classifications were actually good. I manually labeled 91 Reddit posts and created a blind golden dataset, then built a deterministic scorer to compare the agent’s classifications with my labels. The first held-out evaluation scored only 0.23, which gave me something concrete to improve against. I iterated on the classification approach and inspected individual failures. Along the way, I found three separate defects in the data collection pipeline. The held-out score eventually improved to 0.61, while the score across the full dataset increased from 0.33 to 0.67. The finished loop is: Reddit conversations → signal classification → trend analysis → weekly insights newsletter → product discovery for SundayAtlas The golden dataset remains underneath the workflow as a regression test, so when I change the agent, I can measure whether I’ve actually improved it.

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.

Midlifecurious is a newsletter for women navigating midlife—honest, funny, and allergic to being talked down to. Its Sunday issue, the Midlife Missive, is a roundup covering health, wellness, money, beauty, and family. My sister, Claire, edits it; I build the machine behind it. That machine is Missive, a five-part publishing intelligence system that runs the newsletter as one closed loop: scan → triage → publish → measure → remember. It monitors Reddit, search trends, and RSS to identify what midlife women are paying attention to before those topics reach our feeds. Discovery pulls in those sources, ranks every feed using a click-rate-based quality score, and lets Claire triage articles into the week’s issue. Curation composes Sunday’s newsletter and drafts the introduction in her voice. Performance reads the Mailchimp results back into the system and feeds them into the rankings, so strong sources rise and weak ones fall over time. Underneath all four stages is Memory: a vector-searchable corpus of every article, save, rejection, and the reasoning behind each decision. Memory is the real spine of the system. It lets Missive ask editorial questions such as “Have we covered this before?” and “Is this source still earning its slot?” instead of requiring one person to hold everything in her head. We’re a two-person operation: I build with Claude Code, and Claire edits. The system runs on one database for under $25 a month. I built it because the alternative was Claire drowning in a Feedly-and-spreadsheet routine that discarded everything as soon as an issue shipped. We had no record of what we had run and no feedback on what actually landed. My bet is that the corpus is the moat. Claire’s editorial taste—every save, rejection, and “cornerstone” stamp, with the reasoning stored alongside the decision—is a training set no one else has. A system that remembers turns her job from synthesizer into judge. Missive is deliberately internal-only: no SaaS and no customers, ever. That frees me to build for our exact workflow instead of a hypothetical buyer, and to build for 2028 instead of this quarter. The near-term payoff is a calmer Sunday. The long-term goal is a proprietary editorial-intelligence layer we could never buy off the shelf—the foundation for the research and audience products that come next. Step-by-step: 1. I monitor Reddit, search trends, and RSS for topics that midlife women are paying attention to. 2. I pull those sources into Missive and rank each feed using a click-rate-based quality score. 3. Claire triages the ranked articles into the week’s Midlife Missive. 4. Missive composes Sunday’s newsletter and drafts the introduction in Claire’s voice. 5. I import the Mailchimp results so the system can update source rankings based on performance. 6. Missive stores every article, save, rejection, “cornerstone” stamp, and the reasoning behind each decision in a vector-searchable corpus. 7. We use that memory to check whether a topic has already been covered and whether a source is still earning its place. 8. I build and maintain the internal system with Claude Code, while Claire handles editing, using one database that costs under $25 a month.

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 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 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.

I’m building a mobile game called ExoLab Blast with Astra. I developed it through conversation, starting with the basic concept and continuing through testing the game mechanics. Astra also created and repeatedly updated the game’s graphics and UI based on my feedback. Step-by-step: 1. I discussed the basic concept for ExoLab Blast with Astra. 2. I used Astra to build out the mobile game. 3. I tested the game mechanics. 4. I gave feedback on the graphics and UI. 5. Astra created and updated the graphics and UI multiple times based on that feedback.

A while ago, my dad told me he wanted to use AI to analyze World Cup matches. He had never coded before, and his AI experience was mostly limited to occasionally asking Gemini a question. I installed Claude Code for him and gave him a few prompting tips. He ended up building a full football analytics site himself and deploying it on Vercel so he could show it to his friends. Getting started with AI is easier than people assume. Sometimes, you just need a project you genuinely want to make. Now that the Premier League season has kicked off, he’s already reworking the site for it. Step-by-step: 1. I helped my dad choose a football analytics project he genuinely wanted to build for analyzing World Cup matches. 2. I installed Claude Code for him, since he had never coded before. 3. I gave him a few prompting tips and let him use AI to help build the site. 4. He built a full football analytics site himself. 5. He deployed the site on Vercel so he could show it to his friends. 6. After the Premier League season kicked off, he began reworking the site for the new competition.

I built a small GPT automation called PatternSpeak that periodically looks back across my conversations for ideas, themes, or approaches that keep resurfacing over time. It is not meant to analyze me or turn recurring thoughts into tasks. Its job is much simpler: occasionally say, in effect, “Hey, this idea keeps coming back. Maybe there is something here.” I like it because repetition can be meaningful without being urgent. Sometimes an idea disappears for weeks and then returns in a completely different context. PatternSpeak helps me notice those echoes without forcing them into a productivity system. It feels less like tracking and more like having a friendly observer tap me on the shoulder when a thread has quietly become a pattern. It works very well with the scan and analysis workflow I also shared here. Step-by-step: 1. I use PatternSpeak to periodically look back across my conversations. 2. It identifies ideas, themes, or approaches that keep resurfacing over time. 3. When it notices a recurring thread, it surfaces it as a gentle prompt rather than turning it into a task. 4. I review the recurring ideas and notice whether they have become meaningful patterns, even when they return in different contexts. 5. I use the scan and analysis workflow I also shared here alongside PatternSpeak.

Like many people, I had tasks scattered across emails, meeting notes, reminders, recurring responsibilities, and things I was simply trying to remember. Standard task managers helped me store tasks, but they did not solve the harder problem: turning unstructured information into a reliable daily and weekly execution system. I used ChatGPT Work and Codex to build a private, responsive task management application around the way I actually work. The system combines AI-assisted task capture with a Command Center, daily planning, weekly reviews, task lists, a Kanban board, recurring tasks, deadline reminders, search, filters, subtasks, comments, attachments, and a complete activity history. The most useful part is the connection between AI and execution. Emails and free-text descriptions can be interpreted with the OpenAI API and converted into structured tasks, reducing the amount of manual copying and organizing required. Step-by-step: 1. I mapped my real workflow by identifying where my tasks came from and what information I needed to manage them properly: title, description, status, priority, category, deadline, responsible person, subtasks, comments, attachments, recurrence, and activity history. I deliberately designed the system around my existing working habits rather than adapting my work to a generic task management template. 2. I used iterative conversations with ChatGPT Work and Codex to define the requirements, review the interface, build the application, test it, and refine individual functions. Instead of creating one enormous prompt, I worked in short cycles: describe a problem, implement the change, test it with real data, and improve it. 3. I built the application as a responsive web app that works across computers, tablets, and phones. Access is restricted through authentication, an approved-user allowlist, and server-side authorization because the system contains real personal and professional tasks. 4. I migrated my actual task history rather than starting with an empty demonstration: 238 tasks, 37 categories, 25 subtasks, 5 comments, and 671 activity records. I preserved invalid or disconnected historical records in a separate archive instead of silently deleting them. 5. I connected the application to the OpenAI API. The AI can interpret emails and free-text task descriptions and help turn them into structured, actionable tasks. The application also supports an email-to-task workflow, so actionable emails do not have to remain buried in the inbox. 6. I built a daily Command Center that gives me an overview of what requires attention, including deadlines, priorities, task status, and upcoming work. I use the daily planning view to decide what to focus on rather than simply working through the newest emails. 7. I added two complementary execution views. The task list is useful for searching, sorting, and filtering a larger number of tasks. The Kanban board gives me a visual overview of progress; tasks can be dragged between five status columns, and the new status is saved automatically. The default task list shows the newest tasks first, making newly captured work easy to find. 8. I kept the context inside each task by allowing every task to contain subtasks, comments, attachments, and a complete activity history. This keeps the reasoning, follow-up, and progress connected to a task instead of spreading them across several applications. 9. I automated recurring work and reminders. Recurring tasks are recreated according to their schedule, while deadline reminders help surface tasks before they become overdue. This is particularly useful for responsibilities that are important but easy to forget because they do not arrive as new emails. 10. I run a weekly review to check overdue work, upcoming deadlines, open commitments, and tasks that have stopped moving. I can then reprioritize, update statuses, and prepare the following week from the same system. 11. I preserved portability and control through Excel import and export and a full JSON backup. This gives me control over my information and reduces the risk of becoming dependent on one interface or platform. The result is not an autonomous agent making decisions on my behalf. It is a private execution system where AI handles part of the interpretation and structuring, while I remain responsible for priorities and decisions. It has given me one trusted place for capturing, reviewing, prioritizing, and completing work. The tools I used were: - ChatGPT Work - Codex - OpenAI API

“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.

My mother-in-law was diagnosed with cancer. Whenever she received a test result before her doctor had a chance to explain it, she would search Google for answers. I created a website with Lovable to help answer the questions someone might have after leaving the doctor’s office or seeing test results before receiving an explanation from their doctor. Claude helped create the website and infrastructure, and I took the code from Claude and finished the project in Lovable. I’m a finance professional with no coding background, but AI helped me build the website. www.curawellplan.com Step-by-step: 1. I identified a need for clearer answers when someone receives cancer-related test results before speaking with their doctor. 2. I used Claude to create the website and its infrastructure. 3. I took the code generated by Claude and continued building the project in Lovable. 4. I finished the website despite having no prior coding skills.

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.

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.

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've been thinking about the value of handoff documents and explanatory documents as we continue exploring efficient ways to work alongside AI to build software and improve communication. Even though we use many different tools, Markdown still has an important place. This new version of an HTML handoff document can document what exists, describe what could exist, or serve as a mockup for a brainstorm. It lets us communicate with remarkable fidelity through visuals, hierarchy, and formatting. It's also an efficient format for AI to understand. We shouldn't underestimate the significance of AI communicating with us through a visual medium. A visual flowchart with thoughtful design, layout, animation, and progressive disclosure can help us understand the logic and flow of incredibly complex systems much faster. I tried all kinds of tools, including React Flow and Mermaid. They're fun to experiment with, but Archify is a game changer for this use case. I can point it at any technology, repository, or brainstorm and work with it to build flowcharts with animations and clean, distinctive design. It's also completely free. https://tt-a1i.github.io/archify/# Step-by-step: 1. I identify whether I need to document what exists, explore what could exist, or mock up a brainstorm. 2. I use Markdown and an HTML handoff document to communicate the ideas with visuals, hierarchy, and formatting. 3. I consider tools such as React Flow and Mermaid for creating visual representations. 4. I point Archify at the relevant technology, repository, or brainstorm. 5. I work with Archify to develop a flowchart with animations, clean design, and progressive disclosure so the system's logic and flow are easier to understand.