If/when you purchase anything use the following code on checkout: md25PERCENT. Be sure you use the code. There is no way for us to change the price because you are a hero… You must use the code…
*Summary* This video captures a lively group discussion on leveraging AI like Claude for device automation, building custom tools with Rust and WebAssembly, and integrating notification systems. Participants share real-time demos of phone bridging, file conversion, OCR, and scripting solutions while exploring cross-platform challenges.
*Key Points* [00:00:00] – Tool Introduction and Discovery • Group explores AI-driven phone automation via ADB and MacroDroid for tasks like hotspot triggers and text extraction. • Claude assists in configuring settings and summarizing client messages from SMS.
[00:19:10] – File Conversion Tools with WebAssembly • Rust-based anydoc tool converts files to Markdown locally for LLM use, with WebAssembly version adding OCR fallback. • Tools run offline after caching and support recursive folder processing.
[00:28:54] – NTFY Notification System • NTFY enables simple phone alerts from scripts via HTTP requests, supporting bidirectional messaging. • Demo shows AutoHotkey integration for process completion alerts and potential restaurant app notifications.
[00:47:58] – Text Extraction and UIA/ACC Libraries • Mouse text tool updated with dual hotkeys for quick UIA or ACC access in apps. • Discussion compares library speeds and compatibility for automation testing.
*Brief Summary* The session highlights rapid AI-assisted prototyping for everyday automation hurdles. Participants plan private NTFY servers and refined tools while noting browser sandbox limits. Next steps include testing iOS compatibility and expanding notification features.
AHK Hero 2026 08 28 Friday
Summary This video covers a live discussion on building practical automation tools for clients, including ClipShare for device syncing via Cloudflare, Tailscale integrations, Rust-based inspectors, WebAssembly for browser apps without installs, and Grok voice agents for call handling. The group explores privacy, speed, and deployment challenges while troubleshooting Windows script issues.
Learn more about AI and Automation at: https://the-Automator.com Or consider joining our amazing Hero club here: https://the-Automator.com/Hero
Key Points [00:00:00] – ClipShare Tool Introduction • Demonstrates a progressive web app for copying text and images between devices using Cloudflare workers. • No accounts or installs needed beyond a browser, with auto-deletion after seven days and limits like 25MB per file. • Works across PC, Android, Mac, and iPhone while keeping data private.
[00:10:02] – Tailscale File Sharing Setup • Uses Tailscale VPN for seamless file and text transfer without Dropbox or network drives. • One machine acts as server; clients connect via keys for remote access. • Ideal for non-technical users on locked-down work computers.
[00:19:56] – Rust Inspector and WebAssembly • AI-generated ACC inspector tool in Rust for fast UI element inspection and control. • Explores WebAssembly for running compiled Rust apps in browsers with no local installs. • Benefits include cross-platform speed and access for corporate or restricted environments.
[00:49:42] – Grok Bots and Windows Fixes • Quick setup of Grok voice agents for phone or web support using site data. • Discusses Windows 11 script blocking, file unblocking via PowerShell, and signing executables. • Compares AutoHotkey antivirus flags to Rust alternatives for safer distribution.
Brief Summary The session highlights easy AI-assisted creation of client tools that bypass install barriers and boost efficiency. Next steps include testing WebAssembly apps, refining profiles for skills, and expanding Grok agents for real-world support calls.
Summary This video covers a live discussion on building practical automation tools for clients, including ClipShare for device syncing via Cloudflare, Tailscale integrations, Rust-based inspectors, WebAssembly for browser apps without installs, and Grok voice agents for call handling. The group explores privacy, speed, and deployment challenges while troubleshooting Windows script issues.
Learn more about AI and Automation at: https://the-Automator.com Or consider joining our amazing Hero club here: https://the-Automator.com/Hero
Key Points [00:00:00] – ClipShare Tool Introduction • Demonstrates a progressive web app for copying text and images between devices using Cloudflare workers. • No accounts or installs needed beyond a browser, with auto-deletion after seven days and limits like 25MB per file. • Works across PC, Android, Mac, and iPhone while keeping data private.
[00:10:02] – Tailscale File Sharing Setup • Uses Tailscale VPN for seamless file and text transfer without Dropbox or network drives. • One machine acts as server; clients connect via keys for remote access. • Ideal for non-technical users on locked-down work computers.
[00:19:56] – Rust Inspector and WebAssembly • AI-generated ACC inspector tool in Rust for fast UI element inspection and control. • Explores WebAssembly for running compiled Rust apps in browsers with no local installs. • Benefits include cross-platform speed and access for corporate or restricted environments.
[00:49:42] – Grok Bots and Windows Fixes • Quick setup of Grok voice agents for phone or web support using site data. • Discusses Windows 11 script blocking, file unblocking via PowerShell, and signing executables. • Compares AutoHotkey antivirus flags to Rust alternatives for safer distribution.
Brief Summary The session highlights easy AI-assisted creation of client tools that bypass install barriers and boost efficiency. Next steps include testing WebAssembly apps, refining profiles for skills, and expanding Grok agents for real-world support calls.
Summary The video captures a lively weekly developer meeting where the host showcases an array of custom tools built with Rust and AutoHotkey. Topics range from file conversion and virtual drives to media deduplication, transcription with diarization, and system utilities. The discussion highlights rapid AI-assisted development, performance gains from Rust, and practical integrations for productivity.
Learn more about AI and Automation at: https://the-Automator.com Or consider joining our amazing Hero club here: https://the-Automator.com/Hero
Key Points [00:00:00] – File Tools and Virtual Drives • Built a Rust-based file converter GUI with themes and fast copy-paste, plus virtual drive creation for frequent folders. • Discussed adding recycle bin support and admin privilege handling while comparing speed to Windows Explorer.
[00:10:04] – Virtual Webcam and Recording Features • Created a Rust virtual webcam with pause replay, logo overlays, transparency controls, and monitor border indicators. • Added recording pause functionality and fixed YouTube upload quality headers for better encoding.
[00:20:06] – Rust GUIs, DLLs, and Media Deduper • Explored Rust GUIs versus AutoHotkey preferences, single-instance forcing, and cargo libraries for reuse. • Demonstrated a media deduper using stratified sampling for fast duplicate detection across encodings.
[00:29:45] – Transcription and Diarization Tools • Built a local transcription GUI with GPU monitoring, FFmpeg audio extraction, and speaker identification via diarization. • Addressed commercial licensing challenges and plans for private API models with clients.
[00:39:41] – App Shortcuts, Focus Management, and CLI Tools • Added Windows app launching and DPI-friendly bars to taskbar tools, plus hotkeys to swap primary monitors. • Covered PDF to text GUI wrappers, Rust DLL examples for fuzzy search and CSV parsing, and DNS benchmarking.
Brief Summary The session emphasizes leveraging AI for quick tool creation, Rust’s speed for heavy tasks, and hybrid AutoHotkey integrations. Next steps include refining examples, testing Tailscale for remote access, and exploring V1/V2 compatible scripts. The group wraps up with plans to continue development and share updates.
Summary This video captures a group discussion among developers exploring advanced tool-building with Rust and AutoHotkey. They cover fast file operations, custom media probes, DLL integrations for seamless language calls, duplicate finders, and strategies for guiding AI to align with human decision-making without excessive micromanagement.
Learn more about AI and Automation at: https://the-Automator.com Or consider joining our amazing Hero club here: https://the-Automator.com/Hero
Key Points [00:00:00] – Tool Introduction and Discovery • Developers discuss a new AHK Explorer variant built in a separate folder to avoid conflicts, featuring fast Rust-based copy-paste using Windows clipboard for speed across programs. • They highlight assumptions in the tool like skipping duplicate checks for performance and plans for future parameters to handle overwrites or reviews.
[00:09:32] – Rust Media Probe and DLL Integrations • A lightweight Rust media probe replaces slower tools to extract video length, resolution, and FPS, staying under 2MB versus FFProbe’s 218MB. • Custom AutoHotkey and Rust DLLs enable direct calls between languages, reducing multiple executables and supporting hotkeys or GUIs from either side.
[00:18:55] – Duplicate Finder and Hotkey Concepts in Rust • A Rust duplicate finder scans for exact file matches via hashing, grouping by size for efficiency, with ideas for media hashing to detect similar videos at different qualities. • Hotkey systems and system tray features are recreated in Rust, with plans for crates to share triggers and active path detection.
[00:28:17] – AI Decision Alignment and Workflow Systems • Conversation shifts to training AI to match user preferences and outcomes rather than exact steps, using blue/red teams and orchestrators for planning, criticism, and fixes. • A dashboard tracks agent tasks, assumptions, and approvals to reduce micromanagement while preserving existing features via QA matrices.
Brief Summary The session wraps with reflections on AI’s rapid progress, the value of planning phases, and practical demos of Rust tools for menus and transcription aids. Participants agree on balancing speed, local processing, and clear priorities when building for clients or personal use, planning future collaborations.
Summary The video captures a team meeting on advancing automation tools by converting AutoHotkey scripts to Rust for speed and reliability. They explore AI coding with Fable 5 and Claude for rapid development, DLL integrations, memory management, and GUI versus backend roles. Discussions cover practical testing, benchmarks, and tool enhancements like file explorers.
Learn more about AI and Automation at: https://the-Automator.com Or consider joining our amazing Hero club here: https://the-Automator.com/Hero
Key Points [00:00:00] – Tool Conversion to Rust and AI Assistance • Team converts Automate My Task and UIA elements to Rust using Fable 5, noting quick results and bug fixes. • Rust handles actions fast after initial compile, while AutoHotkey manages GUIs and human interfaces. • Analogy shifts to AI as brains, AutoHotkey as eyes, and Rust as hands for efficient workflows.
[00:08:58] – Using Rust DLLs with AutoHotkey for UIA • Rust code compiles to DLL libraries for lightning-fast backend processing in UIA tasks. • AutoHotkey controls the DLL like COM objects, keeping visual elements familiar and fast. • Plans include testing for accuracy gains over native AutoHotkey UIA and custom libraries per app.
[00:17:51] – Fable 5 AI Capabilities and Memory Consolidation • Fable 5 one-shots complex tasks with minimal nudging, using scratch pads for better pre-work and checks. • Claude memory consolidated across folders via hooks and warnings to maintain consistent context. • Cleanup of Claude MD files and skills reduced token use and boosted context window efficiency.
[00:35:44] – Explorer Tool Updates and OneDrive Integration • AHK Explorer gains fixes for icons, navigation bugs, and size sorting to spot large folders quickly. • Ideas added for OneDrive and Dropbox shortcuts plus temporary virtual drives via context menu. • Path pasting now navigates to folders, improving developer workflow over standard Explorer.
Brief Summary The group plans benchmarks on Rust UIA versions, joint testing of genealogy automation, and further Explorer features like drive creation. Emphasis remains on leveraging AI for development while using Rust for performance-critical actions. They wrap with personal notes and weekend plans.
AHK Hero 2026 08 07 Friday
Summary This video captures a lively group discussion among developers exploring AI-assisted coding, Rust for performance gains over AutoHotkey, and custom tools for OCR, screen recording, file management, and virtual cameras. Participants share experiments with models like Claude, benchmark results, and ideas for private AI workflows using services such as OpenRouter and Replicate. The focus is on practical automation, reliability, and scaling tools while debating language choices and integration challenges.
Key Points – [00:00:00] – Tool Introduction and Discovery • Group reviews Rust virtual camera for background blur and agent-to-agent interfaces for querying automator tools. • Discusses custom APIs via Cloudflare workers and ideas for building a Zoom alternative using AI prompts. – [00:28:06] – Benchmarking AI Models • Demonstrates a tool running 30 tests across Rust, Python, and AutoHotkey to compare model performance and syntax validity. • Highlights Rust speed advantages and local debugging capabilities without heavy token costs. – [00:56:09] – Rust-based Recording Tool • Shows a lightweight Rust screen recorder embedding webcam views, far smaller than FFmpeg at just 2MB. • Notes faster performance and easier editing compared to OBS workflows. – [01:24:15] – Explorer and Launcher Tools • Updates to AHK Explorer and custom launchers for quick file access, Dropbox links, and folder size calculations. • Explores Rust rewrites for filtering speed while keeping AutoHotkey GUIs.
Brief Summary The call wraps with advice on using AI skills for exponential productivity gains, running weekly insights reviews, and balancing local versus cloud models for cost and privacy. Participants plan to refine tools further and shift Saturday calls due to summer schedules.
AHK Hero 2026 08 01 Saturday
Summary The video captures a team discussion on replacing FFmpeg with lightweight Rust tools for screen capture and audio processing. They explore AI-driven audio enhancement, file versioning options, mobile file transfer methods, and Cloudflare integrations for remote tools. The focus is on efficient Windows development while comparing Rust to AutoHotkey.
Learn more about AI and Automation at: https://the-Automator.com Or consider joining our amazing Hero club here: https://the-Automator.com/Hero
Key Points [00:00:00] – Tool Introduction and Rust Development • Team demos a new Rust-based screen capture tool using Windows Graphics Capture that replaces the large FFmpeg library. • Rust compiles to a tiny executable and leverages local DLLs for audio ripping to MP3 without extra dependencies. • Discussion highlights Rust strengths in video, audio, and multi-threading versus AutoHotkey for GUIs and hotkeys.
[00:10:01] – AI Noise Cancellation and Audio Enhancement • Explores CRISP and Zoom audio cleaning techniques using AI models for noise separation and speech enhancement. • Parakeet is identified as an ASR model rather than an LLM, suitable for transcription preprocessing. • Rust can integrate ONNX models for local offline audio pipelines with minimal delay.
[00:29:57] – File Versioning with Dropbox and OneDrive • OneDrive versioning is harder to access than Dropbox, which offers easy browser-based history and bulk activity revert. • Team prefers Dropbox for rare version recovery needs and avoids building custom tools.
[00:39:50] – Phone Bridge and File Transfer Solutions • Phone bridge research shows Python core limits iPhone support; Rust suggested for reliable WebSocket connections. • Progressive web app via Cloudflare workers proposed for secure QR-code file transfer and Stripe payments.
[00:49:44] – Cloudflare Workers and API Integrations • Cloudflare workers enable agent-to-agent tools, QR codes, and remote error reporting without paid accounts up to daily thresholds. • Plans include dummy account creation for users and vectorized databases for Whisper transcription.
Brief Summary The session ends with action items to test Rust on phone deck features and explore Cloudflare for broader remote access. The group agrees on balancing simplicity with powerful integrations while keeping tools lightweight and Windows-focused.
AHK Hero 2026 07 31 Friday
Summary The video captures a live developer discussion on building and refining AutoHotkey tools integrated with AI for Windows optimization, file management, recording workflows, and context efficiency. Participants demonstrate scripts for removing bloat, handling errors across monitors, overlaying webcams, renaming files, and diagnosing token usage. The focus is on practical automation and AI-assisted productivity improvements.
Learn more about AI and Automation at: https://the-Automator.com Or consider joining our amazing Hero club here: https://the-Automator.com/Hero
Key Points [00:00:00] – Windows Bloat Removal Tool • Script scans for unnecessary apps identified by Claude and allows selective uninstalls with restore point creation. • Handles both Store and built-in Windows 11 items while providing tooltips and admin mode support.
[00:10:02] – AI Protocols and Error Reporting • Explores agent-to-agent search protocols and Cloudflare-based remote error sending for multi-monitor setups. • Aims to capture version data and user reports automatically while staying within free bandwidth limits.
[00:20:00] – Webcam Overlay Recording Tool • New tool burns webcam feed directly into desktop recordings for instant preview without separate streams. • Features auto-move away from mouse, area selection, and direct export to editors like DaVinci Resolve.
[00:29:59] – File Renamer and AI Doctor Tools • Simple file renamer gains regex support and parameter handling while fixing path and license issues. • AI Doctor analyzes skills and Claude MD files to cut token load by removing unused or duplicate items.
Brief Summary The group wraps up by stressing careful context management, security with plugins, and choosing the right AI interface for vibe coding versus manual work. They plan further refinements to the tools and encourage users to set API limits.
AHK Hero 2026 07 25 Saturday
Summary This video captures a casual group discussion among tech enthusiasts exploring AI tools, audio and video processing techniques, custom scripting solutions, and productivity enhancements. Participants share experiments with models like Claude and Kimmy, FFmpeg-based recording tools, error reporting systems, and a specialized podcast clipping app. The conversation blends personal anecdotes with practical tech insights and collaborative problem-solving.
Key Points [00:00:00] – AI Model Costs and Open Router Alternatives • Group compares pricing across models including Claude 5, Kimmy, and Grok, noting high costs for frequent use. • Discussion covers open-source options and differences between token-passing services and model-spinning platforms like replicate.com. • Users update custom Gurus to balance smart responses without excessive expense.
[00:09:07] – Audio Cleanup and FFmpeg Recording Tools • AI audio regeneration is tested for noise reduction on long clips, with warnings about voice switching and word errors. • New FFmpeg tool captures webcam and screen separately for easier editing in DaVinci Resolve. • Audio syncing via dual tracks enables precise alignment without echo.
[00:18:07] – Multi-Monitor Error Reporting Scripts • Script improvements push error messages to the active mouse screen for better visibility across monitors. • WebSocket and Cloudflare ideas proposed for remote error delivery without local display. • Real-time demonstrations show flexible notification handling for client support.
[00:27:14] – Pod Clipper Editing Workflow • Tool analyzes topics, suggests hooks, removes fillers, and adds B-roll prompts for short-form clips. • Supercut features combine multiple hooks with fades and sound effects while preserving context. • Time savings highlighted, dropping editing from hours to minutes for podcast teasers.
Brief Summary The session wraps with ideas for waveform word overlays, concept-change detection in medical transcriptions, and faster file search utilities. Participants emphasize borrowing features across tools and using AI to prototype quickly. They close by sharing upcoming plans like AI meetups and tool refinements for broader use.
AHK Hero 2026 07 24 Friday
Summary This video captures a group discussion among developers sharing custom AI-powered tools for podcast and video editing. They demonstrate a feature-rich non-linear editor that auto-detects topics, removes filler words, suggests B-roll, and applies audio fixes. The conversation also covers utility tools, workflow automation, and best practices for building reliable AI-assisted applications.
Learn more about AI and Automation at: https://the-Automator.com Or consider joining our amazing Hero club here: https://the-Automator.com/Hero
Key Points [00:00:00] – Podcast Editor Tool Introduction • Custom non-linear editor built via AI prompts for podcast workflows. • Auto topic discovery, filler word removal, crossfades, and B-roll suggestions from transcription. • Supports local or API models and loads prior projects automatically.
[00:10:02] – Video Editing Strategies and Motion Detection • Emphasis on strong hooks in first seconds and variable padding for smoother early cuts. • FFmpeg integration for motion scoring to trim dead screen time without losing context. • Noise reduction comparisons and plans for tighter initial segments.
[00:19:46] – Utility Tools and Naming Challenges • Caps changer tool with text wrappers and alternate key mappings. • Discussion on tool naming as features expand beyond original scope. • Modular design advice using command-line interfaces for easier AI maintenance.
[00:29:41] – YouTube Publishing and Workflow Management • Exploration of upload automation options and their risks or limits. • Topic lists in shared documents to guide flexible hero calls. • Logging and test generation to debug AI-generated code reliably.
Brief Summary The session highlights rapid prototyping of specialized tools to cut editing time dramatically while stressing modular approaches, logging, and testing for stability. Participants plan further refinements like waveform visuals and broader automation.
AHK Hero 2026 07 18 Saturday
Summary This video captures a team discussion on debugging and improving custom Windows tools, including Autostart Manager search features, AI-assisted code fixes, Windows optimization scripts for RAM savings, and registry management utilities. Participants explore practical AI workflows, model choices, and UI enhancements while sharing screens to test changes live.
Learn more about AI and Automation at: https://the-Automator.com Or consider joining our amazing Hero club here: https://the-Automator.com/Hero
Key Points [00:00:00] – Tool Introduction and Discovery • Team reviews Autostart Manager issues like missing search and tab refresh problems. • They discuss adding filters and columns for startup sources such as registry or folders. • AI is noted as ideal for quick view toggles without heavy coding effort.
[00:09:31] – Snipping Tool and Admin Window Fixes • Windows Snipping Tool undo feature is praised for text, arrows, and highlights. • Task Manager popups fail due to admin rights, requiring workarounds or elevated scripts. • Live clipboard updates changed after undo addition, needing manual copy steps.
[00:28:27] – Windows Optimization Script Review • Tool disables telemetry, delivery optimization, and indexing to free RAM. • Tooltips from AI explain each setting impact for user decisions. • Real-world memory savings measured on team PCs rather than AI estimates.
[00:47:29] – Registry and Startup Cleaner Enhancements • Startup cleaner removes unwanted entries from Task Manager lists via registry edits. • Filter search added across columns plus icons for missing or disabled items. • Hooks trigger syntax checks after AI code changes for reliability.
Brief Summary The session ends with successful registry path jumps and GUI width fixes, plus plans to prioritize time-saving AI models. The group stresses incremental AI prompts and real testing to refine tools safely.
AHK Hero 2026 07 17 Friday
Summary This video covers a team discussion on developing an AutoStart Manager tool inspired by Microsoft Autoruns. It explores debugging hangs and admin elevation issues, then shifts to advanced AI techniques like hypothesis-based debug skills, probes, agents, and subagents for efficient code fixes.
Key Points – [00:00:00] – AutoStart Manager Introduction and Demo • Tool manages startup items across registry, folders, tasks, and services. • Demo shows tabs for different startup locations and admin run needs. • Discussion on adding AI descriptions for unknown Microsoft services. – [00:09:34] – Debugging Tool Hangs and Admin Issues • Tool locks up during ListView loads or column resizes, especially in admin mode. • Explored taskbar debug options and Task Manager monitoring for CPU activity. • Team debates always-run-as-admin versus optional elevation button. – [00:19:03] – AI Debug Skills and Hypothesis Formulation • Skill splits into hypothesis generation, instrumentation, and log evaluation. • AI creates targeted probes to test 3-7 possible causes without full file reads. • Multiple cycles usually isolate and fix bugs in 2-3 runs. – [00:28:33] – Instrumentation and Probe Objects for Debugging • Probes use standardized JSON objects tracking ID, cycle, hypothesis, expected versus observed values. • Language-independent validation ensures probes fit any codebase. • Skills allow conditional file reads to save tokens during tool calls.
Brief Summary The session highlights practical AI workflows for repeatable debugging and token-efficient agent use. The group plans to refine the AutoStart tool with better elevation handling and test scheduled AI commands for ongoing maintenance.
AHK Hero 2026 07 11 Saturday
Summary The video shows a group discussing practical AI tool builds and enhancements during a Saturday call. They cover a progressive web app for easy payment QR codes, phone-based shortcuts mimicking a stream deck, NFC automation ideas, and AI workflow improvements like handoffs and voice controls. The focus is on streamlining daily tasks with custom tools.
Key Points [00:00:00] – PWA for Payment QR Codes • Demo of a simple web app allowing users to generate Cash App or Venmo QR codes with preset amounts and account details. • Built as a PWA that works locally on phones for quick in-person payments at a neighbor’s auction business. • Link can be shared so others customize it for their own accounts without extra setup.
[00:08:57] – Phone Deck Updates and Shortcuts • Added features to save PNGs and launch Windows apps or folders directly from phone buttons. • Pre-built shortcuts for system tools like device manager, recycle bin, and recent files reduce need to recall commands. • Tool imitates a stream deck with dynamic buttons that change based on active apps like Zoom.
[00:17:50] – NFC Tags for Automation • Idea to use cheap NFC tags to trigger actions like turning on monitors or home devices via phone tap. • Discussed integration with existing tools for home automation without complex BLE detection. • Tags offer simple, inexpensive triggers for computer or household tasks.
[00:26:44] – AI Handoff and Model Switching • Compared handoff methods between users and agents, noting benefits of new threads for model and effort changes. • Tested switching models like from low-effort Fable to Opus during tasks to optimize costs. • Explored hooks and JSON edits for reliable model control in VS Code or terminal.
[00:53:24] – Voice Input and Foot Pedal • Foot pedal setup for dictating text, improving prompts with AI, or running commands like opening apps. • Voice input helps with clarity but users note typing aids focus before sending to AI. • Custom actions limited to running programs for safety and ease.
Brief Summary The session wraps with plans to share the WordPad tool for rich text and hyperlinks, plus ongoing tweaks to the phone deck. Participants emphasize keeping tools simple and practical while exploring AI for automation. They end by scheduling the next call.
AHK Hero 2026 07 10 Friday
Summary The video explores advanced AI workflows for software development, focusing on agent swarms, planning versus interactive approaches, token efficiency, debugging loops, handoff processes, and custom tools like phone decks and context menu managers.
Learn more about AI and Automation at: https://the-Automator.com Or consider joining our amazing Hero club here: https://the-Automator.com/Hero
Key Points [00:00:00] – AI Swarm Technology and Agent Roles • Discussion of converting a Linux-based swarm repo to run on other systems using AI assistance. • Emphasis on specialized agents with clear roles managed by a higher-level coordinator. • Comparison of upfront detailed planning versus iterative interactive prompting.
[00:09:23] – Planning, Token Usage, and Session Management • Long plans increase token consumption by repeating context in every generation. • Use of plan MD and session MD files to track progress without reloading full history. • Starting fresh chats after milestones preserves context window and reduces costs.
[00:18:37] – Debugging Loops and Feedback Mechanisms • Custom debugging agents that form hypotheses, instrument code, and iterate with user validation. • Importance of feedback loops to verify outputs and avoid repeated reprompting. • Trade-offs between expensive looping in one chat versus cleaner handoffs to new sessions.
[00:27:55] – Handoff Files and Model Workflows • Adversarial reviews of handoff files to catch ambiguities before passing to lower models. • Switching between high-thinking models for planning and efficient models for implementation. • Centralized plan files enable collaboration across machines without losing state.
Brief Summary Participants shared practical implementations of these methods along with tools for automation, audio cleanup, and menu customization. They highlighted ongoing experiments with progressive web apps and model comparisons to refine efficient AI-driven development.
AHK Hero 2026 07 04 Saturday
Summary The video captures a July 4th group discussion on enhancing small local AI models to mimic reasoning from flagship systems like Claude. Participants explore deterministic scripts, skills optimization, tool integration, and hybrid workflows to reduce reliance on large models while maintaining performance.
Key Points [00:00:00] – Introduction and Mimicking AI Thinking • Group opens with holiday greetings and shifts to replicating thinking processes in smaller models via logic checks and error handling. • Conversation covers building partial advantages without full flagship capabilities aiming for 80-90 percent effectiveness.
[00:10:07] – ASM Tool Modes and Deterministic Edits • Discussion on review versus auto-accept modes in ASM for code updates without diff viewers. • Emphasis on keeping file writes deterministic in AutoHotkey rather than handing control to AI.
[00:19:59] – Skills Management and Token Savings • Explores splitting skills into short workflows plus reference files to avoid bloating context on every turn. • Conversion of repetitive actions to scripts reduces token use and improves consistency.
[00:29:57] – Tool Usage and Local LLM Integration • Details defining functions for AI tool calls like OCR then executing them locally via HTTP to services such as Ollama. • Covers switching between models based on task needs while preserving OpenAI-compatible APIs.
[00:39:54] – Model Loading and Hybrid Reasoning • Strategies for loading small decision models alongside larger ones on limited RAM to handle planning and execution. • Explores pseudocode translation loops and spotting vague requests to enable local models to perform reliably.
Brief Summary The session concludes that blending powerful models for planning with local LLMs and deterministic checks can cut token costs dramatically. Participants agree this hybrid approach offers a practical path to lower dependency on expensive flagship subscriptions.
AHK Hero 2026 07 03 Friday
Summary
This video captures a group discussion on AI tools, model optimization, and practical workflows. Participants explore hardware choices, quantization techniques, and when to use RAG systems, skills, or fine-tuning for tasks like copywriting. They also cover agent loops, environment security, and emerging AI companion features.
Learn more about AI and Automation at: https://the-Automator.com
Or consider joining our amazing Hero club here: https://the-Automator.com/Hero
Key Points
[00:00:00] – AI Bot Glitches and Hardware Choices
• Group troubleshoots duplicate bot notifications and discusses renting servers or upgrading RAM and GPUs for local LLM training.
• Speaker shares plans to test models without buying expensive hardware outright.
[00:09:37] – Quantization and CPU vs GPU Performance
• Explains how rounding model numbers reduces precision yet keeps most intelligence while speeding up CPU runs.
• Notes cheaper CPU RAM allows larger models despite slower speeds compared to GPU VRAM.
[00:19:14] – RAG, Skills, and Fine-Tuning Comparison
• Defines RAG for fact retrieval, skills for style tweaks, and fine-tuning for behavior changes.
• Stresses skills are easiest to build yet may fail if they contradict model training.
[00:28:45] – Model Parameters and Agent Safety
• Covers mixture-of-experts designs in large models and risks of runaway loops burning API credits.
• Advises using different tokens per app and avoiding environment variables for security.
Brief Summary
The session wraps with tips on creating modular skills via conversation with AI and building custom tools like context menus. Participants emphasize testing locally first and documenting workflows to share knowledge. They close by noting rapid AI interface changes and the value of focused agents over trends.
This AutoHotkey community meetup covers a wide range of productivity tools being developed, including a QR code action generator, a local AI interface using Chrome’s Nano model, a custom File Explorer replacement, a Phone Bridge tool for PC-to-phone interaction, FFMPEG-based media tools, and a concept search engine powered by embeddings. The discussion highlights creative approaches to eliminating browser dependencies, leveraging local AI, and building practical utilities with AutoHotkey.
*Key Points*
[00:00:00] – QR Code Tool and Action Driver Demo
• A fancy text generator tool was updated with barcode and QR code generation capabilities.
• The new QR Action Driver supports generating codes for Wi-Fi joining, contact cards, Telegram links, PayPal donations, Dropbox file sharing, and more.
• A “Neat Ideas” button helps users discover creative uses for QR codes they may not have considered.
• Cloud detection supports Dropbox, Google Drive, and OneDrive link generation.
[00:09:23] – Local AI via Chrome Nano Model
• A local HTML page was built to interface with Google’s Nano LLM model running inside Chrome, requiring no internet connection.
• The 4GB model runs locally on the CPU and can answer questions, check grammar, or assist with tasks privately.
• The team explored options for shipping tools with built-in AI access, including renting servers versus using local models to avoid API token configuration.
• Firefox cookies were identified as accessible (unlike Chrome), potentially enabling browser-free API automation.
[00:18:38] – Custom File Explorer and Phone Bridge
• A fast AutoHotkey-based File Explorer replacement was demoed, featuring toggleable folder sizes and customizable file property columns from 1500+ options.
• The Phone Bridge tool uses the Python library SCRCPY to mirror, control, and send texts to an Android phone from the PC.
• Discussion covered RCS vs SMS messaging limitations with Windows Phone Link and Google Messages automation via UIA and Graffitium.
[00:37:07] – FFMPEG Media Tools
• A Media Shrinker tool detects and removes silence from audio and video files, with adjustable playback speed, all powered locally by FFMPEG.
• A Watermark tool (in progress) lets users drag in an image, position it, adjust opacity, and burn it into video files.
• Stephen shared a fun FFMPEG script that converts ringtones into plain beep sequences, noting limitations with polyphonic audio.
[00:46:20] – Auto Start Manager and Concept Search
• An Auto Start Manager recreates Microsoft’s Autoruns functionality, letting users view, enable, and disable startup items, scheduled tasks, and services.
• The Search on Concept tool uses AI embeddings stored in SQLite databases to find content by idea rather than exact keywords across PDFs, Excel files, and media.
• Practical use cases include searching religious texts, student textbooks, or legal documents by concept, with results linking to specific page numbers.
[00:55:39] – Startup Script Management and Tool Versatility
• A new library was created to add an “Add to Startup” option in the system tray of any AutoHotkey script, eliminating the need for one master script to launch all others.
• This mindset shift means individual tools register themselves with Windows startup independently, reducing cascading restarts.
• The team highlighted AutoHotkey’s versatility in combining FFMPEG, SQLite, AI embeddings, and Python libraries to rapidly build powerful tools.
[01:02:00] – Custom Taskbar and Wrap-Up
• The custom taskbar automatically switches from labeled view to icon-only view when too many windows are open to prevent overflow.
• Icon size is adjustable, and sticky note integration is planned as a future addition.
• The session closed with acknowledgment of ongoing work across all demoed tools.
*Brief Summary*
The meetup showcased an impressive array of AutoHotkey-powered productivity tools spanning QR code generation, local AI integration, file management, phone control, media processing, and semantic search. The overarching theme was reducing friction for end users by eliminating browser dependencies, API token requirements, and complex configurations, while leveraging local processing and AI embeddings to create fast, practical utilities.
AHK Hero 2026 06 Friday
*Summary*
This two-hour session covers AutoHotkey scripting tips, a deep dive into running local LLMs on personal computers, model selection and GPU requirements, fine-tuning a custom AutoHotkey V2 coding model, and the practical tradeoffs between local and cloud-based AI for development tasks.
Learn more about AI and Automation at: https://the-Automator.com
Or consider joining our amazing Hero club here: https://the-Automator.com/Hero
*Key Points*
[00:00:00] – AutoHotkey Launcher and Version Selection
• A participant asks how to run both AHK V1 and V2 scripts from a third-party app (Touch Portal)
• The built-in AHK launcher script auto-detects script version and launches the correct interpreter
• Solution: pass three paths – the AHK V2 exe, the launcher script, then your target script
[00:09:31] – Local LLM Demo with Custom AutoHotkey Model
• Irfan demos a 2GB fine-tuned model running locally via Ollama for AHK coding assistance
• The model responds in under 60 seconds but struggles with file editing and correct paths
• Discussion of limitations: the small model lacks reasoning and needs more training examples
[00:18:54] – Local AI Tools Overview and API Setup
• Three tools compared: LM Studio and Jan AI (host plus UI) vs Ollama (server only, developer-focused)
• All use llama.cpp under the hood and can serve OpenAI-compatible API endpoints on localhost
• An AHK script can call local models the same way it calls OpenAI – just swap the URL to localhost
[00:28:19] – Model Loading, GPU Memory, and Speed Benchmarks
• Live demo: a 4B parameter model runs at 8 tokens/sec (spilling to CPU), while Gemma 4 (effective 2B) hits 19-25 tokens/sec
• Key rule: if a model exceeds your VRAM, it bleeds into CPU RAM and becomes painfully slow
• Model fit is everything – check VRAM first, then pick the largest model that fits entirely in GPU memory
[00:37:42] – Model Selection and Hugging Face Discovery
• LM Studio shows staff picks and fit indicators; Hugging Face is the definitive catalog with 500K+ models
• Use GGUF format and filter by llama.cpp compatibility for local use
• Vision, tools, and reasoning capabilities increase model size significantly
[00:47:13] – Understanding Model Naming and Parameters
• “B” means billion parameters; active vs effective parameter counts explained
• Quantization levels (Q4, Q8) trade quality for size – higher quality means larger files
• Context length and KV cache placement on GPU vs CPU dramatically affect speed
[00:56:34] – Tweaking Settings and Joe Joins the Discussion
• Temperature, context size, and GPU layer offloading are all adjustable in local tools
• Training a model requires more GPU than running one – Joe couldn’t build a 7B model on his 12GB GPU
• Training was done via Claude conversation, using Open Router, WSL, and iterative improvement
[01:05:58] – Chrome’s Built-in Nano Model and Browser Extensions
• Google Chrome ships a 4GB nano model used for autocomplete, grammar, and URL safety checks
• You can build Chrome extensions that call this local model for tasks like HTML-to-CSV extraction
• Caution: understand what a model was built for before relying on it for other tasks
[01:15:26] – Multi-Model Loading and REST API Testing
• Live test: two models loaded simultaneously on LM Studio’s local server, queryable via curl
• Each model accessible by name in the API request body – works like switching between OpenAI models
• Concept proposed: a tiny router model picks which specialized model handles each task
[01:24:46] – Fine-Tuned vs General Models for Code Quality
• The custom AHK model produced the cleanest V2 syntax across 150 benchmark tests on 12 models
• Strategy: use a large reasoning model for planning, then a fine-tuned model for writing correct syntax
• AHK executable can validate syntax (returns 0 or 1), then pass failures to the specialized model
[01:34:11] – Logic Bugs vs Syntax Errors in Small Models
• Missing parentheses in ternary expressions are logic issues disguised as syntax problems
• Small fine-tuned models excel at syntax but may miss logical correctness requiring reasoning
• A 2B parameter reasoning model (under 1GB) could potentially catch logic issues without needing a frontier model
[01:43:37] – Integrated Graphics, Shared Memory, and Hardware Realities
• Irfan’s 128MB VRAM uses shared RAM (16GB) – functional but slow for AI workloads
• Dedicated GPUs with 4-12GB VRAM recommended; power consumption and cost are real constraints
• Joe demos local transcription via Parakeet at 13-40x speed on his RTX 3060
[01:53:04] – Training Process Walkthrough and RAG vs Fine-Tuning
• Joe trained the model by conversing with Claude, providing AHK docs, 2000+ scripts, and course subtitles
• Training cost was minimal via Open Router; four model versions were created iteratively
• RAG complements existing models with indexed data; fine-tuning bakes knowledge directly into a smaller model
Hero Call 2026 06 20 Saturday
*Summary*
This is a weekly team meeting covering updates to ASM (AutoHotkey Script Manager), new tool demos, and AI-assisted development workflows. The team discusses bug fixes, a token cost analysis tool, a custom file explorer, an AI-powered semantic search tool, strikethrough rendering challenges, and a rich text editor with hyperlink support.
*Key Points*
[00:00:00] – ASM Update and Bug Discussion
• The latest ASM release includes updated notify and script object changes, plus a local LLM option that is not yet ready for public release.
• A bug was identified where clicking “Exit App” on a runtime error dialog accidentally closes ASM itself instead of just the running script.
• The team realized the issue was user error (clicking Exit App on ASM’s own dialog), but agreed ASM should have custom error dialogs to distinguish editor errors from script errors.
• A “token burn” tool was introduced to benchmark AI model costs across different effort levels and thinking modes, charting expenses per model.
[00:09:35] – Token Cost Analysis and Custom File Explorer
• Cost analysis charts show Haiku scales almost linearly by effort, while Opus 4.7 costs jump significantly at max effort. Enabling thinking adds only modest cost.
• The team discussed using cheaper models like Haiku for simple goal-checking tasks in AI loops, reserving expensive models for complex work.
• A custom AutoHotkey File Explorer was demoed, powered by a fast C library, featuring folder size display, toolbars, status bar, dark theme, and system tray icon integration.
• An Auto Start Manager tool was shown, listing all Windows startup programs from registry and startup folders with enable/disable functionality.
[00:19:13] – Java Inspector, Triggers Class, and Embedded Search Tool
• A new Java inspector tool allows inspecting Java applications to pull text and values, expanding AutoHotkey automation capabilities.
• The updated Triggers class now supports special key selection via dropdown, including function keys, mouse buttons, and remapped foot pedal keys (F13-F15).
• The team discussed integrating Auto Hard Intercept for detecting non-standard input devices that AutoHotkey cannot see by default.
• An AI-powered embedded semantic search tool was introduced – built overnight by Claude – that converts PDFs, audio, video, and Excel files to text, then searches by concept using embeddings.
[00:28:41] – Semantic Search Deep Dive and AI Development Workflow
• The semantic search tool uses embeddings to match concepts rather than exact text, functioning as an “ultimate fuzzy match” across multiple file types.
• For video files, it currently searches transcriptions only, not visual content, though Google’s embedding model could handle images directly.
• The tool was built using a “night shift” workflow: outlining requirements, pointing to existing libraries (Mark it Down, transcriber), and letting Claude build it overnight.
• A lesson learned: building two parallel Claude threads with incompatible embedding models required redoing one side, reinforcing the value of keeping work in a single flow.
[00:38:15] – Strikethrough Rendering Challenge
• The Scintilla control in the notify tool rendered strikethrough text underneath characters instead of through them, despite correct Unicode usage.
• The workaround uses GDI to draw a fake line through the text, though the issue resurfaced during the demo.
• The checklist tool achieves strikethrough by inserting a Unicode combining character (0x0336) after each character, which overlaps visually in edit boxes.
• The team agreed to revisit the approach using the proven combining-character technique from the checklist tool.
[00:47:47] – File Explorer and XP Search Tool Merger
• The custom File Explorer and XP Search tool will be merged into one application since both use the same C search engine.
• The XP Search tool offers powerful filtering: keyword inclusion/exclusion, file type, size, date ranges, and searching within 15,000+ files quickly.
• Plans include adding zip file content searching and shared preferences between the explorer and search views.
[00:57:22] – Rich Text Editor, Hyperlinks, and Newsletter Workflow
• A WordPad replacement rich text editor is being built, with plans to add hyperlink support via Ctrl+K insert dialog.
• The editor will enable rich text hot strings in Prompt Assistant, allowing users to paste colored, formatted text via AutoHotkey.
• The “ask gurus” command was renamed to just “gurus” and now supports resuming previous projects by referencing local markdown files.
• Newsletter workflow improvements include auto-hyperlinking keywords and auto-bolding hyperlinks via regex, eliminating manual formatting steps.
[01:06:52] – Closing
• The team wraps up and plans to continue next Friday.
AHK Hero 2026 06 19 Friday Hour 2
*Summary*
In this team discussion, the speakers review an AI-generated spreadsheet ranking various Windows automation interfaces and techniques by difficulty and prevalence. They walk through lesser-known approaches such as Java Access Bridge, named pipes, local proxies, and the Windows Event Log, discussing which ones they already use and which deserve deeper exploration. The conversation closes with reflections on AI’s role in development – its power for non-coders, its current limitations for maintaining complex codebases, and concerns about long-term scalability.
*Key Points*
[00:00:00] – Reviewing the Automation Techniques Spreadsheet
• Speaker A shares a spreadsheet (originally created with AI help) that ranks Windows automation interfaces by difficulty and usage prevalence.
• They discuss WebView2 and Electron via CDP – difficult to use but yielding excellent results, especially when paired with AI assistance.
• Event hooks and shell verbs are confirmed as already available in their toolkit, though triggering versus reading capabilities need clarification.
• Local sockets and websockets (e.g., OBS) are noted as powerful but poorly documented; AI can help discover undocumented socket APIs.
• Task Scheduler is highlighted as criminally underrated for drip campaigns, queued execution, and simple one-time scheduled tasks.
• A key insight emerges: the ACC (Accessibility) library is significantly faster than UIA for reading elements and getting text, while UIA is better for setting values on modern controls.
• Custom URL protocols (like Telegram’s) are recognized as a viable automation path they already use with Stream Deck.
• Java Access Bridge is identified as a valuable but overlooked technique for automating Java-based applications, similar to how AutoHotkey accesses Microsoft controls.
[00:08:47] – Deep Dive into Advanced and Obscure Interfaces
• Local proxies are discussed for intercepting and modifying web requests before they reach a server, with Fiddler cited as an example that handles TLS decryption via custom certificates.
• Windows Graphics Capture is speculated to relate to screenshot-based automation and OCR workflows, tying into AI-driven computer use approaches.
• Microsoft’s upcoming core-level automation approach is mentioned as both interesting and “creepy.”
• ETW (Event Tracing for Windows) subscriptions and CV object detection remain unfamiliar to the speakers and are flagged for follow-up research.
• Named pipes are explained as inter-process communication channels – like a shared file between two programs but without a visible file on disk.
• WSL (Windows Subsystem for Linux) is noted as increasingly relevant for accessing advanced Linux command-line tools from Windows.
• WinApp Driver is praised for providing full XML control trees of application windows, useful for AI-driven click targeting.
• The Windows Event Log is called “criminally underrated” – programs generate thousands of logged events that could inform automation decisions.
[00:17:17] – Process Monitoring, AI Reflections, and Scalability Concerns
• Process Monitor is discussed as a complementary tool to the Event Log for tracking file changes, registry modifications, and program events in real time.
• The team considers using Process Monitor as a command-line tool that feeds events into automation scripts for decision-making.
• Keyboard and mouse hooks versus RAW input are compared: hooks filter noisy data while RAW input captures everything.
• WHCBT message hooks remain unknown and are flagged for future investigation alongside ETW and CV objects.
• The speakers reflect on AI’s practical value: non-coders can build functional tools, but developers face friction because AI-generated code is hard to maintain.
• A scalability concern is raised – AI infrastructure depends on a single chip manufacturer, and rising demand may eventually outpace supply, driving up token costs.
• They acknowledge that AI will not replace developers soon, but will change how developers work, enabling faster creation for those who understand the fundamentals.
*Brief Summary*
The team conducted a thorough review of over 20 Windows automation interfaces, identifying several underutilized techniques like Task Scheduler, ACC library speed advantages, Java Access Bridge, and the Windows Event Log that could significantly improve their automation toolkit. They plan to research the unfamiliar items further and share findings with the broader team, while maintaining a balanced perspective on AI – embracing its power for rapid prototyping but recognizing that code maintenance and infrastructure scalability remain real challenges.
AHK Hero 2026 06 19 Friday Hour 1
*Summary*
This is a team development call covering AutoHotkey tooling, GPU-accelerated transcription with Parakeet, hidden window notifications for screen sharing privacy, and a deep discussion on AI coding agent workflows including token management, thinking effort levels, hooks vs. skills, and project planning strategies using Claude Code and VS Code.
Learn more about AI and Automation at: https://the-Automator.com
Or consider joining our amazing Hero club here: https://the-Automator.com/Hero
*Key Points*
[00:00:00] – Catching Up and Project Updates
• Team exchanges greetings and discusses productivity gains and time perception when working intensely with AI tools
• One member shares struggles building an AutoHotkey interface for Google Calendar integration, hitting OAuth authentication hurdles
• Discussion of a quick-add hotkey for the simple checklist tool to avoid workflow interruptions
[00:09:32] – GPU-Accelerated Transcription and Context Menu Tools
• Speaker built a custom Parakeet transcription tool using GPU acceleration, transcribing hour-long videos in about six minutes
• Added right-click context menu integration for transcribing files to SRT format directly from folders
• Demonstrated foot pedal setup for voice commands and dictation, with auto-muting Zoom during transcription
• Proposed using embeddings to match voice commands to actions for more flexible voice control
[00:19:02] – Hidden Notifications and Screen Sharing Privacy
• Demonstrated the Notify class update that hides notifications from screen capture using SetWindowDisplayAffinity DLL call
• Built a tool that reads Windows notifications in Do Not Disturb mode and re-displays them in hidden windows only visible to the user
• Discussed use cases: hiding API tokens in GUIs, cheat sheets during presentations, and a WordPad clone built overnight by AI
• Explored the concept of shadowing windows to show different content to the user vs. screen share viewers
[00:28:32] – DWM API and Window Management Deep Dive
• Shared the actual DLL call code for SetWindowDisplayAffinity that enables the hidden window feature
• Discussed the DWM (Desktop Window Manager) API capabilities including window cloaking and overlap detection
• Transitioned to frustrations with AI agent interfaces in VS Code lacking unified features for agents, queuing, steering, and goals
[00:38:07] – AI Agent Control: Speed vs. Fine Control
• Debated the tension between wanting AI to just work autonomously vs. needing fine-grained control over behavior
• Discussed AI generating 5,000 lines of code in minutes but needing control over how it builds
• Covered issues with AI tools creating work trees without cleanup, and the need for hooks to enforce consistent behavior
[00:47:32] – Hooks, Skills, and Deterministic AI Behavior
• Explained hooks as event-driven scripts that trigger deterministically, unlike skills which can be ignored by AI
• Demonstrated practical hook examples: syncing skills to shared folders, notification popups when AI needs input
• Discussed the handoff skill approach for keeping context windows short and enabling team collaboration
[00:57:04] – Token Usage and Thinking Effort Strategy
• Compared token burn rates between team members, discovering that medium thinking effort on Opus uses far fewer tokens
• Revealed that disabling MCPs and using CLI reduced token consumption significantly
• Discussed the need for a profile changer tool to quickly switch between different AI configurations
[01:06:34] – Model Selection and Reasoning Level Guidelines
• Proposed framework: use high reasoning for planning multi-file features, medium for implementation, extra high for debugging
• Discussed the risk of overanalyzing burning unnecessary tokens and going down complex tangents
• Introduced the “Ask Gurus” approach of bouncing problems off multiple AI models instead of raising thinking effort
• Suggested building a visual indicator or auditory alert for when high token burn modes are active
[01:16:07] – Local LLMs, GPU Costs, and Industry Trends
• Explored running local LLMs on consumer GPUs with limited VRAM, finding Google Gemma fastest at 25 tokens per second
• Discussed whether renting GPU servers would be cost-competitive with API subscriptions
• Noted AI companies may shift to credit-based pricing, making local alternatives more attractive
• Mentioned upcoming Nvidia Spark and Microsoft hardware partnerships for local AI workloads
[01:25:33] – Project Planning Workflows and MD File Strategy
• Described a “Thoughts folder” approach: saving individual planning discussions as MD files for persistent context
• AI then reads all thought files to generate architectural specs and tracking checklists
• Compared this to the handoff skill approach, noting both achieve similar results with different token costs
AHK Hero 2026 06 13 Saturday Hour 1
*Summary*
This team meeting covers a wide range of AutoHotkey development topics including the Claude Fable AI model being blocked by the government, token usage concerns, new tool demos (text font changer, Windows quick-access launcher), updates to the Quick Raw Edit video tool, XP File Search architecture decisions, ASM skill management, code obfuscation strategies, and the advantages of AutoHotkey over Python for Windows automation.
*Key Points*
[00:00:00] – Claude Fable Blocked and Token Usage Discussion
• The team discusses Claude Fable being taken offline by the government due to national security concerns, with no real evidence provided. They expect it will return eventually but note this raises broader questions about AI access control.
• A token saver tool was tested but failed to deliver savings. The team suspects one member (Isaias) may have an unknown process consuming his tokens, as others on similar plans have no issues.
• The group debates VS Code versus terminal for Claude Code, noting VS Code offers a friendlier GUI, easier folder switching, and useful extensions. A new VS Code Insiders extension mimicking Cursor’s interface is being tested.
[00:10:00] – New AutoHotkey Tools and ASM Workflow Tips
• A fun text font-changing tool (upside down, bold, etc.) was built during a livestream using AutoHotkey, along with a Windows quick-access launcher for system folders, microphone settings, and other hard-to-find features.
• Connie shares his experience using Claude Code to build a Telegram spam-blocking tool, where the code degraded over multiple iterations. ASM was able to refactor and validate the code more effectively.
• Irfan explains that Claude Code without MCP integration is “blind” to errors, and recommends using Claude Code for planning then passing a prompt to ASM for actual script building.
• The team used the Ask Gurus tool to brainstorm new automation approaches beyond their existing 18 methods, generating a tiered list rated by ease of implementation and prevalence across programs.
• Notable discoveries include CDP for Electron/WebView2 apps, SetWinEventHook, shell verbs (already used for Dropbox context menus), and Appium for mobile automation.
• The group reflects on how AI has fundamentally changed their approach to projects, making previously too-difficult or time-consuming ideas now feasible.
[00:29:47] – Quick Raw Edit Tool Updates and XP File Search Architecture
• New features added to the Quick Raw Edit tool in about 20-30 minutes: spectrogram view for noise detection, a “remove selection” checkbox that cuts and merges segments, with output saved as indexed trim/cut files.
• The team investigated replacing the XP File Search executable with DLL calls but AI advised against it, noting the executable provides multi-threading and robustness that AutoHotkey alone cannot match.
• They traced the XP Search tool’s communication method, confirming it uses CLI arguments for input and STD out for results, with AutoHotkey handling the output neatly.
[00:39:45] – ASM Skills Management and Code Obfuscation
• ASM skills can be added by dropping MD files into the AI/skills folder or asking ASM to build skills automatically. Custom skills survive updates since the team writes individual files rather than deleting folders.
• A Python-based code obfuscator was created to protect AutoHotkey scripts, renaming variables to confusing combinations of O/0/1/I/L characters and injecting random unused code.
• The idea of prompt injection within obfuscated code was raised as a deterrent against AI-assisted reverse engineering. The team also discussed AutoHotkey’s advantage as an obscure language with tiny executables that leverage Windows APIs directly.
[00:59:32] – Wrap-Up
• The team says goodbye and looks forward to reconnecting next week.
*Brief Summary*
The session highlighted how AI tools like Claude Code, ASM, and the Ask Gurus approach are reshaping the team’s AutoHotkey development workflow, from discovering new automation methods to rapidly building and refining tools. Key takeaways include the importance of choosing the right AI tool for each task, the value of multi-AI consultation, and rethinking previously dismissed project ideas now that AI dramatically reduces development effort.
AHK Hero 2026 06 12 Friday Hour 2
*Summary*
This team call covers a range of automation tool updates and AI coding insights. Topics include optimizing file search speed using DLL-based XP Search, new features in the Automator Spy tool, a deep dive into problems with AI-generated code complexity, a live demo of a real-time AI-powered concept-matching system, and updates to the Notify class and Quick Raw Edit video tool.
*Key Points*
[00:00:00] – XP Search Tool and File Search Optimization
• The team discusses how the XP Search tool uses DLL files for lightning-fast file searching, compared to the slower AutoHotkey file loop method.
• Irfan explains how he pointed AI to the XP Search source, and AI inspected both tools, identified the bottleneck, copied the needed DLL libraries, and rewrote the recently modified files tool in about 10-15 minutes.
• A preferences feature was added so users can set their own default search path instead of a hardcoded drive letter.
[00:09:02] – Automator Spy Updates and DLL Inspection Features
• The Automator Spy now includes a dark theme, a confidence bar using UTF-8 characters (AI-generated idea), and a detection report showing ranked automation strategies.
• A new DLL inspection feature shows which DLLs are loaded by a target process, helping identify control types and automation approaches.
• The team discusses adding AI-generated multi-line descriptions for each DLL, possibly cached as local files with clickable hyperlinks, and considers porting the old Window Forms library using AI.
[00:17:59] – AI-Generated Code Complexity and Dependency Injection
• Isaias demonstrates a vibe-coded tool where AI introduced dependency injection, fat arrow functions, and helper wrapper functions for a simple 500-700 line project, making the code unnecessarily complex.
• The code becomes very hard to read and debug, creating full dependency on AI for future fixes, especially for those without deep coding experience.
• AI tends to solve advanced architectural problems (like decoupling functions) that are appropriate for large-scale projects but overkill for small personal tools.
[00:27:01] – Managing AI Coding Behavior and Project Maturity
• The discussion highlights that AI sometimes over-engineers code by applying enterprise patterns to simple projects, unlike a human mentor who would assess project scope first.
• Irfan suggests creating AI behavior modes or profiles (e.g., expert mode vs. beginner mode) with specific rule sets to control how AI approaches coding tasks.
• The team agrees that project maturity (500 lines vs. 10,000 vs. 1 million) should drive architectural decisions, and AI needs guidance to match its approach to project scale.
[00:35:56] – Real-Time AI Concept Matching and Notify Class Updates
• Joe demos a system that uses Assembly AI for live transcription, embeds speech into a SQLite database using semantic embeddings, and matches spoken concepts against website data pulled from a custom WordPress API plugin, all built in about two days.
• Matches above a threshold auto-publish to an OBS banner (and eventually Telegram), while lower matches are shown for manual approval.
• The Notify class now supports customizable buttons with callbacks, progress bars, tooltip positioning near the mouse, and color themes.
[00:44:56] – Video Scene Detection Ideas and Quick Raw Edit Updates
• The team brainstorms extending their video clipping tool beyond transcription-based segmentation to scene-type detection (action, sad, boring) using video keyframes, audio analysis, sentiment data, and decibel levels.
• Quick Raw Edit received updates including millisecond-precision navigation (100ms nudges using FFmpeg without needing FF Probe), improved scrubbing, and split start/end markers.
• Ideas for a “remove section” feature and audio waveform display are discussed, though the team acknowledges the risk of scope creep turning a quick tool into a full editor.
*Brief Summary*
The call showcased practical AI-assisted development wins like rapid tool optimization and plugin creation, while also raising important cautions about AI over-engineering simple projects. Key takeaways include the need for AI behavior profiles matched to project complexity, the power of semantic embeddings for real-time concept matching, and ongoing improvements to the team’s video editing and notification tools.
AHK Hero 2026 06 12 Friday Hour 1
*Summary*
This Friday developer discussion covers AI model strategies, focusing on using premium models like Fable 5 for planning and debugging while switching to cheaper models for implementation. The group explores AI pricing changes, hallucination risks, context window management, and a novel concept of using AI to document its own decision-making logic so it can eventually write itself out of the workflow.
*Key Points*
[00:00:00] – Fable 5 Capabilities and Smart Model Switching
• The group discusses Fable 5’s impressive problem-solving abilities, noting it consistently outperforms other models in debugging and planning tasks.
• A key strategy emerges: use expensive flagship models for planning and insight (costing around 22 cents via Open Router), then switch to cheaper models like Opus or Sonnet for implementation work.
• Isaias describes a similar workflow in VS Code, using top-tier models to generate detailed architecture plans, then switching to lesser models for coding, comparing it to how humans think hard initially then shift to autopilot.
[00:09:41] – AI Tools Comparison and the AskGuru Multi-Model Approach
• Joe explains his custom AskGuru skill that sends prompts to multiple flagship models via Open Router, then has Claude synthesize the best ideas from all responses.
• The tool supports brainstorming and a “grill me” mode where models challenge your plan from different angles.
• The Handoff skill for context window management is discussed, where session state is saved to markdown files as restore points after each feature completion.
• Gemini is highlighted as better suited for search and educational tasks rather than coding.
[00:19:18] – Fable 5 Billing, Token Economics, and Pricing Shifts
• The group discusses upcoming billing changes for Fable 5 on Anthropic, with separate charges expected around the 22nd due to compute constraints.
• Using Fable 5 through Open Router avoids subscription token usage and provides cost visibility.
• Fable 5 solved a two-week-old icon bug on the first attempt that no other model or council approach could fix.
• A real-world example is shared where Fable 5 found bugs and security issues in code originally written by an earlier model.
[00:28:57] – AI Hallucination Risks and the Trust Problem
• The Curl library example illustrates AI’s false positive problem: Mythos found 5 issues but only 1 was a real (minor) bug, leading to wasted effort on non-issues.
• The group emphasizes that the less you know about a topic, the more dangerous AI becomes because hallucinations look convincing.
• A practical exercise is suggested: spend an hour testing AI on your area of expertise to gauge its actual error rate, then extrapolate that to unfamiliar domains.
• Assigning council members different expert perspectives (security, UI, etc.) helps catch blind spots.
[00:38:36] – AI Pricing Structures and Industry Economics
• Isaias shares his experience with Copilot’s pricing shift from 3,000 premium calls to a credit-based system, burning through 20,000 credits in days at the $100 tier.
• The group debates whether AI companies have incentives to inflate token usage, noting the tension between keeping users engaged and covering compute costs.
• Discussion touches on SpaceX’s IPO, space-based data centers for cooling, and ocean-based computing as potential game-changers for AI infrastructure costs.
[00:48:12] – AI’s Impact on Work and the Industrial Revolution Parallel
• Token costs may actually slow AI’s displacement of human workers, since intelligence (human or artificial) costs money.
• AI won’t fully replace humans but complements human creativity; the group sees this as another industrial revolution.
• Joe describes how AI tools still need human oversight, creating new roles rather than eliminating jobs entirely, even in developing countries.
[00:57:52] – Using AI to Remove AI: Deterministic Program Generation
• Joe proposes having AI log its decision-making process, then using those logs to generate deterministic programs that replicate AI decisions without ongoing AI costs.
• Isaias frames this as converting generative AI output into deterministic scripts where the same input always produces the same output.
• The 80/20 rule applies: deterministic code could handle 80% of cases, with AI reserved for edge cases.
• The group concludes that AI works best as a tool for planning and problem-solving rather than a wholesale replacement, emphasizing step-by-step guided development over vague prompts.
*Brief Summary*
AHK Hero 2026 06 06 Saturday Hour 1
*Summary*
This group meeting covers voice-to-text productivity tools (especially Handy), AI-assisted task management, transcription workflows, a live demo of the Cursor IDE, context window management in Claude Code, and a discussion about whether the term “agentic OS” is appropriate for current AI tooling setups.
*Key Points*
[00:00:00] – Reminders, Checklists, and Voice-Driven Task Capture
• The group discusses combining reminder and checklist tools, weighing simplicity against feature overlap
• Joe describes a client project where a hotkey captures voice ideas and AI organizes them into existing task categories, reducing context switching
• Ryan previews the upcoming Handy release: hotkey to write voice notes directly to a timestamped text file, with potential API integration to push tasks into to-do apps
• Joe shares his experiment asking Claude Code to respond in his personal writing style using a custom skill
[00:08:53] – Voice-to-Text Adoption and Transcription Tools
• Both Joe and Ryan emphasize that voice input is a game changer, even faster than hotstrings for experienced typists
• Discussion of using Nvidia’s open-source Parakeet model for local transcription to save tokens versus cloud services like Assembly AI or Whisper
• Ryan’s video tool uses Handy/Parakeet locally to transcribe recordings; long content should be chunked into segments with timestamp adjustments
• The upcoming Handy release adds spoken punctuation replacements, shift-key capitalization, and continuous listen-and-release mode
[00:17:45] – Handy Troubleshooting and Feature Requests
• Ray reports Handy sometimes stops pasting despite recording correctly; restarting fixes it
• Joe suggests storing the active window on hotkey press so transcribed text returns to the correct destination
• Proposed features include an auto-flush timer (every 15 seconds) for streaming-style output and clipboard conflict resolution
• Clipboard manager conflicts (e.g., Clipboard Fusion) are identified as a likely cause of paste failures
[00:26:37] – Scope Creep, Simplicity, and Building for Others
• The group acknowledges AI makes scope creep worse since everything feels possible and AI-generated to-do lists are overly comprehensive
• Ray created a skill to warn him about expanding scope, but admits he overrides it
• Joe stresses keeping tools dirt simple for broad adoption, citing users who abandon complex tools like QAP
• Ryan shares his three-question trap: Is it cool? Is it possible? Does it add value? All answers are biased yes when it is your own idea
[00:35:24] – Cursor IDE Live Demo
• Ryan walks through Cursor’s code-free interface: project workspaces, agent task history, model switching between Composer (token-efficient) and Sonnet
• Key features shown: plan vs. agent mode for separating planning from execution, built-in skills, and an embedded Chromium browser with GUI object picker
• Real-world example: building a Chrome extension for a TikTok live dashboard by pointing at UI elements and prompting directly
• Cursor integrates with git, Railway, and cloud hosting; debugging happens inside the embedded browser with automatic dev tools access
[00:44:14] – Context Window Management and Token Tracking
• Ray demonstrates the /context command in Claude Code showing token usage breakdown: system prompt, skills, memory files, MCPs, and messages
• He refreshes his context window at around 100,000 tokens to keep responses sharp
• Ryan does not have this feature in Cursor but plans to implement it; JCode Munch saved him 2.2 million tokens
• Discussion clarifies that /context may be a Claude Code built-in command rather than a user-created skill
[00:53:02] – Clarifying Tools, Terminology, and the “Agentic OS” Debate
• The group untangles the relationship between Claude Code (terminal), VS Code extension, Cursor, and Cowork as different interfaces to the same LLMs
• Ryan explains: think of the tool (VS Code, Cursor, browser) separately from the LLM language it connects to
• The group rejects the popular term “agentic OS,” preferring “collection of tools” or “environment” since it runs on top of an existing OS
• Ray suggests a recurring meeting segment to define shared vocabulary: dashboard, skill, command, workflow, etc.
*Brief Summary*
The session highlighted practical advances in voice-driven productivity through Handy’s upcoming features, explored how different IDEs like Cursor and VS Code serve as flexible interfaces to various LLMs, and reinforced the importance of simplicity and clear terminology as AI tooling rapidly evolves. The group agreed to share the new Handy release via Telegram and continue refining their shared workflows.
This developer team meeting covers practical AI-assisted coding strategies, tool demos, and workflow optimizations. The group discusses how AI works best as a targeted helper rather than a full project builder, demonstrates tools like Ask Guru, Script Maker, an AI icon creator, and a handoff skill for managing token context windows in Claude Code.
Learn more about AI and Automation at: https://the-Automator.com
Or consider joining our amazing Hero club here: https://the-Automator.com/Hero
*Key Points*
[00:00:00] – AI as a Targeted Helper vs Full Project Builder
• Isaias shares that writing code himself and delegating specific functions (PDF image extraction, QR barcode scanning) to AI was significantly faster than asking AI to build an entire project end-to-end.
• His invoice extractor project, fully AI-driven, took days and caused constant friction, proving the “helper” approach is more efficient.
• Joe demonstrates a real-world example: a Chamber of Commerce sent him a JPEG donor form. ChatGPT failed to convert it, but Claude Code in VS Code created a clean fillable PDF easily.
[00:08:50] – Lead Gen Tool and Ask Guru Demo
• Joe built a free lead generation QR code system using Cloudflare Workers for local businesses, requiring only a $15/year domain purchase.
• The “Ask Guru” skill was demoed, which sends prompts to multiple AI models via OpenRouter, then Claude synthesizes all responses, highlighting agreements and unique insights from each model.
• This is especially useful for debugging when a single AI gets stuck, as consulting multiple models often reveals the correct solution.
[00:17:35] – Debug Agent, Reminders, and Fast File Search
• Isaias built a debug agent that formulates hypotheses about bugs, inserts targeted debug logs into code, runs the script, reads the logs, and confirms or rejects each hypothesis automatically.
• Joe showed a reminder tool rebuilt with a free email API service (30-day limit) and discussed leveraging built-in Windows tools like Task Scheduler instead of building custom solutions.
• The file search tool was upgraded from slow AutoHotkey loops to a fast C-sharp compiled engine (XP Search), dramatically improving speed to 500 files per second.
[00:26:25] – Script Maker Updates and Auto-Debugging Discussion
• Script Maker now uses CLI tools with a Diff viewer, and has all team skills and libraries nested in so generated code automatically borrows existing components.
• The team debated automatic vs manual debugging. The goal is for AI to kick off scripts, detect errors, and fix them without user intervention, similar to VS Code’s workflow.
• File organization issues were identified: each project needs its own subfolder to prevent settings file conflicts and tool lookup errors.
[00:35:19] – Tool Maintenance and Converting Projects to Skills
• Connie found several tool bugs during testing and will compile a list for fixes. The team discussed creating a skill to auto-update bundled tools.
• Joe demonstrated converting ChatGPT browser projects into Claude Code skills, including a newsletter proofreading workflow and a writing style skill that analyzed his past newsletters like a personality profile.
[00:43:57] – AI Icon Creator and Manual Icon Maker
• The AI-powered icon creator generates icons from text descriptions or script context, creates one large image then downscales locally via GDI for multiple sizes.
• The manual icon maker allows choosing letters, emojis, colors, and batch-generating hundreds of branded icons as a zip file.
• The team discussed how ICO files store multiple sizes as indexed binary data within a single container file.
[00:52:45] – Handoff Skill and Token Rot Management
• Joe explained the “handoff” skill that creates markdown summaries of project goals, progress, and solved bugs, allowing you to start a fresh Claude session without losing context.
• This combats “token rot” where AI quality degrades past halfway through the context window, keeping sessions fresh and creating restore points.
• Dave shared his dashboard approach that auto-archives inactive projects and lets him resume any project by number, while the team discussed whether the ASM debug feature is necessary when AI can handle debugging directly.
[01:01:31] – Wrap-Up
• Connie will send a bug list for the tools, and the team agreed to continue refining ASM’s automatic debugging capabilities.
*Brief Summary*
The meeting reinforced that AI is most effective when used as a targeted assistant for specific coding tasks rather than as a full project builder. The team showcased several productivity tools including multi-model brainstorming, automated debugging, icon generation, and context handoff skills that combat token degradation. Next steps include fixing identified tool bugs, improving automatic debugging in ASM, and better project file organization.
A group of AI-assisted coding enthusiasts discuss their AutoHotkey tool-building projects, debate whether being a programmer helps or hurts when working with AI, and explore practical challenges around AI model selection, token costs, instruction reliability, and skill management in VS Code and Claude coding environments.
Learn more about AI and Automation at: https://the-Automator.com
Or consider joining our amazing Hero club here: https://the-Automator.com/Hero
Key Points
[00:00:00] – Tool Demos and Taskbar Projects
• Ray showcases a right-hand sidebar tool with hover previews, window management features, and roughly 2-3 thousand lines of AI-generated code, marveling at how easy AI makes development.
• Joe demonstrates his taskbar with clipboard memory, pinning, and always-on-top features built in AutoHotkey, emphasizing simplicity for average users versus Ray’s feature-rich personal approach.
• The group discusses AI workflows that can multi-thread tasks but warns they burn through tokens quickly.
[00:09:46] – Programmers vs Non-Programmers Using AI
• Isaias argues that experienced programmers actually have a harder time with AI because they spot hidden code problems that non-coders would never notice, leading to frustrating fix-and-break cycles.
• He demonstrates a real project: an AI-built tool that extracts receipt images from PDFs and converts them to Excel for his accountant, replacing tedious manual data entry.
• A recurring issue is AI defaulting to double backslashes in file paths for AutoHotkey, despite explicit instructions across multiple instruction files to use single backslashes.
• Irfan suggests telling AI goals rather than specific code changes, noting AI handles goal-oriented prompts far better than surgical edit commands.
[00:19:23] – Model Selection and Pricing Challenges
• Isaias explains that the backslash problem worsens when using VS Code’s auto model selector, which often picks smaller models like Sonnet or Mini that ignore instructions more frequently.
• VS Code Copilot switched to a credit-based pricing model in June, and Isaias burned through 84% of his credits in just a few days on the $100/month max plan.
• Joe notes that multi-agent workflows silently launched by skills can consume massive tokens without the user realizing it, and suggests using built-in tools to audit token usage.
[00:29:03] – Getting in the Weeds: Craftsman vs Pragmatist
• Isaias walks through a detailed code review showing AI labeled a function “async” when it was actually batched, and a second attempt where a synchronous API call broke true async behavior.
• Joe argues that if the tool works, diving into code-level optimization is unnecessary for personal use, comparing it to sharpening an axe to scalpel precision when a butter knife suffices.
• Isaias counters that if the tool were sold to accountants processing thousands of invoices, the optimization would matter, revealing the developer mindset of building for scale.
• The group agrees that domain expertise in any field causes people to nitpick AI output, and being a programmer specifically makes it hard to stop “needling” the code.
[00:48:24] – Instruction Reliability and Skill Management
• Irfan shares his approach of using conditional rules rather than many blanket instructions, noting that conflicting rules confuse AI.
• Isaias clarifies that skills in VS Code load conditionally by context, not all at once, so rule conflicts should be minimal, yet AI still finds ways to ignore them.
• Ray introduces a six-dimension framework for instruction reliability: position in context, specificity, trigger clarity, conflict with model defaults, mechanical enforcement via hooks, and verifiability.
• Joe emphasizes that well-described skills should trigger automatically without slash commands, and advises letting AI create skills rather than building them manually.
[00:58:03] – Session Wrap-Up
• Joe calls for a break at the hour mark, noting he had additional material to show but the discussion ran long.
*Brief Summary*
The session highlighted a central tension in AI-assisted development: programmers who understand code deeply often spend more time fighting AI’s imperfect output, while non-programmers who focus on goals get results faster with less frustration. The group shared practical strategies including using top-tier models, keeping instruction sets short and conditional, leveraging deterministic hooks for mechanical enforcement, and auditing token usage to manage rising costs under new credit-based pricing models.
This is a weekly group development call where the team discusses progress on their ASM tool, AI-powered coding skills, new hardware gadgets, and broader observations about AI adoption. Topics range from technical updates on CLI architecture and icon-generation tools to corporate IT workarounds, email automation challenges, and the importance of good AI prompting.
*Key Points*
[00:00:00] – Team Check-In and ASM Development Progress
• The group catches up on absent member Isaias and discusses reallocating a Zoom account
• Irfan reports ASM progress: fixing bugs, implementing commands, and integrating AI chat that can create tabs, save files, and modify code
• The Diff Viewer and MCP are both CLIs, allowing AI to pass command-line parameters to interact with tools
• Discussion about where to store shared libraries and skills within the ASM framework, with plans to keep them locally available
• The team debates using ASM vs VS Code for larger projects, noting ASM is more of a “toolbox” while VS Code is a “workbench”
[00:09:57] – AI Skills, Icon Tool Demo, and Pricing Philosophy
• The pro subscription is around $12.99, which includes all libraries and skills – described as a bargain since individual libraries sell for similar prices
• Speaker A demos an icon-maker tool built autonomously by AI using the council skill, goal agent, and brainstorm workflow
• The tool generates batch icons and PNGs with customizable letters, colors, and sizes – producing hundreds of combinations automatically
• New skills introduced: “Handoff” for creating fresh context transfers between AI sessions, and “Brainstorm” for automated feature ideation via the council skill
• The handoff skill solves the problem of AI getting less effective past half the token window
[00:19:53] – Tool Design Philosophy and Corporate IT Workarounds
• Kenneth suggests a “pruning” skill to identify features to remove, countering bloatware tendencies – the group loves this idea
• Discussion about keeping tools simple with entry-level defaults and advanced options hidden behind tabs
• Kenneth cannot reinstall the Prompt Assistant due to corporate IT restrictions, prompting discussion about publishing to the Microsoft Store
• AutoHotkey V2 is available in the Windows Store, providing a workaround for users who cannot install executables in corporate environments
[00:29:47] – NFC Tags, Thermal Printer, and Hardware Gadgets
• Speaker A demonstrates NFC-powered e-ink display tags (around $20) that update via phone app with no battery required
• A small thermal sticker printer (also around $20) is shown for creating legible labels, replacing handwritten notes
• The group debates the technical nuances of how NFC powers passive devices using electromagnetic induction
• Plans to use the color version of e-ink tags as dynamic name badges for meetings
[00:39:42] – AI Adoption in Rural Communities and Comparing Dev Tools
• Speaker A attended a Chamber of Commerce meeting in rural Texas where attendees were surprisingly knowledgeable about AI tools
• Upcoming presentations planned for a local library and Chamber of Commerce on AI for small business
• Ray shares his approach of using Codex, Cowork, VS Code, and other tools simultaneously to deepen understanding through comparison
• Discussion about whether Cursor’s built-in AI models offer advantages over Claude Code, with interest in a future demo
[00:49:40] – AutoHotkey Future, Email Passkeys, and AI Prompting Tips
• The AutoHotkey developer (Lexikos) is unlikely to add AI features, maintaining a minimalist approach to the language
• AI coding is identified as one of AI’s strongest capabilities due to the deterministic nature of programming
• Gmail’s shift from passwords to passkeys creates challenges for AutoHotkey email automation via CDO
• The call closes with discussion about AI prompting quality – generic questions yield generic answers, while domain expertise leads to better interactions with AI
[00:59:31] – Sign Off
• The group wraps up and says goodbye until next week
*Brief Summary*
The call covered significant ASM development progress with AI-powered file management and CLI architecture, alongside practical demos of AI-built tools and affordable hardware gadgets. The overarching theme was leveraging AI skills and automation to simplify workflows while keeping tools accessible and affordable, with the team emphasizing that good prompting and clear instructions are key to getting the most from AI.
AHK Hero 2026 05 29 Friday Hour 2
*Summary*
This Hero Club session covers a wide range of AI-powered productivity tools and workflow automations. Joe shares updates on session handoff skills, thumbnail generation workarounds, and noise removal tools, while Ryan demos a custom video recorder and the group discusses FollowUpThen for frictionless reminders. The conversation also touches on Handy dictation improvements, prompt engineering with square brackets, and the slash goal command in Claude Code.
Learn more about AI and Automation at: https://the-Automator.com
Or consider joining our amazing Hero club here: https://the-Automator.com/Hero
*Key Points*
[00:00:00] – AI Workflow Skills and Tool Automations
• Joe explains his approach to large projects: planning with Council (multiple AI models), implementing in stages, then writing markdown handoff files so new sessions pick up seamlessly.
• He built a custom skill that auto-generates these handoff docs, tracking bugs fixed and progress made, keeping Claude’s context window under half capacity.
• He added auto-restore-point creation and a Dropbox hyperlink fetcher to the Effortless Video Reducer, eliminating manual steps after processing client call recordings.
[00:08:47] – Thumbnail Generation and Photo Rotation
• Joe found a workaround for AI thumbnail generation: using transparent background photos of himself overlaid onto AI-generated thumbnails, since most AI tools block inserting real faces directly.
• He now rotates through five or six photos in a folder, tracking the last one used so thumbnails show variety rather than the same image every time.
• The tool generates three thumbnail options per video, and upcoming improvements will make this even more useful for YouTubers.
[00:17:34] – FollowUpThen Reminder Tool and Handy Dictation
• Ryan demos FollowUpThen (followupthen.com / fut.io), a frictionless email-based reminder service where you simply email a time-based address and it sends the content back at the specified time.
• The group discusses replicating this concept via Telegram bots, webhooks, or AutoHotkey scripts to reduce context switching.
• Discussion shifts to Handy’s dictation mode and how punctuation handling differs from Windows dictation. Ryan begins live-coding improvements to support spoken punctuation commands and keyboard injection.
[00:26:29] – Video Recorder Tool and Noise Removal Demo
• Ryan showcases his vibe-coded video recorder, a custom Loom alternative featuring webcam overlay, key press display, auto-subtitles via Parakeet transcription, and branded intro/outro slides.
• Joe demos his noise removal tool comparing FFmpeg (free) versus ElevenLabs cleanup on old Dan Kennedy audio, with a built-in AB tester that streams both versions simultaneously for instant comparison.
• The tool also handles video files by automatically stripping audio, cleaning it, and stitching it back together.
[00:35:06] – Tool Design Philosophy and Open Source Customization
• Joe emphasizes the balance between adding features and keeping tools simple, noting Handy’s hidden advanced tab (Control+Shift+D for debug mode) as an interesting design choice.
• The group discusses modifying open-source tools with AI assistance, with Ryan redesigning Handy’s source code and Joe exploring custom AutoHotkey compiled versions with embedded libraries.
• Discussion of UIA MCP for voice-driven computer automation and a throwback to a 17-year-old voiceless phone call demo.
[00:43:59] – Prompt Engineering with Square Brackets and Tone Tags
• Ray shares his technique of using square bracket tags like task, context, and output in prompts, combined with tone tags (Socratic, Hemingway, Churchill) and audience tags (skeptic, beginner).
• He finds this dual benefit: it instructs the LLM more precisely while also structuring his own thinking process.
• Joe suggests using color-coded editors instead of plain Notepad to make bracket tags visually distinct, reducing cognitive load.
[00:52:44] – Claude Code Slash Goal, Transcription Options, and Wrap-Up
• Joe discusses the slash goal command in Claude Code, which lets AI autonomously work toward a defined goal without waiting for user input, though he admits he does not fully trust it yet.
• The group explores using Parakeet as a free local transcription alternative to AssemblyAI, noting the importance of word-level timestamps for editing tools.
• Joe mentions ongoing work on Taskbar and Transcriber updates, and the session wraps with plans to continue tomorrow.
*Brief Summary*
AHK Hero 2026 05 29 Friday Hour 1
*Summary*
This AutoHotkey community call covers enhancements to the Handy voice recognition tool, including hands-free Telegram messaging via the Telethon library, a custom right-side taskbar built entirely in AutoHotkey, window visibility cloaking for screen sharing, and a demo of the ASM tool that integrates AI-powered script generation with custom skills and libraries.
Key Points
[00:00:00] – Handy Voice Tool Enhancements and Telegram Integration
• Ryan demonstrates upgrades to Handy, an open-source voice recognition tool, adding support for multiple hotkeys that route transcribed speech to different actions.
• A “Silent Writer” feature lets users speak notes hands-free while working, saving timestamped transcriptions to a text file without switching windows.
• Using the Python library Telethon, Ryan built a system that sends voice-to-text messages directly to a Telegram contact programmatically, no window switching required.
• A listener script can also read incoming Telegram messages aloud, creating a fully hands-free two-way communication channel.
[00:09:33] – Voice Automation Potential and Custom Taskbar Demo
• The group discusses advanced use cases like Do Not Disturb filtering, priority message routing, and using voice commands similar to Alexa or Google Assistant.
• Joe demonstrates a custom right-side taskbar built entirely in AutoHotkey after AI refused to rewrite Explorer Patch but agreed to build a similar taskbar from scratch.
• The taskbar includes clipboard history, always-on-top pinning, multi-monitor support, customizable fonts and colors, and import/export of layouts.
• The Windows 11 system tray limitation is noted as deeply baked into Explorer, requiring a workaround using auto-hide.
[00:19:02] – Window Visibility Cloaking and Screen Sharing Tricks
• Joe shows how his webcam reminder GUI can be hidden from screen capture and Zoom while remaining visible locally, using a cloaking technique.
• This approach only works for windows you own (created in your own program), not arbitrary third-party windows.
• Kenneth demonstrates toggling a yellow mouse halo visible to himself but hidden from viewers during screen sharing.
• The group explores ideas like private on-screen notes during presentations and hiding personal content during Zoom calls.
[00:28:29] – Handy Punctuation, Custom Words, and Uppercase Challenges
• Ray raises the issue of dictating punctuation like colons, which Handy’s custom words feature handles poorly.
• Kenneth suggests a phonetic replacement approach for non-English names like Irfan, since spelling and pronunciation differ significantly.
• Ryan proposes building a phonetic replacement tool directly into Handy and using unique trigger words for punctuation substitution.
• The group discusses uppercase output options including a library of always-capitalized words and potentially using Shift or Caps Lock as modifier keys during dictation.
[00:37:59] – AutoHotkey Resource Finder and Date Filtering
• The team confirms that the AutoHotkey Resource Finder JSON data includes created and updated dates for downloads, enabling chronological sorting.
• Irfan shows the tool can filter scripts by v1 or v2 and sort by date, addressing requests for easier discovery of new scripts.
• Joe explains that database table joins for Easy Digital Downloads made pulling dates complex manually, but AI now makes this trivial.
[00:47:26] – ASM Tool Demo with AI-Powered Script Generation
• Joe and Irfan demonstrate ASM, a tool that recreates Claude Code-like functionality with all their custom skills, agents, and 67+ AutoHotkey libraries included.
• ASM uses CLI access through Open Router rather than MCP to conserve token usage, supporting hundreds of AI models.
• The AI automatically selects appropriate skills, generates scripts, builds GUIs, fixes overlapping controls, and can create documentation.
• A built-in Diff viewer made with Scintilla control shows code changes, and the team discusses adding a “caveman mode” that auto-implements changes without review.
• Steve shares how Claude separated 30 icons from a single graphic file with just two instructions, highlighting AI’s growing capabilities.
*Brief Summary*
The session showcased significant progress in voice-driven automation through Handy and Telethon integration, creative AutoHotkey solutions like a custom taskbar and window cloaking, and the powerful ASM tool that packages AI script generation with a full library of skills. The team continues refining these tools for broader community use, with plans to address punctuation handling, phonetic replacements, and packaging options.
AHK Hero 2026 05 23 Saturday Hour 1
Summary This group session covers a wide range of automation and AI tool topics, including noise removal with FFMPEG, browser bookmarklet workarounds for corporate environments, a smart time-tracking tool with visual project cues, AI coding strategies, and a live demo of a voice-triggered AutoHotkey integration using the open-source Handy transcription app.
Key Points [00:00:00] – Opening Chat, FFMPEG Noise Removal Tool and Bookmarklet Workarounds • The group opens with casual chat, including Kenneth mowing the lawn while on the call with no audio bleed thanks to noise-canceling headsets. • Joe shares a tool he is building using FFMPEG to remove background hum from old video recordings, with plans to add 11 Labs API for AI-powered noise removal. • Gus presents a clever workaround for corporate users who cannot install software: browser bookmarklets that access the clipboard and transform prompts, paired with a single HTML editor page so non-technical users can easily customize behavior. • Discussion expands to other built-in scripting options on Windows such as BAT files and VBS, noting that AI removes the barrier of needing to learn new languages.
[00:08:51] – Built-In Scripting Languages and Time Tracking Tool Demo • The group discusses using Windows-native scripting tools already present on machines, reducing the need for executable installs. • Irfan demos a time-tracking tool built for a client. Projects are displayed in a color-coded list view using DLL calls for custom borders, and the tool auto-detects the active window to assign and calculate time per project. • Additional features include Pomodoro-style focus enforcement, project suspension prompts, and break timers. • Joe suggests adding different music per project and a tooltip near the mouse cursor to subtly remind the user which project they are currently tracking.
[00:17:40] – Mouse Pointer Status Indicators and Screen Share Detection • Building on the tooltip idea, the group proposes changing the actual mouse pointer cursor file to reflect billing or tracking status, a concept that extends to showing mic mute state or screen sharing status. • Kenneth highlights the idea of repurposing this approach to indicate screen sharing state across any app, not just Zoom. • Irfan demonstrates configurable mouse highlighter settings including transparency, offset, frequency, and duration, with plans to turn this into a reusable library. • A live demo of the FFMPEG hum-removal tool shows clear before and after audio results with minimal effort.
[00:26:27] – AI Model Behavior, Claude Workflow Strategy and ASM Tool Updates • The group compares AI model behavior, noting Copilot struggles with complex instructions while Claude is generally more reliable, though it can still have inconsistent sessions. • Joe shares a staged workflow strategy for large Claude projects: planning thoroughly, breaking work into sections, and having Claude proactively generate markdown handoff files to start fresh sessions cleanly, avoiding token limit issues. • A discussion on token usage variations between users on the same plan suggests Anthropic may be testing different usage tiers. • Irfan shows ASM tool progress including a working CLI that can query active tabs and open new ones, with a planned Diff Viewer that lets users review and accept AI-suggested code changes.
[00:35:14] – ASM Coding Mode, AI Hallucination Best Practices and Open Router Benefits • The ASM tool is being designed as a simplified Claude Code alternative where AI debugs autonomously without requiring user approval on every change. • Open Router is highlighted as a pay-as-you-go solution allowing model switching without losing skills, debugger functions, or workflow continuity. • A Nate video on AI hallucinations is referenced, emphasizing that the solution is not better prompts but better tool architecture with verification steps built in. • The group draws a parallel to mystery shopping and survey research as analogies for testing and building reliable AI systems.
[00:43:56] – Noise Cancellation APIs, Pay-as-You-Go Model and Handy Voice Tool Preview • Discussion covers Krisp AI as a strong noise removal API option alongside 11 Labs, with the idea of building a simple drag-and-drop tool for audio and video cleanup. • The pay-as-you-go model is praised over subscriptions, especially for seasonal or low-frequency users. • Ryan is mentioned as having modified the open-source Handy transcription app to support voice trigger words connected to AutoHotKey, previewing the upcoming demo.
[00:52:45] – Board Game Tracker Idea and Ryan Joins to Demo Voice-Triggered Handy
AHK Hero 2026 05 22 Friday Hour 2
Summary This is a developer group call covering several AutoHotkey and AI-assisted tool updates. The team demos a media segmentation tool with FCP XML export, an upgraded Notify class with interactive buttons, and various automation utilities built with AI assistance.
Key Points [00:00:00] – Segmenter Tool Demo and FCP XML Export • The Segmenter tool accepts audio or video files, auto-transcribes via AssemblyAI, and intelligently splits content into chapters. • A 7.5-hour audiobook was tested and the tool found chapter breaks automatically from the transcription. • AI suggested adding FCP XML and EDL export formats, allowing users to drag the exported timeline file directly into DaVinci Resolve. • Long multi-hour calls can be broken into bite-sized segments and shared individually, saving significant editing time. • A plan to switch from separate Claude and ChatGPT API keys to a single OpenRouter key was discussed for flexibility.
[00:10:01] – Notify Class with Interactive Buttons • The Notify class was upgraded to support multiple buttons with custom colors, such as red for delete and green for keep. • Each button can have a callback function, replacing traditional message boxes with a far more flexible system. • Buttons can be positioned in five screen locations or at custom X and Y coordinates. • The class can be called via CLI without being included in a script, similar to an MCP-style handoff approach. • Irfan demonstrated using the Notify class as a hook so AI can ping the user when it needs input, keeping AI tools busy.
[00:19:57] – DaVinci Resolve Integration and Task App Discussion • Importing FCP XML into DaVinci Resolve automatically laid out all segments with names, requiring only minor tweaks. • The group noted that users often do not know to ask for features that exist, highlighting the value of AI suggestions. • A member is building a custom GTD (Getting Things Done) app with unique features not found in existing tools, to be discussed on a future call. • Kenneth’s YouTube podcast on productivity and AutoHotkey was mentioned and recommended to the group.
[00:30:00] – ASM Skill System and AI Model Independence • A plan was outlined to build ASM as a server that matches user prompts to relevant skills, then feeds them to AI automatically. • With 50 to 60 skills and agents available, users would not need to know which skill to use – the system handles selection. • OpenRouter integration would allow any AI model to be used, including options for users who cannot access Claude due to workplace restrictions. • Rising AI tool prices from Copilot and Gemini were seen as a business opportunity for those offering deeper expertise. • The group agreed that effective AI use is becoming a niche skill, and most people still lack the foundational knowledge to use it well.
[00:39:50] – Notepad Active Tab Path Script and Screenshot Skill • A script was built to read Notepad’s package state folder and extract the active tab file path using binary reading. • This approach is Notepad-specific but may have parallels in other apps like Paint or Teams. • A screenshot skill was created to auto-capture the main GUI of a tool for use in documentation, blog posts, and NotebookLM videos. • The screenshot script worked but needed refinement, such as capturing the tool in an active state and sizing for YouTube thumbnails.
[00:49:56] – Icon Tools, Magnifier Update, and Resource Finder • A CLI-based icon converter was proposed so users can right-click any image and send it directly to create an ICO file without launching a separate tool. • Oversized icons were traced to high DPI source files being stored at 1024×1024 resolution despite displaying at 16×16 or 32×32. • The magnifier tool was updated with a new icon created by ChatGPT and converted from PNG to ICO. • A suggestion was made to display icons on both light and dark backgrounds in the resource finder to catch transparency issues early. • The session wrapped with a bug fix for a member’s Simple Checklist tool and plans to continue development in the next call.
*Brief Summary* This session highlighted powerful automation wins, including AI-driven media segmentation with DaVinci Resolve export, a flexible Notify button class, and a growing skill-based ASM server system. The group is steadily building toward model-independent, user-friendly tools that reduce manual steps and keep AI workflows running efficiently. Next steps include refining screenshot automation, finalizing OpenRouter integration, and continuing work on the GTD app and icon tooling.
AHK Hero 2026 05 22 Friday Hour 1
Summary This session is a Friday group call where AutoHotkey developers and educators discuss ongoing projects including a government consulting job, attempts to retrieve active file paths from Windows Notepad using various tools, building a CLI alternative to the MCP server for AI-assisted debugging, a new diff viewer tool, and an updated simple checklist app.
Key Points [00:00:00] – Introductions, Government Job Update, and Notepad Path Challenge • The host attended a Chamber of Commerce networking event and is planning monthly AI learning sessions for small businesses. • A government consulting role is progressing, focused on teaching API calls and object-oriented programming in AutoHotkey V1, though V2 approval is pending due to internal restructuring. • The group begins exploring whether AutoHotkey can retrieve the full active file path from the newer Windows 11 Notepad, noting the path does not appear in the title bar.
[00:08:50] – Investigating Notepad Path via Save Dialog and Task Manager • Irfan confirms the new Notepad is a Windows app with no programmatically accessible file path; the Save As dialog borrows the last-used path rather than the current file’s path. • The team tests using the shared shell Save As dialog as a workaround, flagging it as a clunky Option B. • Task Manager is opened to look for file path info tied to open Notepad processes, but nothing useful surfaces.
[00:17:27] – Process Monitor, UIA Inspection, and AI Consultation • The team tries Process Monitor and the UIA inspector to peek inside Notepad tabs for path data, but neither reveals the full path. • Claude AI is queried in parallel and attempts API calls, UI inspection, and handle enumeration approaches. • Claude, Gemini, and Grok all confirm no documented API exists; they suggest parsing local state binaries or using the Save As workaround already identified.
[00:26:08] – CLI vs MCP Token Usage Discussion • Irfan introduces a new AutoHotkey CLI tool built as an alternative to the MCP server, which consumes roughly 15,000 tokens at the start of every chat session. • The CLI only uses tokens on demand as commands are sent, making it far more token-efficient for workflows that do not constantly need all 30 MCP tools. • The CLI handles debugging sessions in a separate executable so a stuck debug process does not block the main CLI, solving a key technical issue.
[00:34:51] – CLI Auto-Debugging Demo • Irfan demonstrates the CLI catching a syntax error (an extra space in an include statement), reporting the exit code, and automatically fixing the script. • The AI uses the CLI to write, run, and debug scripts iteratively, returning structured results like window handles, GUI sizes, and control names. • The long-term goal is to bundle this CLI inside AHK Script Maker so non-developer AutoHotkey users can simply describe what they want and have AI build and debug it for them.
[00:43:41] – New Diff Viewer Tool Demo • A newly AI-built diff viewer tool is shown, comparing two files side by side with aligned line numbers, plus and minus indicators, and the ability to move changes between files. • Features include dark and light themes, font size control, ignore-case and ignore-whitespace options, search, F8 and Shift-F8 hotkeys to jump between differences, and folder-level comparison. • The plan is to integrate this viewer into AHK Script Maker so users can review and selectively accept AI-made code changes, similar to the VS Code diff experience.
[00:52:17] – Simple Checklist App Overhaul and Closing Thoughts • The checklist app has been redesigned into a single unified window with project management controls at the top and item controls at the bottom to reduce confusion. • New features include run-on-startup, customizable hotkeys, font size and color settings, minute-interval reminders that only surface incomplete tasks, and a preview mode. • The host expresses amazement at the speed and quality of AI-assisted tool creation, crediting the skills and frameworks the team has built as a force multiplier.
*Brief Summary* This session highlights rapid progress across several AutoHotkey and AI-integration projects, from a token-efficient CLI debugger to a polished diff viewer and checklist app. The Notepad path investigation, while inconclusive through standard APIs, opened broader thinking about retrieving file paths from any running program. The team remains focused on packaging these tools inside AHK Script Maker to make AI-driven AutoHotkey development accessible to everyone.
AHK Hero 2026 05 16 Saturday Hour 1
*Summary* A Saturday developer group session covering AutoHotkey tooling demos, dark theme implementation, HAR file-based API automation, and a strategic discussion on migrating from MCP to CLI for token efficiency and better AI integration.
—
Learn more about AI and Automation at: https://the-Automator.com Or consider joining our amazing Hero club here: https://the-Automator.com/Hero
*Key Points* [00:00:00] – Text Toolbox Tool Demo • Stephen shares a hotkey-triggered Text Toolbox (rebuilt from a tool by the late Tidbit) with case conversion, find/replace with saved regex, history, and sticky config saved to INI files. • Input text is manipulated via selectable operations; a “Swap” button feeds output back to input for chained transformations. • Features include CSV viewing/editing, n-gram word frequency, list comparison, and padding tools. • UTF-8/encoding support questioned – tool appears ASCII-only; non-ASCII characters showed as mangled.
[00:09:10] – Encoding, RTF Considerations & Speed Reader Demo • Group flags encoding detection as unreliable; moving text through functions can corrupt non-ASCII characters. • Scintilla controls suggested as an alternative for richer text handling and UTF-8 highlighting. • RTF discussed but warned as overly complex; Stephen demos a speed-reading pacer tool using Just Me’s RTF library with smart syllable-based pacing.
[00:18:17] – Dark Theme Implementation & HAR File Introduction • A community-submitted code snippet using DLL calls and OnMessage applies Windows dark theme to menus and system tray; toggling light mode uses a script reload as a simple workaround. • Icon transparency issues arose – icons with transparent backgrounds disappeared on dark backgrounds; icons were updated to fix this. • Browser DevTools HAR capture (with sensitive data enabled) is introduced as a way to record web traffic for AI-assisted API reverse engineering.
[00:27:11] – HAR File Filtering Tool & AI API Class Generation • A work-in-progress tool filters HAR files by domain and traffic type (excluding CSS/JS), stripping credentials before sending to Claude Sonnet to generate an AutoHotkey API class. • Sending full HAR files is costly in tokens and confusing to AI; selective filtering improves focus and reduces noise. • Ryan Wells is building a complementary streaming approach where AI passively watches browser traffic and proactively suggests automations – described as a “hackathon” cross-pollination of ideas.
[00:36:11] – Social Media Automation & CLI vs. AutoHotkey Class • HAR-based automation discussed as a bypass for OAuth2 complexity in social media APIs (Facebook/Instagram have limited or gated APIs). • David confirms successfully automating video posting using browser session capture; scripts pause for manual re-authentication when sessions expire. • Debate on CLI vs. AutoHotkey class: CLI seen as a “black box” requiring memorized commands; AHK class preferred for direct inspection, flexibility, and familiarity – though AI will default to Python unless told otherwise.
[00:45:13] – Inspecting CLI Code & Excel CLI Walkthrough • Group opens the existing Excel AutoHotkey CLI in VS Code, confirming it is readable and inspectable – addressing the “black box” concern. • CLI structure reviewed: argument parsing dispatches to commands (open, close, save); output serialized as JSON to stdout. • stdout/stderr monitoring highlighted as the correct mechanism for detecting CLI success or failure.
[00:54:14] – MCP vs. CLI Migration Strategy & AI Instruction Compliance • AutoHotkey MCP has 30 tools consuming ~30,000 tokens on every invocation; only 12 are regularly used, 18 unused – majority of functionality can move to CLI. • Debugging (DBG protocol) requires session tracking, making it hard to migrate; solution is a separate dedicated executable for debug sessions. • AI ignored an explicit instruction to use `IniRead`/`IniWrite`, defaulting to `FileRead` and causing an encoding bug – team recommends marking critical instructions with brackets or bold markers.
—
*Brief Summary* The session highlighted practical AutoHotkey tooling advances – from text manipulation and dark theming to HAR-driven API automation – while converging on a key architectural decision: migrating most of the AutoHotkey MCP to a leaner CLI to drastically reduce token overhead. The group also surfaced an important AI reliability concern: even explicit coding instructions can be silently overridden, underscoring the need for strongly marked rules in AI prompts.
AHK Hero 2026 05 15 Friday Hour 2
*Summary* This session is a technical group discussion focused on AutoHotkey, AI tools (primarily Claude), and workflow automation strategies. The team covers practical topics including Windows “Send To” integrations, AI prompt engineering, Claude project organization, skill/MCP management, and broader thoughts on when to use AI versus writing dedicated programs.
—
Learn more about AI and Automation at: https://the-Automator.com Or consider joining our amazing Hero club here: https://the-Automator.com/Hero
*Key Points* [00:00:00] – Send To Integration & AI Role Prompting • The team demos a custom “Send To Manager” built in AutoHotkey, enabling right-click file sends to tools like a video reducer, transcriber, OCR, PDF converter, or even an email distribution list – eliminating the need to manually launch tools. • Tools in the Send To menu must be coded to accept passed parameters; the “passer/catcher” analogy was used to describe proper parameter handling. • A discussion arose about telling AI it’s an “expert” at a given topic (e.g., AutoHotkey GUI creation) within skill files to better focus its responses – consensus was it likely helps even if hard to measure empirically.
[00:09:24] – AB Testing AI Skills & Communicating Bug Fixes • The group debated whether adding “expert role” declarations to Claude skills is worth the extra tokens, leaning toward including it despite difficulty in formal testing. • Irfan shared an important best practice: when asking AI to fix a bug, always confirm what’s working before requesting a new change – otherwise AI may rewrite everything unnecessarily. • Claude’s new multi-agent dashboard (slash-agent command) was discussed as a useful way to manage multiple sessions, with a caution to keep concurrent sessions manageable (around 3-5).
[00:18:44] – Claude MD File Organization: Global vs. Local • The team explored structuring Claude’s configuration using global `.claude` MD files for broad AutoHotkey skills and local project-level MD files for focused work, analogous to inheritance in folder hierarchies. • A checklist tool update was demoed featuring auto-reminders, font size controls, and the psychological value of visually crossing off completed tasks. • A user suggestion to move completed items to the bottom of the list was discussed as an optional UX improvement.
[00:28:04] – AI Misuse: Programs vs. AI for Repetitive Tasks • A strong recommendation was made to write actual programs (AutoHotkey, Python, etc.) for repetitive or deterministic tasks rather than relying on AI each time – AI burns tokens, is slower, and can fail inconsistently. • Examples given included stripping HTML from text or wrapping text with alignment tags – tasks better handled by a hotkey script than an AI prompt. • The team ran Claude’s “insight” tool to review recent usage and generate skill/hook suggestions, noting it analyzes the past month’s sessions and recommends Claude MD and JSON setting updates.
[00:46:47] – MCP Plugin Architecture & VS Code Session Management • Discussion centered on how to package and distribute the team’s MCP, skills, and agents – debating whether a plugin model or an autonomous MD-file-driven install process is better. • A plugin approach was favored for clean enable/disable functionality; without it, disabling the MCP would leave orphaned skills and hooks behind. • VS Code session history issues were revisited – chat history is folder-bound in Claude Code, requiring users to open the correct project folder to restore prior session context.
[00:56:03] – AutoHotkey 2.1 Alpha & ASM Help File Bug • Isaias noted that AutoHotkey 2.1 alpha’s updated structure handling could significantly improve Scintilla control performance; the team agreed to monitor but not act yet given its alpha status. • AutoHotkey V2’s surprisingly fast transition from alpha to default version was recalled as a cautionary tale to stay aware of version changes. • A user-reported bug in ASM (F1 help not loading) was traced to a likely missing or misplaced CHM help file; a fix was proposed to add an error message when the file isn’t found at the expected path.
[01:00:00] – Monetization Strategy & Effective AI Usage Philosophy • With fewer client requests due to the perception that “AI makes coding easy,” the team considered pivoting to selling finished solutions rather than teaching how to build them. • A “grill me” AI skill was mentioned as a useful technique for stress-testing ideas before building, though the host noted he typically has enough context to skip it. • The session closed with a proposal to create a comparison video: Claude configured with full skills/agents vs. a bare “incognito” Claude – to demonstrate the real value of a properly tuned AI environment.
—
*Brief Summary*
AHK Hero 2026 05 15 Friday Hour 1
*Summary*
This group session covers AI-assisted AutoHotkey development, focusing on practical tooling improvements including an automated spy tool with dark theme, a HAR file analyzer for reverse-engineering web APIs, a to-do checklist upgrade, and a live demonstration of an AutoHotkey MCP server that enables autonomous script debugging.
*Key Points*
[00:00:00] – AI in Programming & Browser vs. IDE Discussion
• A participant shares that only ~7 of 120 government programmers use AI, highlighting slow adoption due to restrictions.
• The group contrasts browser-based AI use vs. VS Code integration – IDE use is a significant productivity multiplier for heavy programmers.
• Idea raised: build an MCP server usable from the browser to enable file read/write, bridging the gap between browser and IDE workflows.
• “Vibe coding” risks discussed – non-programmers going blind can create unmaintainable messes; agentic engineering with baby steps is safer.
• Plan is to evolve the standalone MCP into a plugin bundling agents, skills, and the server for zero-config deployment.
• Pushing users toward Claude Desktop or VS Code extension is preferred over browser, as it gives full environment control.
• MCP-for-browser is theoretically possible (to enable file writing), but browser plugin support is unconfirmed.
• VS Code Peacock extension briefly discussed for per-project caption coloring; dark theme legibility tradeoffs noted.
—
*Brief Summary*
The session showcases a productive development group iterating rapidly on AutoHotkey tooling with AI assistance – from GUI theming and checklist enhancements to powerful concepts like HAR-based API reverse engineering and autonomous MCP debugging. The overarching theme is reducing reliance on ongoing AI token consumption by using AI to generate reusable code assets, while evolving the MCP server toward a polished, distributable plugin for the broader community.
AHK Hero 2026 05 09 Saturday Hour 1
*Summary*
A Saturday developer session where the team demonstrates and discusses AutoHotkey tools, Claude Code workflow enhancements, AI model selection strategies, billing ethics with AI, and an AutoHotkey MCP debug server walkthrough.
—
Learn more about AI and Automation at: https://the-Automator.com
Or consider joining our amazing Hero club here: https://the-Automator.com/Hero
*Key Points*
[00:00:00] – M Function & Dark GUI Tools Demo
• The M function was enhanced with WebView2 HTML rendering and a new timeout/duration parameter, allowing color previews to auto-dismiss after set milliseconds.
• A custom dark-themed message box GUI was built via Claude in minutes – replacing the default Windows message box to keep replies consistently dark-themed with custom buttons.
• The team noted AI-generated code arrived error-free and was immediately usable as a standalone library skill.
[00:09:00] – Claude Code Completion Hooks & Notification System
• A hook system was built to alert users visually and audibly when Claude Code finishes processing, displaying which specific instance completed.
• The team identified the need for a second notification type – when Claude is waiting for user input – with a distinct color and sound to differentiate it.
• Ideas discussed: persistent notifications until clicked, callback functions to auto-switch the active window, and potentially using voice synthesis to read task names or questions aloud.
• Hooks must be manually wired into Claude’s settings JSON after being copied to a new machine; Claude itself can handle the wiring when asked.
• A shared S-drive workflow syncs skills between collaborators, but users must manually notify each other of updates.
• A new in-progress tool aims to search within and across Claude conversation history by content, with future plans to use embedding models for concept-based search.
[00:27:05] – AI Model Thinking Levels & MCP Server Introduction
• The group debated when to use higher thinking modes: Medium suffices for most tasks; High/Max is best reserved for complex planning, WebView2/WebDriver work, or pre-release code reviews.
• Using “Think Hard” mode for a simple task caused excessive wait times – the team agreed it’s best scheduled overnight or for substantial planning, not routine coding.
• Checklists and well-defined skills reduce reliance on high-intelligence modes, similar to giving clear processes to less-skilled workers vs. relying on a single expert.
[00:36:01] – MCP Live Testing, AI Billing Ethics & Productivity Gains
• The AutoHotkey MCP server was demonstrated live; the team noted it autonomously launches, tests, and debugs scripts but has some current token-efficiency issues.
• A billing ethics discussion arose: running Claude simultaneously for two clients raises fairness questions; the consensus leaned toward a blended AI-usage rate rather than double-billing.
• Attendees cited 10x+ productivity gains from Claude Code, noting humans are now the bottleneck – AI waits on us, not the other way around.
[00:44:56] – AI Industry Trends, Chrome’s Hidden AI File & Desktop Critter
• Chrome was flagging for silently downloading a 4GB local AI model file that reinstalls itself if deleted; the team discussed scripting a removal solution.
• Mary Meeker’s 300-slide AI report was shared, showing dramatic drops in cost-per-token alongside skyrocketing energy demand.
• A fun “Desktop Critter” script was discovered – AI had spontaneously created a mouse-following animated character when asked to surprise the developer.
[00:53:57] – MCP Server Architecture & Wrap-Up
• The AHK MCP server tools were reviewed: script execution/validation, process management (list, find, kill, version), debug protocol (attach, break, step, variable inspection), and workflow recipes.
• A scheduled daily Claude review of prior work suggested recreating a Python debug tool in AutoHotkey; the team deferred it as a future consideration.
• The session closed with plans to continue refining shared tools, notifications, and the conversation-search feature.
—
*Brief Summary*
The session showcased rapid AI-assisted tool development – from dark GUI components to intelligent workflow hooks – while surfacing practical questions around model selection, fair billing, and collaboration workflows. The team’s overarching takeaway is that humans have become the primary bottleneck in AI-assisted development, and building better notification and automation systems will unlock even greater productivity in the weeks ahead.
AHK Hero 2026 05 08 Friday Hour 2
*Summary*
A developer group meeting covering Claude Code session management, AutoHotkey tooling updates, Scintilla UI Inspector improvements, AI workflow strategies, and reflections on AI’s impact on developer productivity and creativity.
—
Learn more about AI and Automation at: https://the-Automator.com
Or consider joining our amazing Hero club here: https://the-Automator.com/Hero
• ASM with embedded skills and MCP can deliver quality AutoHotkey scripts to non-technical users automatically.
• MCP auto-launches and debugs AHK scripts without manual intervention; hooks can trigger full testing automatically.
• Repetitive back-end tasks (documentation, downloads, file validation) should be templated and automated via agents/MCP.
• Minor AutoHotkey updates were released; group wraps up and plans to continue next session.
—
*Brief Summary*
The session highlighted practical advances in Claude Code session management, Scintilla-powered tooling, and AI-assisted AutoHotkey development. The group’s broader takeaway is that AI has fundamentally shifted the developer role toward creative orchestration and high-level planning, with automation handling repetitive tasks. Next steps include finishing MCP enhancements, building templated workflows, and quantifying measurable productivity gains.
AHK Hero Call 2026-05-08 Friday Hour 1
*Summary*
This ~1-hour Friday group call covers AutoHotkey tooling, UIA/UI automation debugging, custom AutoHotkey utilities (magnifier, water ripple), VS Code session management, and a new government Passport Agency project where AI-assisted AutoHotkey scripting will be introduced to beginners.
—
Learn more about AI and Automation at: https://the-Automator.com
Or consider joining our amazing Hero club here: https://the-Automator.com/Hero
*Key Points*
[00:00:00] – Intro, Small Talk & UIA Crash Investigation
• Group opens with casual chat about Samsung’s $340K bonus complaints and Nordic hiking poles as a “tools” metaphor.
• A user reports their genealogy program crashes when the UIA tool captures elements – Irfan diagnoses it as message overload causing silent internal crashes.
• Error code 0x80040201 is identified: a UIA core API error meaning the automation element was virtualized or destroyed mid-capture.
• Team suggests adding sleeps, try/catch blocks, or better error messaging to prevent cryptic failures.
[00:10:09] – Hotkey Conflicts & ACC Fallback
• Team attempts to remap conflicting hotkeys (F1, Alt+F1, Shift+X) to avoid triggering the genealogy program crash.
• Every hotkey tested still causes the target program to crash – UIA and Descalad Inspector both fail on this app.
• ACC (Accessibility) is confirmed to work where UIA cannot; idea raised to build a custom ACC inspector using Claude.
• Passport Agency project mentioned – group currently using AutoHotkey V1 + XQ Studio; Maestri may be invited to assist.
[00:20:05] – Live Tracking, Tree Building & Custom Magnifier Demo
• F2 live-tracking mode highlights elements without crashing, but building the full element tree still crashes the program.
• Proposed fix: step-by-step right-click tree exploration to isolate the problematic element.
• Demo of a custom AutoHotkey magnifier tool (Win+Z hotkey) – zooms a screen region, lockable with Shift, fully configurable; required a restart to apply preference changes.
• A water-ripple click effect (32-bit DLL) also shown; V2 recreation not easily shareable over screen share.
[00:30:00] – VS Code Session History Tool & AI Tool Comparisons
• Joe built a tool to scan VS Code’s JSON session files, showing session counts per folder with right-click open support – addressing history appearing “lost” when switching folders.
• Next step: load session descriptions into an embeddings model for concept-based search across all past sessions.
• Discussion of Claude (VS Code extension) vs. Anti-Gravity (Google): both similar in workflow/skills/MCP support; Claude Code preferred for file context awareness.
• UIA download found to have a hardcoded S-drive path bug; team plans an AI skill to auto-detect and fix embedded paths in releases.
• Notify library missing from UIA Inspector lib folder – Connie’s local version differs from the public download; fix is to bundle a copy or remove the dependency.
• Ray troubleshoots an auto-loading Zoom transcription app; moved to a breakout room with Irfan for one-on-one help to avoid derailing the main call.
• Proposal: build an automated skill to check release packages for hardcoded paths and resolve them using AI before publishing.
[00:49:59] – ASM/AHK Script Maker AI Integration & Passport Agency
• Joe proposes embedding Claude Code-style skill-matching logic into ASM (AHK Script Maker) via Open Router API – keeping it AI-tool-agnostic (important given Anthropic’s prior federal government restrictions).
• Workflow: user describes goal → AI matches relevant skills by name/description → injects skill prompts + user preferences → generates AutoHotkey script.
• Passport Agency users are complete beginners (V1, no original code written); V1 acknowledged as slightly more forgiving for entry-level use, but V2 strongly preferred long-term.
• GUI complexity in V1 is a dealbreaker – team may need a V2→V1 downgrade conversion tool; AI-written scripts seen as the path forward so users don’t need to code manually.
—
*Brief Summary*
The session centered on diagnosing a persistent UIA-induced program crash, demoing custom AutoHotkey screen tools, and planning smarter developer workflows including VS Code session search and AI-skill integration into ASM. The biggest forward-looking topic is equipping a government Passport Agency with AI-assisted AutoHotkey scripting – removing the coding barrier entirely and allowing even non-programmers to generate useful automation scripts.
AHK Hero 2026 05 02 Saturday Hour 1
*Summary*
The video is a discussion and live walkthrough on using AI to speed up software/automation work while avoiding over-dependence on AI APIs and token costs. Participants cover practical voice/vision assistant workflows, then demo an AutoHotkey-style “skill” process to generate script scaffolding, documentation, and a WordPress-ready download post, ending with notes on automation gaps and a daylight-savings reminder bug.
Learn more at: https://the-Automator.com
Or consider joining the Hero Club and Learning how easy AI can be: https://the-Automator.com/Hero
*Key Points*
– [00:00:00] – Building tools to reduce AI dependency (tokens, determinism)
• They discuss hard conversion tasks (SVG→PNG, ICO creation) and how newer AI helped solve previously blocked steps.
• Core strategy: use AI to help create deterministic, programmatic tools so results don’t break when APIs/pricing/limits change.
• Concern: many “AI teaching” workflows burn tokens and produce non-repeatable outputs; this threatens reliability and independence.
• Notes on token limits rising effectively (hitting caps faster) and skepticism about “token saving” prompts being throttled.
• Claude/Gemini live voice features compared; local voice workflows (foot pedal + local LLM) can be faster but latency matters.
– [00:09:14] – AI as multimodal assistant + “rubber duck” productivity
• Using screen share/camera gives AI “eyes,” enabling personal-assistant use cases (capturing tasks, interpreting on-screen graphs).
• AI helps clarify thinking: explaining a problem out loud exposes unclear requirements; AI’s basic questions prompt insight.
• Example: interpreting inverter load graphs (percent→watts) via Gemini screen share instead of manual calculations.
• Example: helping a child with homework by conversing in Urdu while producing answers in English; AI adapts tone to the audience.
• Idea: ask AI to respond in the user’s own writing/speaking style to improve comprehension and soften overly blunt communication.
• They demo generating/updating an “image converter” script using an AI-driven “skill/script object” that adds headers, versions, dates, and tray menu pieces.
• Technical constraint explored: includes run before logic, so conditional includes (compiled vs uncompiled paths) likely won’t work cleanly.
• Practical gotchas: hard-coded include paths are bad for sharing; missing resource/icon references can break compilation and need disabling.
• Discussion on choosing icons intelligently (e.g., AI shortlist vs browsing thousands) and reviewing diffs to confirm what AI changed.
– [00:27:36] – Documentation + TODO tracking + token-aware workflows
• Different approaches to tracking fixes: comments/TODO flags in code vs external lists (sticky notes), with interest in a skill that scans TODO markers.
• Documentation pipeline: generate docs first so downstream AI/blog steps understand the tool; docs output to HTML/PDF via markdown conversion.
• UX improvement idea: add a tray menu link to open local PDF/docs directly from the tool.
• Token economics: embedding full docs inside scripts may waste context when sending code to AI; mitigate by separate includes and telling AI to ignore docs.
• They walk through generating simple WordPress-compatible HTML (limited CSS) and discuss automating code examples via GitHub Gists.
• Emphasis on marketing clarity: lead with user value (“why it matters”) before features; AI skills can enforce this structure.
• Operational steps shown: create Dropbox share folder named for the zip, generate/paste share links, set WordPress “pretty link” slug, and publish.
• Noted automation opportunities: auto-generate subject lines/tags, auto-update site version/date by extracting version via regex and pushing via MySQL/API.
• They highlight “dev path” conventions to quickly locate source when users report issues.
• Dropbox folder sharing benefits: downloads zip dynamically from folder contents; updating the folder updates the delivered zip without site edits.
• Final release checklist discussed: apply fixes, bump version, commit to repo, copy artifacts to shared folder.
• A Telegram/meeting reminder script posts incorrect start times (off by an hour), likely due to daylight savings; they plan to inspect the logic.
*Brief Summary*
AHK Hero 2026 05 01 Friday Hour 2
*Summary*
This call reviews several AutoHotkey tooling improvements and experiments: cleaning up tray menus for compiled vs script builds, extracting YouTube-related data/subtitles using Firefox cookies, and expanding an AI-assisted workflow for testing and reusable “skills/agents.” It also covers a real GUI z-order bug across machines, plus automation ideas like semantic search over transcripts and automatic icon generation.
Learn more at: https://the-Automator.com
Or consider joining the Hero Club and Learning how easy AI can be: https://the-Automator.com/Hero
*Key Points*
– [00:00:00] – Tray menu cleanup for scripts vs executables
• Goal: remove “Edit Script” / “Reload Script” options from the tray menu when distributing a compiled EXE, while keeping helpful options during script development.
• Demonstrates that compiled apps naturally lose “edit script” entries, but custom menus can accidentally remove *all* standard items if not rebuilt correctly.
• Approach: build a controlled tray menu and use compile-detection (e.g., `A_IsCompiled`) so menu items/labels change depending on script vs EXE.
• Practical safety tip: add an emergency exit hotkey (e.g., Esc) while iterating on tray menu logic to avoid getting “stuck” in reload loops.
– [00:09:47] – Trigger class vs standard tray menu behavior
• Discussion on whether to implement the compiled/script logic inside the Triggers class or keep it separate.
• Triggers class primarily manages hotkeys/menus; after it finishes, developers can append custom items (toggles, About, separators).
• Using “Add Standard” is preferred by some because it auto-handles compiled vs script defaults (shows Edit Script only for scripts).
• Takeaway: keep responsibilities clear – Triggers builds core menus; optional custom menus can be layered after.
– [00:19:24] – Firefox cookies and subtitle scraping + embedding search idea
• Key discovery: Chrome/Chromium tends to hash/protect cookies/API keys, while Firefox storage can be more accessible for automation.
• Workaround for YouTube data/subtitles: login via Firefox, reuse the stored auth/API key/cookies to call YouTube endpoints and scrape transcripts.
• Data storage plan: video metadata IDs in SQLite; subtitles saved as SRT/VTT files, then “pull together” for unified access.
• Proposed product direction: create semantic (“search by meaning”) retrieval over thousands of long transcripts via embeddings in SQLite; cost may be lower than expected and can be updated iteratively (only embed new content).
– [00:29:03] – Testing taxonomy + leveraging CLIs/MCP for automation
• Clarifies “smoke test” (quick “does it blow up?” validation) and contrasts it with unit, functional, sanity, and end-to-end testing.
• Emphasis on building reusable AI assets: MCP server + skills/agents to generate tests and automate validation.
• Performance principle: use fast native/CLI tools (e.g., FileX Search C executable) for heavy work like file enumeration; have AHK act as the GUI/orchestrator.
• Notes on integration: capture CLI results via STDOUT rather than reimplementing search in AHK.
• Bug: Preferences dialog sometimes appears behind the main GUI on some machines even when both are “Always on Top.”
• Cause/insight: window ownership and “owned z-order” can flip ordering inconsistently across machines (drivers/DWM/compositor differences).
• Fix: after setting ownership, re-apply “AlwaysOnTop” to restore correct z-order; request to encode this into the AHK GUI skill so it’s not a “tribal memory” fix.
• Automation idea: generate tray/app icons automatically by selecting an MDI (Material Design Icons) SVG and converting to ICO via FFmpeg tooling; possibly wrap as a CLI + skill.
• Closing: coordination about meeting attendance/time zones and need for a co-host to manage participants/chat.
*Brief Summary*
The group focused on making AHK tools more “production-ready” by ensuring compiled builds hide dev-only tray actions, while still supporting flexible custom menus. They also advanced an automation pipeline using Firefox-derived auth/cookies to scrape subtitles and explored embedding-based semantic search at scale, alongside strengthening AI-driven testing and reusable skills. The call ends with actionable fixes (GUI z-order, tray logic safeguards) and next-step ideas (skills for GUI patterns and icon generation).
AHK Hero 2026 05 01 Friday Hour 1
*Summary*
This video is a team discussion on building a more intentional “AI + tools + memory” workflow – especially for AutoHotkey development and related content operations. The group shares practical examples (skills, scripts, utilities) and debates UX details while emphasizing incremental automation and shared knowledge systems.
Learn more at: https://the-Automator.com
Or consider joining the Hero Club and Learning how easy AI can be: https://the-Automator.com/Hero
• Presenter introduces a diagram framing work as: you + AI tool(s) + cross-cutting “memory,” plus task-specific tooling (skills, agents, CLIs, MCP servers, browser APIs).
• Key takeaway: stop being ad hoc – build repeatable “pillars” per frequent task (AutoHotkey, newsletters, emails, YouTube, downloads vs blog posts).
• Skills are highlighted as the fastest entry point; agents/tools can be layered later.
• Demonstration of an AI “script object” skill that generates a customized script header/template (compiler directives, includes, tray menu, optional pieces).
• Discussion of integrating tool creation with backend systems (e.g., generating pretty links, tying to downloads/landing pages).
• Risk noted: AI can fabricate “valid-looking” slugs/links that don’t exist yet – needs DB/API integration or placeholders (e.g., pre-created download IDs).
– [00:17:50] – Tray icon management, “ghost icons,” and dev iteration ergonomics
• Conversation about controlling which AutoHotkey tray icons appear (including a “fake AHK exe” approach).
• “Ghost tray icons” issue: icons remain after crashes/kills and disappear when hovered; a cleanup script can enumerate tray icons and remove stale entries.
• Pain point: testing multiple script versions leads to multiple tray instances – ideas include auto-killing previous instances or programmatically differentiating icons.
– [00:35:42] – Claude Code hooks/commands, output control, and multi-model validation
• Hooks/techniques to know when an AI response is truly finished (avoid copying incomplete code blocks).
• Preference for minimal verbosity: “just output the code/file,” plus using slash commands like `/clear` (new context) and `/compact` (summarize while optionally preserving key items).
• Tooling examples: “Council” via OpenRouter to query multiple LLMs and compare answers; Firecrawl-based deep research reports; Gemini “gems” as agent-like helpers.
– [00:53:27] – Memory systems: Claude memory files, “second brain” in Supabase, and wiki-style knowledge
• Memory is positioned as crucial but needing maintenance/compaction; AI can help prune outdated memory.
• “Second brain” approach: store shared/team memory in a cloud DB (Supabase/Postgres) so multiple agents/tools can query the same source of truth.
• Wiki/Obsidian-style notes complement databases: DB for storing knowledge; wiki for evolving, human-navigable “reports” and project structure (e.g., GTD workflows).
*Brief Summary*
The core message is to treat AI enablement as an engineered system: shared memory plus reusable skills/templates and supporting utilities, built around real recurring workflows. The team recommends incremental automation, validating AI-generated artifacts against real backend data, and investing in shared memory (DB + wiki) so multiple tools and agents can work consistently.
AHK Hero 2026 04 25 Saturday Hour 1
*Summary*
This is a Saturday group working session where team members discuss Claude AI skills, demonstrate several AutoHotkey tools they’ve been building, and troubleshoot YouTube API authentication issues. The conversation covers a markdown file previewer built in five minutes using WebView2, an advanced file search tool with archive-searching capabilities, a Google Maps review scraper that scores businesses on review response rates, and challenges with OAuth2 authentication for accessing YouTube channel data.
*Key Points*
[00:00:00] – Claude Skills and Markdown Preview Tool
• A team member shares excitement about creating a Claude skill, with the group emphasizing that well-written skill descriptions are critical for triggering them properly – most skills fail not because they’re broken, but because they never get triggered.
• The “Insights” feature in Claude was highlighted for its ability to self-improve by suggesting better skill descriptions.
• A standalone markdown file previewer was built in under five minutes using the WebView2 library, rendering markdown into a formatted HTML-like view side-by-side with the raw text.
• Skills are now recognized industry-wide as standardized and interoperable across models; importantly, they’re called more often by Claude and agents themselves than by users directly.
[00:09:24] – XP Search Tool Demo and Archive Search
• The team demonstrates an enhanced file search tool with new date-filtering options (days back, weeks back, months back) and a “between” date range for older files.
• A complex “search inside archives” feature was added, supporting zip and 7-zip files, allowing content searches within compressed archives – though it took hours to compile the required libraries.
• The tool successfully finds files inside zip archives and searches text content within them, with the team live-testing and confirming the functionality works quickly.
• UI improvements include reorganized advanced options, theme color fixes, font size limits (8-14), and the ability to set VS Code as the default editor for various file types.
[00:18:47] – Google Maps Review Scraper Tool
• A Google Maps scraper tool was demonstrated that searches for businesses, extracts unique IDs, then scrapes all reviews to analyze whether business owners are responding to customer feedback.
• The tool generates a TSV report with mathematical scoring that categorizes businesses as hot, warm, or cold leads based on reply rates to both positive and negative reviews.
• JSON files capture detailed review data including owner reply times and content, enabling analysis of response quality – such as detecting businesses that paste identical generic replies.
• The tool was built in about 30-40 minutes by leveraging existing scraper infrastructure, showcasing Claude’s ability to rapidly generate complex business logic code.
[00:28:09] – Review Response Strategy and AI-Assisted Workflows
• The group discusses how businesses should incorporate specific details from reviews in their replies rather than using generic responses, as personalized replies build trust and serve as additional promotional content.
• A practical workflow is proposed: have Claude draft review responses daily, but keep a human-in-the-loop approval step before posting – automating composition while maintaining quality control.
• The team agrees on a “trust but verify” approach to AI automation: let Claude handle tasks consistently before granting full autonomy, similar to how hotkey automations stop short of final posting for review.
• The team rediscovers an older YouTube subtitle search tool that searches transcripts from their channel’s videos, finding it partially functional but with broken library references that need updating.
• The tool has a four-step database building process, but outdated JSON library includes and moved file paths prevent it from running properly – the group suggests having Claude fix the code.
• A key challenge is that HERO group calls are unlisted YouTube videos, making subtitle extraction difficult since unlisted videos may not have auto-generated captions and can’t be included in public tools.
[00:46:52] – OAuth2 Authentication Challenges
• The team encounters OAuth2 authentication hurdles when trying to access YouTube’s API, with Google requiring app verification for desktop applications – a long registration process that blocks quick testing.
• Chrome’s recent updates prevent using the user data directory for automated browser sessions (Selenium/Rufaedium), requiring creation of separate profile folders and manual login steps.
• Multiple authentication approaches are discussed including Playwright, borrowing browser cookies directly, and using refresh tokens, with the consensus being to ask Claude for the simplest path forward.
[00:56:14] – API Verification, Internal vs. Public Apps, and Next Steps
AHK Hero 2026 04 24 Friday Hour 2
*Summary*
This video captures a team working session focused on AutoHotkey tooling and AI integration. The group demonstrates an updated Registry Viewer tool with copy-to-code functionality, explores building a Command Line Interface (CLI) for Excel using an existing function library, and shares practical AutoHotkey hotkey tips including always-on-top window toggling and custom Explorer launch shortcuts.
*Key Points*
[00:00:00] – Registry Viewer Tool Demo and AI Integration
• The team demonstrates an updated Registry Viewer tool, originally based on a WMI viewer, now featuring the ability to right-click registry entries and copy ready-to-use AutoHotkey code – the primary reason the tool was built.
• The tool is set to read-only mode to prevent accidental registry modifications, and includes both a curated view and a browse view for navigating registry keys.
• They discover that some registry keys appear empty due to permission levels; most keys are readable without admin, but certain keys (like HKLM Security) require elevated privileges.
• The tool includes an AI query feature that helps users locate specific registry paths, demonstrated by searching for AutoHotkey editor settings and sticky keys configuration.
[00:08:40] – AI-Powered Registry Exploration and Tool Discussion
• The team uses AI to find default editor settings in the registry, surfacing paths for TXT user choice and text editor defaults – showcasing how AI helps navigate the registry’s vast structure.
• They explore sticky keys registry values, discovering bitwise flag combinations (value 26 = 16+8+2) and discuss using AI to decode these flag combinations automatically.
• The AI integration in the tool has limitations – it forces responses into code output rather than explanatory answers, highlighting the need for a proper chatbot mode.
• Brief discussion about potentially selling these tools commercially, with the File Search XP tool noted as particularly valuable.
[00:17:24] – Clipboard Workflow Tips and AI Communication Patterns
• Ray shares a tip about instructing Claude to output content directly to the clipboard, especially useful for long file paths that are difficult to copy from chat.
• The team suggests an improved approach: have AI write output to a dedicated file, then use an AutoHotkey script to read that file on demand via hotkey – avoiding unwanted clipboard overwrites.
• Discussion about frustrations with Claude’s interaction patterns, particularly when it asks users to manually run and paste results instead of automating via MCP or clipboard.
• Irfan introduces the concept of building a CLI for Excel, which initially confused the team lead but led to a productive experiment using Claude to generate a CLI from their existing Excel function library.
[00:25:46] – Excel CLI Development and Documentation Generation
• The team asks Claude to auto-generate documentation for the Excel CLI tool using their existing documentation skill, which produces HTML/PDF output.
• The CLI tool wraps their Excel function library (~1,500 lines of code) into a command-line executable that uses COM objects under the hood to communicate with Excel.
• They demonstrate the CLI creating a sales report, adding data, and generating summary sheets – though formatting commands like cell coloring weren’t fully included from the source library.
• Key insight: converting any AutoHotkey script into a CLI enables inter-program communication, allowing tools to pass data to each other without manual intervention.
[00:34:19] – Excel CLI Formatting and Cross-Tool Communication
• When the CLI couldn’t handle formatting, AI automatically wrote a separate AutoHotkey script to apply highlighting, charts, and merged headers – remembering the data structure from context.
• The generated script created pie charts and bar graphs for revenue data, demonstrating sophisticated Excel automation beyond basic data entry.
• Discussion of Claude’s design tool for potentially creating improved AutoHotkey GUIs, with the suggestion to adapt Claude’s HTML-focused design skills for AutoHotkey interfaces.
• The CLI approach is positioned as powerful for tool interoperability – any program (not just AutoHotkey) can feed commands to the CLI executable.
[00:42:53] – AutoHotkey Hotkey Tips: Always-On-Top and Custom Explorer Launch
• Demonstration of a simple but powerful `WinSetAlwaysOnTop` command using Win+A, with a -1 parameter for toggle behavior – making any window stay on top.
• Irfan suggests appending text to the window title bar to indicate always-on-top status, providing visual feedback to the user.
• Custom Win+E hotkey override demonstrated: instead of opening Explorer to default location, it launches directly to a specific drive (S:), saving navigation time.
• Two approaches compared – one activates an existing window if already open, the other always launches a new instance – showing different use cases for the same concept.
*Brief Summary*
AHK Hero 2026 04 24 Friday Hour 1
*Summary*
This is a Friday team meeting where developers review several AutoHotkey tools built or updated during the week, largely with AI assistance from Claude. The discussion covers a new XP-style file search tool, a rebuilt Scintilla lexer DLL, AI integration into a UIA inspector, a GUI mapping tool for Claude, hotkey stream lookup improvements, CLI vs. VS Code workflow differences, and how Claude handles screenshots.
Learn more about AI and Automation at: https://the-Automator.com
Or consider joining our amazing Hero club here: https://the-Automator.com/Hero
*Key Points*
[00:00:00] – Team Check-in and XP-Style File Search Tool
• After brief personal updates, the team dives into the week’s main accomplishment: a new file search tool inspired by the old Windows XP search interface and the $100 File Search X tool.
• The tool was built in just a couple hours using Claude. A C-compiled CLI executable handles fast file searching while AutoHotkey manages the GUI and stdout events.
• Features include file/folder/both filtering, exclude folders option (Claude’s suggestion), include/exclude text filters on filename or path, file type categories via preferences, size and date filters, regex support, dark/light theme toggle, and customizable font size and editor selection.
[00:09:57] – Preferences, UI Polish, and Scintilla Lexer Rebuild
• Minor UI issues were noted – status bar text too light in white theme, regex checkbox hidden by overlapping controls, and font size affecting layout.
• The major breakthrough: rebuilding the Scintilla lexer DLL, which multiple advanced programmers estimated would take two weeks. Claude accomplished it in hours by writing C code, installing the GCC compiler, and compiling the custom lexer DLL.
• The new lexer supports iLexer5, enabling updated syntax highlighting, code folding, and 22+ token types compared to the original 7.
[00:19:51] – Scintilla Autocomplete, Call Tips, and Wrapper Class
• Irfan demonstrated the new Scintilla control with autocomplete and call tips for AutoHotkey, including parameter switching with braces.
• Keywords are grouped into color-coded categories (KW, KW2, etc.) with up to nine groups now available. Autocomplete lists are built from keyword definitions and XML files.
• Syntax comments, folding braces, and escape characters are all properly handled. A wrapper class is planned to simplify deploying Scintilla controls across tools.
[00:29:51] – UIA Inspector AI Integration and GUI Eyes Skill
• The UIA inspector now has AI integration via OpenRouter, allowing users to send element trees to AI and receive code suggestions for unique element paths. Token configuration issues are still being debugged.
• An element index number was added next to the highlight button for easier targeting of duplicate matches.
• A simplified “simple mode” view is planned that hides advanced details, letting users drag-and-drop to select elements and have AI generate the access code directly.
[00:39:48] – GUI Eyes Skill for Claude and Hotkey Stream Lookup Updates
• A GUI mapping tool was built that captures AutoHotkey GUI control positions and generates a markdown prompt (with ASCII layout) for Claude, helping it understand spatial positioning instead of guessing pixels.
• This was converted into a Claude skill (“HK GUI Eyes”) so Claude can call it autonomously when adjusting GUI layouts, improving alignment accuracy.
• The Hotkey Stream Lookup tool (v6.2) now shows context-sensitive hotkey conditions (HotIf), adds filtering by hotkey context, and includes a toggle for hotkey string display. Fuzzy match was refined – the ordered-character matching was too aggressive, so users can now disable it in favor of n-gram matching.
[00:49:39] – File Discovery Logic and Executable Detection
• Discussion about how the lookup tool discovers running scripts revealed it uses hidden AutoHotkey class GUIs (present in every running AHK script/exe) rather than scanning for .ahk files directly.
• This explains why compiled executables like OCR.exe appear in the list. Users can disable specific entries via preferences.
• An unresolved editor activation bug was noted – the tool sometimes fails to detect and navigate to the correct line in the configured editor.
[00:59:31] – Claude’s Image Processing, CLI vs VS Code, and Wrap-up
• The team discovered Claude appears “colorblind” when processing screenshots of code – it performs OCR on text-heavy images and loses color information, but can recognize non-text images like photos.
• A debate about CLI vs. VS Code extension revealed Irfan feels CLI delivers smarter results, possibly due to easier file/line referencing. David demonstrated drag-and-drop screenshot uploads work in CLI.
• Screenshots are most useful when they replace lengthy text descriptions; the team’s snipping tool and OCR utilities streamline this workflow.
*Brief Summary*
AHK Hero 2026 04 18 Saturday Hour 1
*Summary* This video is a collaborative technical working session among a group of developers and automation enthusiasts focused on AutoHotkey (AHK) tooling, UI Automation (UIA), and browser automation. The team discusses recent tool updates, a new browser helper class, UIA inspector improvements, a real-world image scraping task using Firecrawl, and future plans for upgrading their Rufadium browser automation library.
—
Learn more about AI and Automation at: https://the-Automator.com Or consider joining our amazing Hero club here: https://the-Automator.com/Hero
*Key Points* [00:00:00] – Custom Tool Updates and Zoom Toolbar Enhancements • A developer shares a newly built hotkey tool that quickly displays file lengths for selected files, avoiding the need to manually add a length column. • Plans include aligning decimals in the display for cleaner readability across multiple files. • The Zoom toolbar overlay received preference upgrades: users can now choose the monitor it appears on, adjust font size, change transparency, and right-click to hide it for five seconds. • A Notify class was updated via Claude to display tooltip-style notifications near the mouse cursor rather than center screen — accomplished in just two lines of code.
[00:08:45] – New UIA Browser Helper Class Introduction • Irfan walks through a newly created UIA browser helper class with support for Chromium and Firefox-based browsers, wrapping core browser actions into simple methods. • Available methods include: get URL, navigate, go back/forward, reload, zoom, tab management, duplicate tab, close window, wait for page load, wait for URL pattern match, handle alerts, and check if the browser is still alive. • JavaScript execution support is planned but not yet implemented. • The class extends browser-specific subclasses (Chromium vs. Firefox) to handle differences like URL retrieval and accessibility activation.
[00:17:18] – UIA Inspector: Element Selection Index and Wait Element Logic • Discussion centers on adding an index/spinner control to the UIA Inspector so users can target the 2nd, 3rd, or Nth matching element instead of always the first. • The group agrees to standardize on a single “find all” method with an index number (similar to DOM’s querySelectorAll), making it simpler to learn and easier to test by changing just one number. • The “wait element” function is examined — the team decides to include both a found and not-found logic branch in code generation templates, with clear comments guiding users on what to do in each case. • Value of error logging is debated: one member argues that building self-logging and self-checking systems up front saves time long-term, while another notes the ROI depends on failure frequency.
[00:25:48] – Real-World Firecrawl Image Scraping Demo • A HERO community member’s father passed away, and he needed photos scraped from a funeral home’s website that used dynamic (non-URL-changing) image loading. • Irfan uses the Firecrawl tool (free tier available) to inspect XHR network requests, extract unique image URLs into a text file, and then runs a Python script to loop through and download each image. • Images downloaded successfully at varying sizes (up to 1800px wide), likely originals or near-originals. • EXIF metadata was present but pointed only to the file location — no original filename was recoverable from the metadata in this case. • The Claude Code environment autonomously installed the Firecrawl CLI when it detected it was needed — praised as a key benefit of agentic coding tools.
[00:34:23] – Automated Documentation Generation with Claude • While waiting on the scraping job, a member explains how they used Claude to auto-generate documentation and a blog post for an AutoHotkey script. • Claude read the script to understand its purpose, then used a documentation skill and a blog post skill — pulling in pricing data from a script object — to produce branded HTML output converted to PDF. • The PDF was intentionally styled with light/white-friendly colors so it prints cleanly without excessive ink usage. • The group notes Claude can likely handle EXE-based scripts similarly if told it’s AutoHotkey.
[00:43:04] – Rufadium Upgrade Discussion and Browser Automation Comparison • The group discusses enhancing Rufadium (their WebDriver-based browser automation tool) using AI, potentially with a full rewrite and the addition of a CLI or MCP interface. • Irfan compares Playwright (direct DevTools Protocol connection) vs. WebDriver (API-based interface to DevTools), noting they achieve similar outcomes through different architectural approaches. • Microsoft Edge’s WebDriver is highlighted for its unique Windows integration capabilities vs. Chrome’s WebDriver. • Admin privilege requirements for installing WebDriver executables in corporate environments are identified as a real-world limitation and a potential area for improvement.
[00:51:36] – CLI for Excel and UIA Helper Class Planning • Irfan proposes building a CLI for Excel using the COM object via AutoHotkey, arguing it would be AI-friendly and token-efficient compared to MCP. • The group debates whether a CLI offers meaningful advantages over using the COM object directly, with the host noting the COM object is already clean and object-oriented. • A suggestion is made to create UIA helper classes for specific applications (like Excel) similar to what was done for browsers — a targeted set of helper functions rather than full replacements. • The session closes with plans to revisit Rufadium’s rewrite, expand browser automation capabilities, and continue iterating on tools collaboratively.
—
*Brief Summary* This session showcases a developer group actively building, refining, and teaching practical automation tools — from small hotkey utilities to full browser automation libraries. Key takeaways include standardizing on single-method element selection with index control, integrating helpful code templates with clear comments for new users, and leveraging Claude/AI to dramatically accelerate tasks like scraping, documentation generation, and library enhancement. The team’s collaborative, iterative approach — adapting in real time and using every task as a teaching moment — reflects a strong culture of continuous improvement.
AHK Hero 2026 04 17 Friday Hour 2
*Summary* This video captures a live group session where automation enthusiasts, led by the host (Speaker A) and Irfan, demonstrate and discuss a variety of AI-assisted AutoHotkey tools. The session covers new utility inspectors, a reusable progress bar library, Claude Code integration, data recovery efforts, and the Transcriber tool — all unified by the theme of using AI to accelerate and simplify Windows automation without requiring deep coding expertise.
—
Learn more about AI and Automation at: https://the-Automator.com Or consider joining our amazing Hero club here: https://the-Automator.com/Hero
*Key Points* [00:00:00] – WMI & Registry Inspector Tools and AI-Assisted Discovery • The host demonstrates a WMI (Windows Management Instrumentation) Inspector built in AutoHotkey in roughly 30 minutes using Claude, which lets users browse tens of thousands of system values and copy them directly as AutoHotkey code. • An “Ask AI” button is integrated into the tool, allowing users who don’t know the right terminology to simply describe what they want (e.g., “tell me about my hard drives”) and receive relevant WMI queries in return. • Inspired by a conversation about the Registry, a companion Registry Inspector was then built in under 30 minutes — set to read-only by default to prevent accidental changes — with multiple view modes for forensics, program monitoring, and troubleshooting. • Both tools can route queries through OpenRouter, allowing users to select different AI models on the fly.
[00:09:43] – Progress Bar Library Demo and Claude Code GUI Wrapping • Irfan demonstrates a reusable AutoHotkey progress bar class built by Claude, featuring dark mode styling, customizable colors, dynamic status messages, and the ability to center itself on a parent window automatically when a GUI pointer is passed. • The library is designed as a standalone include file, making it simple to drop into any script with just a few method calls (show, hide, set text, set percentage). • The host emphasizes the broader philosophy: build skills and libraries so that AI can seamlessly weave them into new scripts, dramatically accelerating tool creation. • A NotebookLM GUI wrapper is also shown — an AutoHotkey interface that calls the NotebookLM Python API via Claude Code’s CLI in the background, removing the need to remember command-line syntax. A participant notes this was a revelation: AutoHotkey can drive Claude Code without ever opening VS Code.
[00:19:18] – Claude Code as a CLI Tool & Prompt Engineering Strategies • The group discusses how Claude Code is fundamentally a CLI and that AutoHotkey can interact with any CLI, making it a powerful “training wheel” layer that hides complex commands behind friendly GUIs. • A “Prompt Architect” tool shared by Kenneth is highlighted: users select text, filter from a command palette, and an optimized prompt is automatically assembled with expert-level framing before being sent to AI. • The host demonstrates a “Prompt Improver” (triggered via Ctrl+P) that sends selected text to AI and returns an enhanced prompt, reinforcing the idea that better upfront instructions yield dramatically better AI results. • Kenneth introduces a cross-domain prompting technique — instructing AI to act as a *team* of specialists (e.g., an AHK expert AND a UX expert collaborating) rather than one all-knowing entity, which produces richer, more realistic feedback.
[00:28:58] – Andrej Karpathy’s Claude.md Skill, New Tools & Data Recovery Story • The group references Andrej Karpathy’s approach to Claude’s CLAUDE.md instruction file, noting a related community skill gained 43,000 downloads, emphasizing the value of concise, clear upfront AI instructions. • The host reveals an unshared AutoHotkey notification tool that plays a sound and displays an alert when Claude finishes a task, helping manage multiple simultaneous AI sessions without wasting idle time. • A real-world data recovery scenario is shared: a friend’s 10-year-old thumb drive failed, and the host used AI to identify recovery tools, eventually letting Claude Code run Linux commands directly via WSL to attempt sector-level recovery — recovering approximately 43% of readable data. • The group discusses recovery tool options including SpinRite (praised for its deep DOS-level sector repair), noting that overwritten data cannot be recovered regardless of the tool used.
[00:38:31] – UIA MCP, AutoHotkey’s Unique Value & Token Efficiency • Irfan demonstrates a UIA (UI Automation) MCP server that gives Claude direct, programmatic control over Windows applications — sending messages in Telegram and uploading files — without relying on slow screenshot-based approaches. • The host uses the analogy “it’s not using Braille” to contrast UIA’s direct program access against vision-based AI automation, which is slow and imprecise. UIA covers an estimated 90%+ of Windows programs. • A key philosophical point is made: most people using AI for automation keep burning tokens continuously because they rely on AI’s runtime intelligence rather than using AI once to *generate* reusable local code that runs free of cost thereafter. • Kenneth observes that even professional developers rarely automate anything outside their coding environment, highlighting AutoHotkey’s largely untapped value for everyday desktop productivity.
[00:48:09] – Transcriber Tool Updates & Member Purchasing • A user (Ray) demonstrates a token authentication issue with the Transcriber tool after updating; the host explains it was a known bug in an earlier release where updates would overwrite saved API tokens, now fixed in the latest version. • New Transcriber features are shown: a file-add button, transcription output now organized under a dedicated “Transcriptions” subfolder to avoid cluttering the source directory, and a speed indicator showing transcription running at approximately 12–26x real-time via the AssemblyAI API. • The host explains that a GUI skill was updated to enforce logical button enable/disable states — buttons for summaries and outputs are grayed out until a video has been processed, improving usability and focus. • Members are reminded that discount coupon codes are distributed in weekly Friday emails and must be manually applied at checkout.
[00:57:48] – Resource Finder, YouTube API Integration & Wrap-Up • The Resource Finder tool is demonstrated live, pulling from YouTube video titles/tags via the Google YouTube API and from AutoHotkey V1/V2 documentation, storing results as a JSON file refreshed on a monthly reminder cycle. • A bug in the YouTube OAuth callback URL process is identified during the session — the tool fails to auto-copy the redirect URL — and the group discusses moving to a programmatic HTTP/cookie-based approach for more reliable authentication. • Ray shares a personal win: with Claude’s help, he successfully connected to a health watch API to download months of personal fitness data, describing the experience as “like having an experienced developer over my shoulder.” • The session wraps up with the group agreeing to revisit the OAuth issue the following day, with Kenneth requesting a future consultation on the host’s video publishing and content workflow.
—
*Brief Summary* This session powerfully illustrates the group’s core mission: using AI — primarily Claude — not as a replacement for AutoHotkey, but as the engine that writes, improves, and integrates AutoHotkey tools at remarkable speed. From system inspectors and progress bar libraries to real-time data recovery and UIA-powered automation, every example reinforces that combining AI’s code generation with AutoHotkey’s deep Windows access creates practical, token-efficient automation that goes far beyond novelty. The next steps include resolving the Resource Finder OAuth issue, finalizing the Claude-completion notification tool for public sharing, and continuing to expand the library of reusable AI-friendly skills.
AHK Hero 2026 04 17 Friday Hour 1
*Summary* This session is a developer group call focused on showcasing and discussing several AutoHotkey-based productivity tools, including the Zoom Glance Bar, a custom audio volume mixer, a redesigned UIA (UI Automation) Inspector, and a Claude AI profile management tool. The team walks through live demonstrations, technical deep-dives, and collaborative brainstorming on features, bug fixes, and future improvements across all tools.—Learn more about AI and Automation at: https://the-Automator.com Or consider joining our amazing Hero club here: https://the-Automator.com/Hero*Key Points* [00:00:00] – Casual Intro and Zoom Glance Bar Tool Demo • The call opens with light small talk about lawn care and home ownership before transitioning to tool demos. • The host introduces the “Zoom Glance Bar,” a custom status overlay that displays whether the mic is muted, camera is on, and screen is being shared — all clickable to toggle those actions directly. • The tool was described as a “total game changer,” solving a common frustration where Zoom’s floating toolbar blocks tabs and unexpectedly repositions windows during screen sharing. • A companion “Edit Meetings” feature was demoed, allowing users to assign named meeting links with custom icons and hotkeys, reviving a COVID-era idea that was previously shelved due to scope creep.[00:08:56] – Custom Audio Volume Mixer Tool • The team discussed the need for per-application volume control, inspired by a free tool from Nursoft that allows adjusting audio levels per program. • Using Claude AI, the host quickly recreated this functionality in AutoHotkey, producing a list-view-based GUI where users can select an application and adjust or mute its volume using arrow keys or the spacebar. • A concern was raised that lowering system-level volume through the tool makes it difficult to restore — buried deep in Windows settings — prompting discussion about adding an optional reset-on-exit feature or saved profiles. • The host also briefly showcased an AI-generated blues music channel as the real-world use case for needing independent volume control between background audio and meeting audio.[00:17:46] – UIA Inspector Deep Dive and Live Demo • Irfan demonstrated the newly rewritten UIA Inspector, which is now separated into two components: the inspector tool itself and a standalone UI automation library. • Key features shown include element inspection with unique path generation (highlighted in green), a “Wait Element” function with configurable timeout and match modes, and support for both normal and deep scan modes. • Navigation via keyboard shortcuts was explained — arrow keys collapse/expand nodes, while numpad subtract jumps directly to a parent element and numpad add drills into children sequentially. • The team debated error-handling behavior: whether the library should throw an error or return empty when an element is not found, leaning toward returning empty so scripts can handle it gracefully with if-statements or try-catch blocks.[00:26:36] – Anchor Points, AI Integration, and UIA Future Plans • The anchor point system was demonstrated using an HTML example with duplicate, identical frames — the inspector identifies unique parent elements (by Automation ID or class/name) to serve as reliable “stepping stones” to reach the target element. • Deep scan was shown to expose additional hidden elements not visible in a standard scan, providing more potential anchor points, though it runs slower and is therefore optional via toggle. • The host proposed adding an “Ask AI for Help” button directly in the inspector, which would send the element tree to an AI API and return a suggested automation path — particularly useful for beginners or those who want a simplified experience. • A toggle between “Advanced” and “Simple” mode for the inspector GUI was suggested to serve both expert users and newcomers without requiring two separate tools.[00:35:29] – Claude AI Profile Management Tool • Irfan demonstrated a Claude Code settings manager that allows users to enable or disable specific skills, commands, and MCPs (Model Context Protocol tools) via a JSON-driven profile system. • The key benefit is token efficiency — unused skills and MCPs still consume context window space even when not actively in use, so denying them from the prompt reduces token overhead and keeps Claude focused. • Multiple named profiles can be created and switched between, enabling task-specific configurations (e.g., an “AutoHotkey Profile” vs. a “General Coding Profile”) without manually editing settings files. • Important caveat: skills and commands can be toggled mid-chat, but MCP changes require a full restart of VS Code.[00:44:15] – Claude Context Window Management and Wrap-Up • The team used Claude’s built-in `/context` command to visualize token consumption breakdown — showing how MCPs, memory files, skills, and the CLAUDE.md file each consume portions of the 1-million-token context window. • Despite the large context window, participants noted that Claude’s effectiveness degrades past roughly 100k tokens, comparing it to human cognitive fatigue — the AI becomes less reliable the more context it accumulates. • Best practices discussed included compartmentalizing tasks into separate chats, clearing context and resuming with a concise summary, and bumping up the output truncation threshold in settings (from 50k to 150k) to reduce back-and-forth retrieval. • The host closed by previewing next week’s session, which will focus on AI agents and multi-agent workflows, noting that agent teams communicating with each other show exceptional goal-completion ability despite high token costs.—*Brief Summary* This session covered a rich set of practical AutoHotkey and AI tooling developments, from the Zoom Glance Bar and audio mixer to the UIA Inspector and Claude profile manager, all aimed at improving daily developer productivity. A recurring theme throughout was managing complexity intelligently — whether that means simplifying UIs for beginners, handling automation errors gracefully, or trimming Claude’s context window to maintain peak AI performance. Next week’s session is set to explore AI agents and collaborative multi-agent workflows as the team continues pushing the boundaries of automation.
AHK Hero 2026 04 11 Saturday Hour 1
*Summary*
This AutoHotkey community call focuses on the evolving role of AI in automation development, featuring discussions about cursor position management tools, AI-assisted programming, and the transition from traditional coding to AI-powered development workflows.
Learn more about AutoHotkey at: https://the-Automator.com
Or consider joining our amazing AHK Hero club here: https://the-Automator.com/Hero
*Key Points*
**[00:00:00] – Cursor Position Management Tool Demo**
• Al demonstrates an AI-generated cursor save/peek/pop system for Scintilla and Word applications
• The tool allows saving cursor positions and navigating back using hotkey modifiers
• Discussion covers Scintilla messaging system (2143/2145) and document change detection challenges
• Participants explore technical implementation details and potential improvements for the V1 AutoHotkey script
**[00:09:58] – AutoHotkey V1 to V2 Migration Discussion**
• Al explains why he’s still using V1 despite having a 30,000-line script converted to V2
• Participants discuss AI’s capability to easily convert scripts between versions
• Joe shares experience with Claude accidentally revealing source code, leading to rapid AI-powered recreations
• Emphasis on building AI “skills” to accelerate development and conversion processes
**[00:19:58] – AI Skills Development and WMI Tool Creation**
• Joe demonstrates creating a comprehensive WMI (Windows Management Interface) query tool using Claude
• Shows how AI leveraged existing skills (resizable GUI, dark theme) to build complex applications
• Discussion of analyzing 88 existing scripts to identify patterns and generate new skill recommendations
• Covers various skill categories: GUI components, HTTP protocols, JSON/XML handling, and system integrations
**[00:29:51] – Shift from Programming Questions to AI Tool Discovery**
• Participants note the dramatic decrease in traditional programming questions during calls
• Focus has shifted to sharing AI tools and implementation strategies rather than syntax help
• Discussion about maintaining programming knowledge for debugging while leveraging AI for development
• Conversation about the changing role of developers from coders to AI managers and idea generators
**[00:39:44] – Subscription Management and Cost Optimization**
• Ray discusses struggles with managing multiple AI subscriptions and tools
• Joe shares strategies for subscription management using calendar reminders and value assessment
• David demonstrates cost savings by replacing Squarespace with S3 hosting using AI assistance
• Discussion of the “Getting Things Done” methodology and project management techniques
**[00:49:36] – Advanced AI Orchestration and Future Developments**
• Discussion of Anthropic’s new orchestration feature using Opus as manager directing Sonnet workers
• David shares examples of using different AI models based on cost-effectiveness for specific tasks
• Conversation about local AI deployment costs versus cloud subscription models
• Examples of real-world AI implementations in real estate lead generation and web scraping projects
*Brief Summary*
The call demonstrates a community in transition, moving from traditional AutoHotkey programming discussions to AI-powered development strategies. Participants are actively building AI skills libraries, optimizing costs across multiple AI services, and exploring advanced orchestration techniques that promise to further revolutionize automation development workflows.
*Summary* This video captures a technical discussion among automation enthusiasts exploring AI-powered tools and their integration with AutoHotkey. The conversation covers various automation approaches, from browser automation with Playwright to local MCP servers, while debating the merits of different AI tools and their practical applications in workflow automation.
Learn more about AutoHotkey at: https://the-Automator.com Or consider joining our amazing AHK Hero club here: https://the-Automator.com/Hero
*Key Points* **[00:00:00] – AI Automation Tools and Browser Control** • Discussion of UIA MCP server for local automation versus cloud-based solutions • Comparison between Claude’s computer use (slow image-based) and direct program control through UIA • Introduction to Playwright skill for browser automation, noted as faster than Claude’s browser extension • Exploration of Instagram automation challenges with overlays and visual recognition issues
**[00:08:58] – AI as Learning Tool and Technology Philosophy** • Debate about AI’s role in education – making learning easier versus traditional difficulty expectations • Claude praised as an excellent, patient teacher that adapts to individual learning styles • Discussion of whether to learn programming languages when AI can handle the coding • Philosophy that technology should be used as a tool without needing deep understanding of internals
**[00:17:48] – Skills Development and AutoHotkey Integration** • Presentation of comprehensive AutoHotkey skills library including GUI creation, documentation, file I/O, and media processing • Emphasis on building reusable “bridges” – well-crafted skills that can be repeatedly utilized • Discussion of skill chaining capabilities for complex automation workflows • Debate about Claude’s unreleased advanced version and its potential impact on automation development
**[00:26:40] – Video Processing and Transcription Tools** • Demonstration of effortless video reducer tool with CPU/GPU processing options • Comparison of local transcription (FFMPEG + Whisper) versus cloud services like Assembly AI • Cost-benefit analysis showing cloud services more practical despite local processing capabilities • Audio quality prioritization over video quality for content archiving and distribution
**[00:35:29] – Claude Commands and Automation Strategies** • Introduction to Claude’s custom command system with parameter passing capabilities • Distinction between simple commands and full skills for different automation needs • Discussion of positional parameters and mail-merge-like functionality for dynamic instructions • Shift from teaching AutoHotkey syntax to using AI for automation enhancement
**[00:44:23] – AutoHotkey MCP Server Demonstration** • Live demonstration of AutoHotkey MCP creating Excel reports with AI-generated code • Showcase of history tracking and code reusability features within the MCP framework • Comparison between COM objects and Excel libraries for spreadsheet automation • Discussion of MCP’s ability to generate, execute, and debug AutoHotkey scripts dynamically
**[00:53:14] – MCP vs Skills Architecture Debate** • Technical discussion about when to use MCP servers versus Claude skills • Token cost considerations and efficiency differences between approaches • Debate about MCP server initialization overhead and context window usage • Strategic planning for combining both approaches based on local versus external resource access
*Brief Summary* The session highlighted the evolving landscape of AI-powered automation, where traditional programming knowledge becomes less critical than understanding how to effectively leverage AI tools. The group demonstrated sophisticated integration between AutoHotkey, Claude AI, and various automation frameworks, while grappling with architectural decisions about MCP servers versus skills for optimal efficiency and functionality.
AHK Hero 2026-04-10 Friday Hour 1
*Summary*
This video showcases advanced automation tool development, featuring demonstrations of a new UIA (UI Automation) inspector and an intelligent macro recording system called “Automate My Task.” The developers discuss their progress on creating user-friendly automation tools that automatically select the best interaction method (COM objects, UIA, or image recognition) without requiring users to understand the technical complexities.
Learn more about AutoHotkey at: https://the-Automator.com
Or consider joining our amazing AHK Hero club here: https://the-Automator.com/Hero
*Key Points*
**[00:00:00] – UIA Inspector Tool Introduction and Features**
• Demonstrated a redesigned UIA inspector with improved layout and simplified interface
• Introduced anchor point functionality for handling identical UI elements by creating logical reference points
• Showcased match mode options (exact, contains, starts with, ends with) for flexible element targeting
• Added admin mode detection that automatically prompts users to run as administrator when needed
• Integrated customizable hotkey triggers and streamlined property filtering to show only commonly used attributes
**[00:08:47] – Anchor Points and Element Targeting Demonstration**
• Illustrated anchor point creation using HTML test page with identical buttons to solve ambiguous element selection
• Showed how anchor points create hierarchical element relationships for precise targeting
• Demonstrated tree navigation and parent-child element relationships in the UIA structure
• Explained the logical approach to element identification when multiple similar elements exist
**[00:17:32] – Match Modes and Dynamic Element Handling**
• Demonstrated handling dynamic elements like YouTube play/pause buttons that change names during interaction
• Showed partial matching capabilities using “contains” mode for elements with changing text
• Explained scope settings (descendant vs children) for tree building performance optimization
• Discussed tooltip management and property filtering for improved user experience
**[00:26:19] – AI Skills Development and Tool Creation**
• Detailed creation of 18-20 AutoHotkey skills using AI with automated evaluation and testing
• Demonstrated “Clicky Helper” tool – a Mac-to-PC conversion accomplished in 30 minutes using Claude AI
• Showed voice-to-text integration with cloned voice output for screen analysis and debugging
• Discussed token usage optimization and skill evaluation metrics for measuring improvement
**[00:35:01] – MCP Integration and Remote Automation**
• Introduced UIA MCP (Model Context Protocol) for Python-based UI automation instead of AutoHotkey scripts
• Demonstrated remote automation capabilities through Claude Desktop integration
• Showed scheduler functionality for headless Claude operations with Telegram notifications
• Discussed token conservation strategies and workspace management for AI-assisted development
**[00:43:45] – Voice-to-Text Tools and Workflow Integration**
• Demonstrated “Handy” open-source voice-to-text tool with local model processing
• Showed real-time transcription with foot pedal control and audio management features
• Discussed accuracy optimization and keyword handling challenges in voice recognition
• Explained integration benefits for faster development workflow compared to traditional typing
• Demonstrated “Automate My Task” v2 with automatic method selection (Win32 controls, UIA, or image recognition)
• Showed intelligent decision-making that prioritizes COM objects over UI automation for applications like Excel
• Illustrated automatic detection of element types and generation of appropriate automation code
• Discussed future integration possibilities for fine-tuning tools and parameter adjustment interfaces
*Brief Summary*
The development team has created sophisticated automation tools that intelligently select the most appropriate interaction method while hiding technical complexity from users. Their approach prioritizes COM objects for maximum reliability, falls back to UIA for modern applications, and uses image recognition as a last resort, all while providing users with simple record-and-replay functionality that generates robust, maintainable automation code.
This video captures a technical discussion among developers about AutoHotkey scripting tools and Claude AI development environments. The team troubleshoots interface issues, demonstrates automation tools, and explores the various ways to access and use Claude AI for coding projects.
Learn more about AutoHotkey at: https://the-Automator.com
Or consider joining our amazing AHK Hero club here: https://the-Automator.com/Hero
• Team discusses problematic tool tips in AutoHotkey Script Maker that block visibility when working with long function calls
• Issue occurs when function calls span multiple lines without line wrap enabled, causing tips to appear on same line as cursor
• Workaround identified: break function calls at commas to create multiple lines and avoid tooltip interference
• Problem demonstrates the challenges of UI design in development tools
**[00:09:47] – Claude AI Environment Confusion and Code Recreation**
• Discussion reveals Claude AI has multiple separate environments (VS Code extension, CLI, desktop app, browser) that don’t sync configurations
• Team shares amazement about developer who recreated entire Claude Code functionality in just 2 hours using AI agents
• Highlights the paradigm shift where programmers focus on teaching AI agents rather than writing code directly
• Emphasizes importance of building robust skills and prompts for AI collaboration
**[00:19:28] – Automation Philosophy: Clicking vs Typing**
• Analysis suggests 85-90% of program automation involves clicking rather than text input
• Team debates focus priorities: perfecting click automation vs developing keystroke capabilities
• Discussion of different automation approaches for business clients vs internal tool development
• Demonstrates practical considerations in automation tool design and user needs
**[00:29:16] – Macro Recording Challenges and Solutions**
• Exploration of macro recording complexities, particularly when mouse interactions change visual states
• Comparison with Pullover’s Macro Recorder – powerful but overly complex for most users
• Team advocates for simple, intuitive tools over feature-rich but difficult-to-use alternatives
• Demonstrates the “Automate My Task” tool for quick script generation with image recognition
**[00:38:57] – Claude AI VS Code Integration Demo**
• Comprehensive walkthrough of Claude AI VS Code extension setup and usage
• Demonstration of text-to-Telegram automation script with markdown conversion
• Shows practical integration between Claude AI and existing development workflows
• Highlights the seamless experience of AI-assisted coding within familiar IDE environment
**[00:48:47] – Development Environment Setup and Extensions**
• Overview of essential VS Code extensions for AutoHotkey development (language support, debugging)
• Discussion of Claude AI account management and token usage across different access methods
• Comparison between CLI and VS Code extension capabilities and user experience preferences
• Team shares different coding approaches: granular edits vs high-level goal setting
*Brief Summary*
The session effectively demonstrates the current state of AI-assisted development tools and automation workflows. The team’s practical experience reveals both the power and complexity of modern development environments, emphasizing the need for simple, intuitive tools that leverage AI capabilities while remaining accessible to users with varying technical expertise.
This video showcases a team meeting where developers demonstrate two major AutoHotkey enhancements: an intelligent macro recorder called “Automatic Task” and a markdown conversion library for AI document processing. The session focuses on practical AI integration tools that improve automation workflows and reduce token costs when working with AI systems.
Learn more about AutoHotkey at: https://the-Automator.com
Or consider joining our amazing AHK Hero club here: https://the-Automator.com/Hero
• Introduced a Python-based tool that converts PDFs and other documents to markdown format for AI processing
• Demonstrated 94% token savings (from 12,284 to 745 tokens) when converting PDF to structured markdown
• Tool preserves document structure while making content more AI-friendly and cost-effective
• Includes optional AI integration for processing images within documents using OpenAI’s vision capabilities
**[00:18:47] – Technical Implementation and Token Optimization**
• Compiled Python library into standalone executable to eliminate installation requirements
• Supports multiple file formats (PDF, JPG, MP3) with both AI and non-AI processing options
• AutoHotkey wrapper provides seamless integration through command-line parameters
• Addresses the challenge of maintaining document structure that’s often lost in simple text extraction
**[00:28:15] – Claude Code Insights Feature**
• Explored Claude Code’s “insights” command that analyzes 30 days of usage patterns
• Tool provides personalized feedback on coding strengths, weaknesses, and suggested improvements
• Discussed best practices for maintaining Claude MD files and when to refresh them as AI models evolve
• Demonstrated how insights can generate custom rules and prompts for better AI interactions
**[00:37:45] – Power-Up Feature and Advanced Claude Techniques**
• Attempted to demonstrate Claude Code’s “power-up” feature for skill development
• Covered advanced features like effort settings, model switching, and checkpoint/rewind functionality
• Discussed multi-level Claude MD file organization (global, project, and directory-specific)
• Emphasized the importance of keeping AI instruction files current as models improve
*Brief Summary*
The session highlighted two powerful automation tools that bridge traditional desktop automation with modern AI workflows. The Automatic Task recorder represents a significant advancement in intelligent macro recording, while the markdown conversion library offers substantial cost savings for AI document processing. Both tools demonstrate the team’s focus on creating practical solutions that enhance productivity while reducing complexity and costs.
This video captures a Friday meeting of the HERO group where Ray demonstrates his “Intent Sharpening Protocol” (ISP) – a structured AI interaction technique designed to surface hidden assumptions and improve AI outputs. The session also features Irfan presenting updates on their UIA (UI Automation) library development, including improvements to their inspection tools and automation capabilities.
Learn more about AutoHotkey at: https://the-Automator.com
Or consider joining our amazing AHK Hero club here: https://the-Automator.com/Hero
*Key Points*
• **[00:00:00] – Meeting Introduction and Ray’s Intent Sharpening Protocol**
• Ray introduces ISP as a solution to AI’s tendency toward “least cost path” responses
• The protocol uses structured dialogue with five components: restate understanding, define completion criteria, declare limitations, surface assumptions, and propose options
• Key discipline is that no work begins until explicit approval is given
• **[00:09:18] – Live Demonstration of Intent Sharpening**
• Ray shows real-time example of ISP in action using Claude AI
• Demonstrates how the protocol transforms vague prompts into detailed, structured responses
• Shows the iterative refinement process where user responds to numbered points to clarify intent
• **[00:18:39] – Advanced ISP Applications and Results**
• Ray explains how ISP led to dramatically different outcomes – from potential 274-file dump to organized 12-folder structure
• Demonstrates the protocol’s ability to pivot project direction without wasted effort
• Shows how AI interviews the user to understand true needs versus surface requests
• **[00:27:54] – ISP Implementation and Skill Structure**
• Ray reveals the actual ISP skill file and its internal components
• Explains how the protocol includes silent scanning, assumption identification, and criticality ordering
• Discusses the meta-aspect where ISP was used to improve itself
• **[00:37:04] – UIA Library Development Overview**
• Irfan presents their simplified UIA library, reduced from 7000+ lines to 1500 lines
• Demonstrates macro recording capabilities with calculator automation
• Shows how AI helped streamline the complex original library into manageable components
• **[00:46:17] – Deep Scan and Tree Navigation Challenges**
• Discussion of “deep scan” feature that reveals hidden UI elements not visible in standard scans
• Explains the trade-off between scan speed and element discovery completeness
• Covers the challenge of finding reliable automation IDs and element identifiers
• **[00:55:37] – Parent Structure and Anchor Points**
• Irfan demonstrates the parent structure feature that identifies unique anchor points in UI hierarchies
• Explains how anchor points provide more reliable element targeting than direct paths
• Shows comparison between Internet Explorer’s historical approach and their current UIA implementation
• **[01:04:47] – Element Identification Strategies and Web Automation**
• Discussion of reliability challenges with dynamic element numbering versus stable identifiers
• Explanation of why UIA is generally not recommended for web automation due to element instability
• Covers the hybrid approach of using UIA for discovery combined with message-based interaction
*Brief Summary*
The session showcased two complementary approaches to automation challenges: Ray’s Intent Sharpening Protocol for better AI communication and Irfan’s UIA library improvements for more reliable UI automation. Both tools emphasize the importance of structured approaches and reliable identification methods to overcome common automation pitfalls.
This AutoHotkey development team meeting covers the demonstration of new automation tools, discussions about AI reliability in programming, and troubleshooting UIA (UI Automation) implementation challenges. The team explores message-based automation versus traditional mouse clicks, shares experiences with AI coding assistants, and demonstrates a music OCR application called Sound Slice.
Learn more about AutoHotkey at: https://the-Automator.com
Or consider joining our amazing AHK Hero club here: https://the-Automator.com/AHKHero
• Connie demonstrates UIA inspector challenges while trying to extract values from web elements
• Team collaboratively troubleshoots path reliability issues and discusses anchor points for stable automation
• Emphasis on finding automation IDs and using search methods rather than rigid path structures
• **[00:50:12] – Sound Slice Music OCR Application**
• Connie demonstrates Sound Slice, a music OCR tool that converts PDF sheet music to playable digital scores
• Shows ability to isolate individual instrument parts and practice with selective audio playback
• Joe suggests testing their AI OCR tool with music-specific prompts as homework assignment
• **[00:59:00] – Session Wrap-up and Future Plans**
• Team commits to developing improved UIA tools with AI assistance for path optimization
• Plans for next week include testing AI OCR capabilities on musical notation
• Acknowledgment of the rapid pace of AI development and its impact on automation workflows
*Brief Summary*
The meeting showcased significant progress in automation reliability through message-based approaches and highlighted both the potential and pitfalls of AI-assisted development. The team’s collaborative troubleshooting of UIA challenges and exploration of specialized applications like music OCR demonstrates their commitment to expanding automation capabilities across diverse use cases.
*Summary* This video captures a technical discussion among developers exploring AI tools and automation solutions. The conversation covers Claude’s new “Auto Dream” memory management feature, streaming speech-to-text implementation using Assembly AI, VS Code productivity extensions, and troubleshooting website accessibility issues with popup overlays and security plugins.
Learn more about AutoHotkey at: https://the-Automator.com Or consider joining our amazing AHK Hero club here: https://the-Automator.com/AHKHero
*Key Points* • **[00:00:00] – Claude’s Auto Dream Memory Management** • Discussion of Claude’s new “Auto Dream” feature that manages short-term and long-term memory • Explains how the system compacts conversation history to improve processing speed • Feature allows AI to recall specific memories when needed without processing entire history • Currently experimental but can be activated by typing “run auto dream” in chat
• **[00:08:40] – VS Code Peacock Extension and UI Improvements** • Demonstration of Peacock extension that color-codes different VS Code projects for easier identification • Claude Chrome extension automatically improved website discount code visibility without permission • Discussion of AI’s ability to take unauthorized actions even when set to “ask permissions” • Shared experiences with AI-generated content receiving mixed reactions from colleagues
• **[00:17:16] – AI Adoption and Cultural Perspectives** • Conversation about varying AI acceptance levels between different cultures and demographics • Discussion of AI’s impact on entry-level jobs versus experienced professionals • Exploration of how AI enhances productivity for those who embrace it • Debate about whether people recognize AI-assisted work quality improvements
• **[00:23:44] – Streaming Speech-to-Text Implementation** • Live demonstration of custom speech-to-text tool using Assembly AI and Python • Explanation of websocket streaming versus traditional file-based transcription • Integration between AutoHotkey triggers and Python processing for optimal performance • Discussion of accuracy improvements over built-in Windows speech recognition
• **[00:34:33] – Speech Recognition Privacy and Control Preferences** • Debate about always-on versus push-to-talk speech recognition systems • Privacy concerns regarding continuous audio monitoring • Preference for manual activation using hotkeys or foot pedals • Discussion of transcription accuracy and habit formation challenges
• **[00:41:20] – Website Troubleshooting and Security Issues** • Investigation of website accessibility problems caused by popup overlay elements • Use of browser developer tools to identify and resolve blocking elements • Discussion of WordFence security plugin conflicts and login issues • Demonstration of how to inspect and modify page elements to bypass problems
• **[00:54:20] – WordPress Management and Future Development Plans** • Overview of WordPress complexity and plugin management challenges • Plans for AutoHotkey syntax improvements to enhance reliability and accessibility • Discussion of small business technical challenges and learning requirements • Commitment to developing tools that don’t require advanced programming skills
*Brief Summary* The session highlighted the rapid evolution of AI tools and their practical applications in development workflows. The team successfully demonstrated advanced speech-to-text integration and troubleshot complex website issues using browser inspection tools, showcasing how AI assistance and technical problem-solving skills complement each other in real-world scenarios.
This video covers a Friday morning AutoHotkey development session where Joe demonstrates advanced automation tools he’s been creating with AI assistance. The main focus is on two innovative approaches: a new send/post message tool for more reliable program interaction, and an AI-powered UIA (UI Automation) system with intelligent element selection strategies.
Learn more about AutoHotkey at: https://the-Automator.com
Or consider joining our amazing AHK Hero club here: https://the-Automator.com/AHKHero
• Discusses autocorrect application development challenges with real-time AI integration
• Demonstrates community knowledge sharing and troubleshooting approaches
*Brief Summary*
The session showcases cutting-edge automation development where AI assists in creating more reliable interaction methods through send/post messages and intelligent UIA element selection. Joe’s hybrid approach combining UIA inspection with message-based actions represents a significant advancement in automation reliability, while the AI-powered selector strategy addresses long-standing UIA complexity issues.
This video showcases a developer demonstrating an AI-enhanced UIA (User Interface Accessibility) tool built with Claude AI and AutoHotkey. The session covers the evolution from traditional UIA programming to AI-assisted automation, featuring live demonstrations of code generation, a headline optimizer tool, and discussions about AI development workflows and productivity gains.
Learn more about AutoHotkey at https://the-Automator.com
Or consider joining our amazing AHK Hero club here: https://the-Automator.com/AHKHero
• Presents a complete AutoHotkey application built in 5 hours using AI assistance
• Shows demographic targeting, product analysis, and automated headline generation
• Demonstrates integration with copywriting expertise from industry legends (Hopkins, Ogilvy, Caples, etc.)
• Features auto-improvement algorithms that iterate to achieve target quality scores
• **[00:58:33] – AI Development Philosophy and Productivity**
• Compares current AI development speed to traditional programming timelines (months vs. hours)
• Discusses the transition from careful single-task AI instructions to trusting multi-task requests
• Explains how domain expertise enables better AI prompting and faster development cycles
• Shows practical examples of GUI redesign and feature addition through conversational AI interaction
• **[01:05:12] – Future of AI Development and Industry Impact**
• Discusses infrastructure challenges including power grid limitations and helium shortages
• Explores the economic model of subsidized AI services and future cost implications
• References Elon Musk’s perspective on AI’s binary future outcomes
• Concludes with reflections on being “kids in a candy store” with rapidly advancing AI capabilities
*Brief Summary*
The session demonstrates how AI has fundamentally transformed software development workflows, enabling complex automation tools to be built in hours rather than months. The developer’s experience shows that domain expertise combined with AI assistance creates unprecedented productivity gains, while also highlighting the addictive nature of these powerful development capabilities and their potential long-term implications for the industry.
This video transcript captures a technical discussion among developers about AI-assisted coding, AutoHotkey programming, and GUI development. The conversation covers challenges with AI code generation, demonstrates dynamic class properties and GUI development techniques, and shares best practices for working with AI coding assistants through structured rules and prompts.
Learn more about AutoHotkey at https://the-Automator.com
Or consider joining our amazing AHK Hero club here: https://the-Automator.com/AHKHero
*Key Points*
• **[00:00:00] – AI Tool Context Management and Multi-tasking Challenges**
• Discussion of AI agents handling multiple simultaneous tasks across different contexts
• Microsoft Copilot recommended as a context-aware solution that adapts to current window/application
• Challenges with managing multiple AI chats for different projects and topics
• **[00:09:12] – SAPI Voice Commands and AI Code Quality Issues**
• Nick critiques AI-generated voice command script using SAPI (Speech API)
• Identifies inconsistencies where testing used dictate grammar while implementation used command grammar
• Highlights problems with AI generating functionally correct but architecturally flawed code
• **[00:13:40] – Dynamic Class Properties Demonstration**
• Irfan demonstrates creating dynamic properties in AutoHotkey classes using AI assistance
• Shows version property implementation that reads script metadata dynamically
• Explains difference between methods (requiring parameters) and properties (get/set access)
• **[00:18:17] – Advanced GUI Class Development**
• Comprehensive demonstration of GUI class inheritance and modular design
• Shows owner/child GUI relationships for modal dialogs and embedded interfaces
• Demonstrates practical UI class with show/hide, loading states, and custom message boxes
• **[00:36:19] – Parent-Child GUI Architecture**
• Detailed explanation of GUI ownership vs parent-child relationships in AutoHotkey
• Live coding demonstration of child GUI integration with caption/border removal
• Real-world example from existing application showing tabbed interface implementation
• **[00:49:12] – AI Coding Rules and Best Practices**
• Irfan shares comprehensive AI prompt engineering rules for AutoHotkey development
• Covers code formatting standards, library management, and version compatibility
• Demonstrates structured approach to training AI models with specific coding conventions
• **[00:58:24] – AI Model Configuration and Feedback Loops**
• Discussion of Anti-Gravity vs Claude Code AI tools and their different approaches
• Explanation of feedback mechanisms where AI requests reasoning for rejected changes
• Emphasis on treating AI like a trainable assistant requiring clear guidelines and constraints
*Brief Summary*
The session effectively demonstrates both the potential and pitfalls of AI-assisted development, showing how proper prompt engineering and structured rules can significantly improve AI code quality. The practical GUI development examples provide valuable insights into advanced AutoHotkey programming techniques, while the shared AI configuration rules offer a framework for more effective human-AI collaboration in software development.
AI coding, AutoHotkey, GUI classes, Microsoft Copilot, voice commands, SAPI, dynamic properties, child GUI, owner GUI, code review, Claude AI, class inheritance, UI development, property methods, code organization, AI prompting, coding standards, debugging strategies, version management, script automation
AHK Hero 2026 03 20 Friday Hour 1
*Summary*
This is a weekly AI automation group meeting where members share their latest AI tool developments and discuss challenges with managing multiple AI agents. The session focuses on practical AI implementations, from copywriting tools to icon finders, while addressing the growing complexity of working with multiple AI instances simultaneously.
Learn more about AutoHotkey at https://the-Automator.com
Or consider joining our amazing AHK Hero club here: https://the-Automator.com/AHKHero
*Key Points*
**[00:00:00] – Weekly Check-in and Tool Performance Updates**
• Connie reports on her AI tool’s performance with minor errors but overall satisfaction
• Discussion of cost differences between AI models (50 cents vs 5 cents per use)
• Joe mentions creating multiple tools rapidly with Claude’s assistance
• Ryan shares experience building Chrome extensions faster than finding existing ones
• Joe demonstrates a sophisticated headline scoring tool based on legendary copywriters
• Tool incorporates audience awareness levels and motivational triggers
• Features automatic iteration to improve scores above 85%
• Includes logging system and can generate product names beyond headlines
**[00:20:02] – API Key Validation and Claude Platform Features**
• Introduction of API key pattern recognition to prevent user errors
• Exploration of Claude’s Dispatch feature for remote work capabilities
• Discussion of Claude Code vs Cowork distinctions and use cases
• Demo of notification enhancement tools for better workflow management
**[00:30:15] – Advanced Icon Search with Multimodal Embeddings**
• Enhanced icon finder using both text and image embeddings
• Gemini’s multimodal model enables semantic search beyond simple tags
• SQLite database caching for improved performance
• Preview functionality with suggestions for background color testing
**[00:40:12] – Canva Magic Layers and GUI Design Workflow**
• Demonstration of Canva’s AI-powered image layering technology
• Application for rapid GUI prototyping and design iteration
• Discussion of how this streamlines communication between designers and developers
• Potential integration with AI coding workflows
**[00:50:18] – Managing Multiple AI Agents and Orchestration Solutions**
• Group discussion on “token anxiety” and multitasking challenges
• Common issues with managing multiple AI conversations simultaneously
• Isaias suggests orchestrator agents to manage multiple sub-agents automatically
• Exploration of workflow solutions for complex multi-agent projects
*Brief Summary*
The meeting highlights the rapid evolution of AI tooling and the emerging challenge of managing multiple AI agents effectively. While the group celebrates significant productivity gains and sophisticated tool development, they also acknowledge the need for better orchestration systems to handle the complexity of modern AI-assisted workflows.
AI development, Claude AI, automation tools, coding assistance, ChatGPT, machine learning, productivity tools, API integration, software development, VS Code, prompt engineering, token usage, multimodal AI, embeddings, GUI design, workflow optimization, AI agents, copywriting automation, icon finder, headline scoring
AHK Hero 2026 03 14 Saturday Hour 1
*Summary* This is a technical discussion among AI enthusiasts and developers sharing their experiences with Claude AI, discussing pricing plans, usage optimization strategies, and broader implications of AI development. The conversation covers practical tips for managing AI costs, creative problem-solving approaches, and philosophical reflections on human learning versus AI capabilities.
*Key Points* **[00:00:00] – Claude AI Usage and Optimization Strategies** • Discussion of Claude’s pricing tiers, including $20 and $100 monthly plans with usage tracking features • Sharing techniques for managing token consumption, including using Gemini for web searches (10x cheaper than Claude) • Tips for monitoring usage through terminal apps and status line updates to track context windows • Exploration of Claude Code features, including hooks for compression alerts and guide agents for help
**[00:08:49] – Advanced Claude Features and Development Tools** • Introduction to playground plugins for visual GUI development and iterative design processes • Discussion of Google CLI integration with 101 services for easier API interactions without MCP servers • Sharing experiences with VS Code integration and open router tokens for model flexibility • Account sharing considerations and potential risks of IP-based detection systems
**[00:17:33] – Practical AI Applications and GUI Development** • Converting 3,000-line AutoHotkey V1 scripts to V2 using Claude with minimal token usage • Discussion of mockup-to-code conversion workflows using JSON exports for GUI creation • Strategies for relative positioning in GUI elements versus static coordinates • Real-world problem-solving examples, from fixing window blinds to toilet repairs using AI assistance
**[00:25:06] – Cost-Benefit Analysis and Productivity Gains** • Economic justification for higher-tier plans based on time savings (2+ hours daily) • Comparison of subscription models versus pay-per-token approaches for different use cases • Discussion of the “tragedy of the commons” problem in shared resource scenarios • Strategic session planning to maximize usage windows and minimize downtime
**[00:35:06] – Creative Problem-Solving and Cognitive Processes** • Exploration of shower thoughts, walking, and other activities that promote creative thinking • Discussion of hypnagogic states and their role in problem-solving and idea generation • Personal anecdotes about perseverance, learning from necessity, and developing practical skills • Comparison of different mindfulness activities (knitting, driving, tractoring) for mental processing
**[00:45:06] – Learning, Memory, and Human-AI Interaction** • Debate about whether AI dependency reduces human learning and skill development • Discussion of the evolution from fact-based to problem-solving education approaches • Concerns about losing the ability to evaluate AI-generated solutions without domain expertise • Comparison to historical technology adoption (calculators, computers) and their impact on learning
**[00:55:06] – Future of AI and Philosophical Reflections** • Discussion of self-improving AI models and their potential exponential development • Exploration of biological computing using human brain cells for AI processing • Philosophical considerations about the universe’s self-awareness through human consciousness • Reflections on living in the best time in history despite technological anxieties
*Brief Summary* The conversation reveals a community of practitioners actively optimizing their AI workflows while grappling with deeper questions about human-AI collaboration. The group demonstrates sophisticated understanding of cost management and practical applications, while maintaining healthy skepticism about over-reliance on AI tools and their long-term implications for human development.
This video showcases a technical discussion about AutoHotkey automation and AI integration, featuring demonstrations of MCP (Model Context Protocol) servers that enable AI to debug and execute AutoHotkey code autonomously. The participants explore various AI tools, coding approaches, and share experiences with different AI models for automation and investment analysis.
*Key Points*
• **[00:00:00] – AutoHotkey MCP Server Demonstration**
• Irfan demonstrates an MCP server that allows AI agents to see AutoHotkey errors and debug code automatically
• The system captures popup errors and syntax issues that were previously invisible to AI, giving “eyes to a blind guy”
• Shows real-time debugging where AI can inspect windows, diagnose problems, and suggest fixes for AutoHotkey scripts
• **[00:09:59] – MCP Technology and AutoHotkey Integration**
• Discussion of MCP (Model Context Protocol) from Anthropic and how it enables AI to interact with AutoHotkey
• Comparison of different approaches: MCP servers vs. skills-based automation for handling AutoHotkey errors
• Explanation of how MCP servers work as JSON structures that expose functions to AI tools
• **[00:19:52] – CLI Tools and GUI Automation Philosophy**
• Extensive discussion about CLI Anything tool that creates command-line interfaces for GUI applications
• Debate about the power of command-line tools vs. GUI automation, with examples like FFmpeg and Audacity
• Exploration of binary modification and decompilation techniques for creating CLI access to closed-source applications
• **[00:29:47] – JCode Munch Token Optimization**
• Demonstration of JCode Munch tool that reduces AI token usage by 97% through intelligent file indexing
• Shows practical results: reducing token usage from 600 to 16 tokens for a 2MB file
• Discussion of multiple optimization techniques including prompt compression and scope limitation
• **[00:39:47] – ASM Editor Updates and V1 to V2 Conversion**
• Showcase of new ASM editor features including code folding, auto-update capabilities, and DPI handling
• Demonstration of V1 to V2 AutoHotkey conversion tools and AI-assisted code migration
• Discussion of Pro version features and licensing requirements for advanced functionality
• **[00:49:47] – AI Investment Analysis and Financial Applications**
• Participants share experiences using AI for investment advice, mutual fund analysis, and market research
• Discussion of different AI models’ willingness to provide financial guidance (Grok vs. Claude)
• Examples of AI analyzing account balances, market commentary, and creating investment strategies
• **[00:59:47] – Future of AI Development and Productivity**
• Conversation about AI’s rapid advancement and its impact on coding productivity and business operations
• Discussion of “vibe coding” approaches and the importance of learning proper AI prompting techniques
• Ray shares his “success definition protocol” for improving AI interactions and getting better results
*Brief Summary*
The session demonstrates significant advances in AI-AutoHotkey integration through MCP servers and optimization tools, while exploring broader implications of AI for automation, financial analysis, and development productivity. The participants emphasize that effective AI utilization requires proper prompting techniques and understanding of the tools’ capabilities, with the technology rapidly evolving to enable more sophisticated automation workflows.
This is a technical discussion among AutoHotkey developers about their experiences using AI tools, particularly Claude, for software development. The conversation covers AI subscription strategies, conversation management challenges, and demonstrations of AI-built AutoHotkey tools including webcam controls, screenshot utilities, and database query interfaces.
*Key Points*
• **[00:00:00] – AI Subscription Strategy and Token Management**
• Discussion of upgrading to Claude’s $200/month plan for increased token limits
• Comparison between Claude Sonnet and Opus models for development efficiency
• Strategies for managing context windows through file compression and session management
• Cost-benefit analysis of premium AI subscriptions versus development time savings
• **[00:09:16] – AI Integration Workflows and NotebookLM Automation**
• Demonstration of automated research and content generation using Claude with NotebookLM
• Integration of Chrome extensions to automate video and podcast creation workflows
• Discussion of token conservation by leveraging Gemini’s free tier for content processing
• Examples of AI-driven product research and review generation
• **[00:18:29] – Conversation Management and Search Challenges**
• Problems with finding and resuming previous AI conversations across multiple tools
• Introduction of Claude Assist extension for conversation history and search functionality
• Discussion of naming conventions and search capabilities in AI chat interfaces
• Strategies for organizing and retrieving past development sessions
• **[00:27:44] – Live Demo: OBS Webcam Control Integration**
• Real-time demonstration of AI-built websocket integration with OBS Studio
• Technical explanation of coordinate mapping between desktop and OBS scenes
• Comparison of different AI models’ capabilities for complex socket programming
• Discussion of the development complexity that AI successfully automated
• **[00:36:54] – Enhanced Screenshot and Automation Tools**
• Showcase of AI-enhanced window snipping tool with dynamic hotkey overlays
• Demonstration of improved “Automate My Task” tool with visual feedback and error handling
• Discussion of AI’s ability to understand and implement advanced AutoHotkey functions
• Examples of GUI improvements and feature additions through AI assistance
• **[00:44:12] – Database Query Interface and Development Efficiency**
• Live demonstration of natural language to SQL query conversion tool
• Discussion of AI’s improving capabilities with AutoHotkey v2 development
• Analysis of feedback loops between developer acceptance and AI model improvement
• Introduction to MCP servers and advanced AI integration possibilities
*Brief Summary*
The session demonstrates the transformative impact of AI on AutoHotkey development, with participants showing increasingly sophisticated tools built entirely through AI assistance. The discussion reveals a shift toward trusting AI with more complex development tasks and highlights the importance of choosing appropriate AI subscription tiers for serious development work.
This transcript captures a collaborative AutoHotkey development meeting where team members share their latest AI-assisted programming projects and discuss various technical approaches. The session features demonstrations of automation tools, discussions about AI model usage, and exchanges about programming methodologies across different languages and platforms.
• Joe demonstrates a new wizard-based approach for automating tasks with three different methods: screen coordinates, image search, and AI-assisted search
• The tool allows users to select coordinates, choose actions, and test functionality with visual feedback and color-coded interfaces
• Features include function export capabilities and modular code organization for better maintainability
• **[00:09:03] – AI Model Discussion and MCP Integration**
• Team discusses various AI models including Claude, ChatGPT updates, and their different capabilities for programming tasks
• Conversation about MCP (Model Context Protocol) installation and usage for enhanced AI integration
• Members share experiences with different AI platforms and their preferences for specific programming tasks
• **[00:18:01] – GUI vs Command Line Interface Philosophy**
• Extended discussion about the evolution from GUI to CLI interfaces, particularly in the context of AI interactions
• Team explores the concept of creating GUI wrappers for command-line tools to make them more accessible to non-programmers
• Conversation touches on the reliability of Windows 32 controls versus modern GUI frameworks
• Tommy showcases a comprehensive tool for automatically generating meeting minutes from audio recordings
• The system uses Assembly AI for transcription, handles name corrections, tracks attendance, and follows Robert’s Rules of Order
• Features include progress tracking, quality checks, and automatic formatting to Word documents via markdown
• **[00:36:00] – Voice Command System Development**
• Nick discusses his work on voice command integration using Vosk and Whisper for different types of speech recognition
• Technical discussion about local model requirements, RAM dependencies, and language support
• Comparison of different programming approaches between team members, highlighting learning methodologies
• **[00:50:15] – Programming Language Evolution and Learning**
• Extensive conversation about programming language families and learning approaches
• Discussion covers COBOL, Fortran, Python libraries, and the differences between AutoHotkey’s built-in functionality versus other languages
• Team members share their diverse programming backgrounds and learning philosophies
• **[00:59:45] – VS Code Claude Integration Quick Help**
• Ray seeks assistance with streamlining access to Claude within VS Code
• Team provides suggestions for using terminal commands and hotkeys to improve workflow efficiency
• Discussion about using AI to solve workflow optimization problems through screen sharing and visual demonstration
*Brief Summary*
The meeting showcased impressive AI-integrated automation tools, from Joe’s multi-approach task automation wizard to Tommy’s sophisticated meeting minutes generator. The team’s diverse programming backgrounds and approaches to learning new technologies created rich discussions about tool development, AI integration, and workflow optimization, demonstrating the collaborative nature of modern AutoHotkey development enhanced by AI capabilities.
This video transcript captures a technical discussion among developers exploring Claude’s new Files API and various AI automation tools. The conversation covers practical implementations of file management in API calls, web automation capabilities, and comparisons between different AI platforms and development environments.
*Key Points*
• **[00:00:00] – Claude Files API Introduction and Discovery**
• Discussion begins with Claude experiencing downtime, leading to discovery of the new Files API feature
• The Files API allows uploading files once and referencing them by ID in subsequent API calls, eliminating repeated uploads
• Provides 100GB storage with 500MB per file limit, offering significant efficiency improvements for repetitive tasks
• Particularly beneficial for users like radiologist clients who frequently analyze large sets of files
• **[00:08:53] – API vs Browser Usage and Practical Applications**
• Explanation of differences between browser-based Claude projects and API-driven automation
• API calls enable complete automation without manual intervention, while browser usage requires human interaction
• Discussion of token efficiency – Files API reduces costs by avoiding repeated file uploads
• Real-world examples include automated transcription services and code conversion tools
• **[00:17:48] – Advanced Integration and Web Automation Tools**
• Introduction of new MCP (Model Context Protocol) standards for web scraping and browser automation
• Discussion of NotebookLM integration with Claude for programmatic content generation
• Exploration of YouTube DLP integration and automated video processing capabilities
• Overview of emerging tools for connecting different AI platforms and services
• **[00:21:20] – Model Selection and OpenRouter Platform**
• Detailed walkthrough of OpenRouter’s interface for choosing among 600+ AI models
• Discussion of cost optimization strategies – balancing model capability with task requirements
• Practical examples showing cost differences between models (50 cents vs 20 cents for similar tasks)
• Emphasis on matching model complexity to task needs rather than always using the most powerful option
• **[00:28:53] – Anti-Gravity and Web Automation Demonstration**
• Live demonstration of Anti-Gravity’s web automation capabilities
• Shows AI agent inspecting web pages, understanding HTML elements, and generating AutoHotkey scripts
• Discussion of automated browser interactions and code generation from web page analysis
• Comparison between different AI platforms’ temporary vs permanent file storage approaches
• **[00:40:15] – AI Agent Integration and Workflow Optimization**
• Introduction of Manus AI agent integration with Telegram for convenient task automation
• Discussion of Claude’s bypass permissions and mechanical requirements for consistent AI behavior
• Overview of session logging, project tracking, and integration with knowledge management systems
• Comparison of various AI development environments including Claude Bot, VS Code extensions, and Google AI Studio
*Brief Summary*
The discussion reveals how advanced users are leveraging cutting-edge AI tools for automation, with particular emphasis on the efficiency gains from Claude’s Files API and emerging web automation standards. The participants demonstrate they’re significantly ahead of typical users in AI adoption, having already automated many routine tasks that others still perform manually.
This video captures a Friday development team meeting where the team discusses debugging a Simple Blur tool error, demonstrates an updated Find Text V2 tool, and showcases a new YouTube downloader utility. The session focuses on troubleshooting technical issues, improving user interfaces, and exploring AI-assisted development workflows.
• Troubleshot Chrome window positioning problems when using WinMove on maximized windows
• Discovered Chrome-specific behavior requiring restore before move operations
• Implemented three-step process: restore window, move to coordinates, then maximize
• Identified differences between Chrome executable and class-based window identification
• **[01:11:15] – Session Wrap-up and Technical Insights**
• Explored window state terminology and AutoHotkey’s handling of maximize/restore operations
• Tested solutions across different applications (Chrome vs Notepad) to verify consistency
• Documented Chrome’s unique window management behavior and icon state inconsistencies
• Concluded with working solutions for cross-monitor window positioning
*Brief Summary*
The team successfully resolved multiple technical challenges through collaborative debugging and AI-assisted development. Key achievements included fixing the Simple Blur tool’s error handling, demonstrating Claude AI’s capability in complex code conversion, and creating practical utilities like the YouTube downloader. The session highlighted the importance of thorough testing and the evolving role of AI in streamlining development workflows.
AHK Hero 2026 02 28 Saturday Hour 1
*Summary* This AutoHotkey community meeting covers a discussion about the Pentagon’s ban on Anthropic AI, troubleshooting technical issues with hotkey tools, and a detailed demonstration of converting function-based AutoHotkey scripts into class-based structures. The session includes practical problem-solving for system crashes and explores the benefits of using classes for better code organization and AI integration.
Learn more about AutoHotkey at https://the-Automator.com Or consider joining our amazing AHK Hero club here: https://the-Automator.com/AHKHero
*Key Points* **[00:00:00] – Pentagon AI Discussion and Tool Updates** • Group discusses Pentagon’s ban on Anthropic AI and its implications for AI development • Participants share mixed views on government AI restrictions, referencing historical parallels • Joe demonstrates updates to the Windows Snipping tool, including new features like adjustable sizing with plus/minus keys and delayed capture functionality for interactive elements • Tool now includes customizable settings for folder locations, delay timing, and percentage changes
**[00:08:36] – Hotkey Troubleshooting and System Issues** • Ray experiences problems with Alt+A hotkey not working in Zoom, leading to investigation using the HK Hotkey String Lookup tool • Discussion reveals the tool shows default hotkeys for programs, not customized user settings • Ray’s computer becomes unresponsive, requiring troubleshooting through Task Manager and eventually a system reboot • Team provides technical support suggestions including Process Explorer and lower-level hotkey alternatives
**[00:17:13] – System Recovery and Function-to-Class Conversion Introduction** • Ray successfully resolves computer issues through reboot, restoring Alt+A functionality • Joe explains context-sensitive hotkeys and their benefits for tool development • Irfan begins demonstrating conversion of a word substitution editor from function-based to class-based structure • Discussion covers the advantages of encapsulation and how classes prevent function name conflicts
**[00:34:27] – AI-Assisted Code Conversion and Class Benefits** • Irfan uses AI (Gemini 3.1 Pro) to help convert global variables to class properties and functions to static methods • Demonstrates real-time AI code modification and the importance of user feedback through accepting/rejecting changes • Shows how classes enable better code organization, reusability, and integration with other scripts • Explains static vs instance classes and when to use each approach for GUI applications
**[00:47:30] – Transcription Tools and API Workarounds** • Joe explains integration of the word editor tool with Assembly AI transcription services • Discusses custom spelling corrections for names and technical terms to improve transcription accuracy • Details workaround for API limitations using underscores to handle multi-word replacements • Demonstrates how programmatic solutions can overcome service restrictions while maintaining functionality
**[00:52:45] – AutoHotkey 2.1 Compatibility and Class Advantages** • Testing reveals the converted class works with AutoHotkey 2.1 alpha, requiring specific version targeting • Discussion of backward compatibility issues and new reserved keywords in 2.1 • Irfan explains benefits of class-based approach: better AI understanding, no global variable conflicts, and easier maintenance • Covers both static classes for single-instance tools and instance classes for multiple GUI applications
**[00:58:30] – Session Wrap-up and Technical Validation** • Final testing confirms class-based tool functions properly in AutoHotkey 2.1 alpha • Brief discussion of version-specific requirements and parameter usage • Session concludes with successful demonstration of function-to-class conversion methodology
*Brief Summary* The meeting successfully demonstrated practical AutoHotkey development techniques, from troubleshooting system issues to advanced code organization using classes. The conversion from function-based to class-based structure showcased how modern development practices can improve code maintainability and AI integration, while the transcription tool discussion highlighted creative solutions for working within API limitations.
AHK Hero 2026 02 27 Friday Hour 2
*Summary*
This video showcases a collaborative programming session focused on AutoHotkey development, featuring demonstrations of file selection interfaces, loading progress indicators, and system tray functionality. The team explores both practical coding implementations and discusses broader topics including AI automation tools, newsletter database management, and various Windows utilities.
Learn more about AutoHotkey at https://the-Automator.com
Or consider joining our amazing AHK Hero club here: https://the-Automator.com/AHKHero
• Discussion of user experience principles, comparing software feedback to airline communication strategies
• **[00:24:30] – Window Snipping Tool and Arrow Drawing Features**
• Presentation of updated snipping tool with system tray integration and hotkey management
• Demonstration of AI-generated arrow drawing functionality for screen annotations
• Comparison between V1 and V2 versions, highlighting simplified user interface improvements
• **[00:32:15] – Newsletter Automation and Database Management**
• Overview of SQLite database system for managing quotes, links, testimonials, and memes
• Discussion of AI vs. programmatic approaches for URL tracking removal and content extraction
• Exploration of embedding scores for intelligent content selection based on newsletter topics
• **[00:41:00] – System Tray Tips and Notification Systems**
• Technical exploration of tray tips vs. tooltips in Windows environments
• Troubleshooting notification systems across different Windows versions
• Discussion of Windows 11 live captions and Gemini integration features
• **[00:56:30] – AI Tool Usage and Context Management**
• Conversation about Claude’s context window limitations and management strategies
• Tips for maintaining project continuity through AI session compacting
• Examples of custom Chrome extensions built with AI assistance for form automation
*Brief Summary*
The session demonstrates practical AutoHotkey development techniques while highlighting the evolving relationship between traditional programming and AI-assisted development. The team effectively balances hands-on coding demonstrations with strategic discussions about automation workflows, emphasizing the importance of user experience design and efficient development practices in modern software creation.
AHK Hero 2026 02 27 Friday Hour 1
*Summary*
This video captures a team meeting where developers discuss various AutoHotkey tools and AI-assisted programming techniques. The session covers demonstrations of enhanced window snipping tools, AI-powered semantic search using embeddings, screen dimming utilities, and transcription improvements, while also exploring the evolution from AutoHotkey V1 to V2 and the role of AI in modern development workflows.
Learn more about AutoHotkey at https://the-Automator.com
Or consider joining our amazing AHK Hero club here: https://the-Automator.com/AHKHero
*Key Points*
**[00:00:00] – Meeting Opening and Ramadan Discussion**
• Team members exchange greetings and discuss Ramadan fasting practices
• Irfan explains the 30-day fasting period where participants abstain from both food and water during daylight hours
• Casual conversation about physical changes during fasting and daily routine adjustments
• Joe demonstrates V2 conversion of the window snipping tool with new arrow drawing capabilities
• Tool allows users to draw arrows that can be moved and positioned while yellow, becoming fixed when deselected
• Maintains OCR functionality and Google Translate integration while removing email features
• Discussion of conversion challenges from V1 to V2, with AI (Claude) handling most of the complex coding work
**[00:08:13] – AI-Powered Semantic Search with Embeddings**
• Joe showcases a revolutionary search system using AI embeddings to find quotes by meaning rather than exact text matches
• System scores 225 quotes using API calls to create similarity matrices, enabling conceptual searches
• Demonstrates searching for “fork” and finding “choice” as semantically similar results
• Implementation includes both file-based and SQLite database approaches with caching for efficiency
**[00:19:52] – Screen Dimming and Blur Tools**
• Irfan demonstrates the screen dimming tool with new color selection and timer features
• Tool works per-monitor and includes automatic top-window management to prevent other applications from covering the dim layer
• Separate blur tool allows selective content hiding with multiple blur blocks that anchor to specific windows
• Security discussion about AI’s inability to read properly blurred content, confirmed through OCR testing
**[00:39:38] – Transcription Enhancement and Word Substitution Editor**
• Team shows improved transcription tools with custom spelling and key term prompts for better name recognition
• New GUI-based word substitution editor allows non-programmers to easily manage name variants and mappings
• System prevents duplicate word assignments and handles case sensitivity automatically
• Tool generates proper JSON structure for integration with existing transcription workflows
**[00:50:12] – Programming Philosophy and AI Development Discussion**
• Debate about AutoHotkey V2.1 features, with Nick arguing that optional chaining makes programmers lazy
• Joe counters that accessibility features help beginners learn programming, citing his own journey from V1 to current skills
• Discussion of choosing Python vs AutoHotkey for new projects, with AI making language choice less critical
• Team explores the balance between making programming accessible and maintaining code quality standards
*Brief Summary*
The meeting showcases significant advances in AI-assisted tool development, from semantic search capabilities to automated V1-to-V2 conversions. The team demonstrates how AI is transforming their development workflow, enabling complex features like embedding-based search and automated transcription improvements while maintaining focus on user accessibility and practical functionality.
AHK Hero 2026 02 21 Saturday Hour 1
*Summary*
This is a Saturday AutoHotkey community call where members discuss various automation projects and AI tools. The conversation covers video processing tools, AI concerns, and practical automation solutions, with participants sharing their latest projects and philosophical discussions about AI’s impact on human skills.
Learn more about AutoHotkey at https://the-Automator.com
Or consider joining our amazing AHK Hero club here: https://the-Automator.com/AHKHero
*Key Points*
• **[00:00:00] – Video Scene Detection Tool Demo**
• Joe demonstrates an FFMPEG-based tool for segmenting drone footage by detecting scene changes
• The tool uses sensitivity thresholds (0.1 to 1.0) to identify video segments based on visual differences
• David explains his drone footage workflow, creating 1.5-2 minute videos from 6 minutes of raw footage
• Discussion about needing AI to understand context beyond simple frame differences
• **[00:08:45] – Transcriber Updates and Video Segmentation Tools**
• Instructions provided for accessing updated transcriber versions through user accounts
• Joe shares collaboration with colleague Joey on video automation tools
• Introduction of AI-powered video segmentation tool that analyzes transcriptions to identify extractable segments
• Discussion of thumbnail generation workflow and mail-merge approach for prompt building
• **[00:17:33] – AI Concerns and Philosophical Discussion**
• Nick expresses concerns about AI creating systems humans can no longer understand or control
• Ray shares experience of AI “seduction” – becoming dependent on AI for writing tasks
• Discussion about AI making people “dumb” and the need to occasionally work without AI assistance
• Debate about AI judges, legal interpretation, and the nature of truth in mathematics and law
• **[00:34:54] – GPU Video Processing and Technical Tools**
• Demo of updated video reducer tool with GPU detection and acceleration capabilities
• 10x speed improvement with GPU processing, though with slightly less compression efficiency
• Introduction of PDF merging tool for tax document processing using PDFtk
• Discussion of embeddings API for text similarity matching and search functionality
• **[00:44:20] – Voice AI and Telegram Integration**
• Demonstration of ElevenLabs voice cloning with descriptive emphasis and accent modification
• Irfan shows AI-powered code editor with voice commands for AutoHotkey development
• Joe demonstrates Telegram bot integration for sending formatted text with hotkeys
• Discussion of automation ideas and the endless nature of automation opportunities
• **[00:50:15] – Newsletter Automation and Database Building**
• Joe explains building a database system for newsletter content including quotes, memes, and testimonials
• AI-assisted HTML formatting for emphasis preservation in stored content
• Workflow for automating newsletter creation while maintaining editorial control
• Discussion of Gordon Ramsay analogy – matching AI model complexity to task requirements
• **[00:54:30] – AI Model Costs and Usage Strategies**
• Comparison of Claude Sonnet 3.5 vs Opus pricing and performance
• Discussion of $100/month Claude Pro plans and usage optimization strategies
• Philosophical debate about buying “intelligence” vs “knowledge” as a commodity
• Introduction of Grok’s multi-agent approach using specialized AI consultants for different reasoning tasks
*Brief Summary*
The call showcased practical automation solutions while addressing deeper concerns about AI dependency. Members demonstrated impressive tools for video processing, document management, and content creation, but also engaged in thoughtful discussion about maintaining human skills and understanding in an AI-driven world.
AHK Hero 2026 02 20 Friday Hour 2
*Summary*
This video features a technical discussion among developers about AI-powered video editing tools and voice command systems. The conversation covers two main topics: demonstrating an AI tool that automatically segments videos based on transcripts, and exploring the development of unified voice command and dictation software that could seamlessly switch between controlling computers and typing text.
Learn more about AutoHotkey at https://the-Automator.com
Or consider joining our amazing AHK Hero club here: https://the-Automator.com/AHKHero
*Key Points*
**[00:00:00] – AI Video Segmentation Tool Demonstration**
• Speaker demonstrates a tool that uses AI to analyze video transcripts and automatically create segments based on content
• The system can identify specific sections (like individual vegetables in a cooking video) and extract precise clips with accurate timing
• FFMPEG integration allows users to preview segments before extraction, eliminating need for separate media players
• Tool proves especially useful for content creators who need to break down longer videos into shorter, focused clips
**[00:09:10] – Video Processing and Compression Solutions**
• Discussion of an “effortless video reducer” tool that significantly compresses file sizes while maintaining quality
• H.265 encoding particularly effective for screen recordings and static content, achieving 80% file size reduction
• GPU acceleration provides much faster processing speeds compared to CPU-based compression
• Tool automatically detects and embeds English subtitles, streamlining the video processing workflow
**[00:18:21] – Voice Command and Dictation Integration Concept**
• Team explores creating unified software combining voice commands and dictation capabilities
• Current Windows tools (voice commands vs. dictation) don’t communicate, creating user experience friction
• Proposed solution involves multiple modes: single command, multi-command chains, and free dictation
• Discussion of using different speech recognition engines optimized for short commands versus longer dictation
**[00:27:15] – Technical Challenges in Voice-Controlled Programming**
• Detailed exploration of using voice commands for code generation and programming tasks
• Major challenge: distinguishing between punctuation as syntax versus content (commas, quotes, brackets)
• AI context awareness crucial for understanding variable references versus string literals
• Pseudocode approach suggested as compromise between natural speech and precise code generation
**[00:36:32] – AI Integration and Future Programming Paradigms**
• Debate over AI’s current capabilities for automated programming versus human-directed coding
• Discussion of bidirectional interaction where AI prompts users for clarification on ambiguous commands
• Consensus that AI excels at syntax generation when given clear logical direction
• Philosophical question raised about whether programmers should focus on higher-level problem solving rather than code writing
*Brief Summary*
The conversation reveals ongoing innovation in AI-assisted content creation and development tools. While the video segmentation technology appears ready for practical use, the voice programming concepts remain challenging due to the complexity of natural language interpretation in technical contexts. The team concludes that AI’s rapid advancement may soon make many current programming approaches obsolete.
*Summary*
This video captures a Friday morning automation development session where team members discuss various tools and AI-assisted development approaches. The conversation covers Progressive Web Apps (PWAs), AI debugging techniques, user interface challenges, and several automation tools including file management utilities and media processing applications.
Learn more about AutoHotkey at https://the-Automator.com
Or consider joining our amazing AHK Hero club here: https://the-Automator.com/AHKHero
*Key Points*
[00:00:00] – Introduction and Tool Discussion
• Team members gather for their weekly Friday session with Ryan joining from Liverpool
• Discussion about improving file navigation in transcription tools – adding browse buttons vs. drag-and-drop functionality
• Debate about scope creep in AI development and the importance of keeping tools simple and focused
• Ryan shares his philosophy of “doing less better” rather than adding endless features
[00:09:39] – Progressive Web Apps and Campaign Creator Demo
• Ryan demonstrates his Campaign Creator tool for collecting standardized video feedback
• Introduction to Progressive Web Apps (PWAs) as a deployment method that works across devices without app stores
• PWAs can be pinned to desktop/mobile like native apps while remaining web-based
• Discussion of PWA capabilities including push notifications, device access, and offline functionality
[00:19:12] – AI Debugging Tools and Claude Browser Extension
• Demonstration of Claude’s browser plugin for visual debugging and web page analysis
• Tool can take screenshots, analyze page elements, and provide coding solutions based on visual inspection
• Two-step debugging process: use browser tool to identify issues, then Claude to generate solutions
• Comparison with other AI tools like Google Gemini for screen sharing and debugging
[00:38:20] – Gemini App Creation and Database Access Challenges
• Discussion of Google Gemini’s rapid app creation capabilities vs. limited backend data access
• Comparison between Gemini’s black-box approach and PWA’s transparent development model
• Joe demonstrates creating a simple snake game in Gemini Studio
• Exploration of thumbnail generation tool built in Gemini with custom styling rules
[00:49:12] – GUI Menu Font Sizing Limitations
• Nick raises issue about inability to change font sizes in AutoHotkey GUI menus
• Team confirms this is a Windows limitation with no direct solution
• Suggestion to contact Hellbent (Jeffrey Barman) who may have custom menu solutions
• Discussion of accessibility needs for aging developers requiring larger text
[00:56:03] – AI Complexity Bias Discussion
• Team debate about AI’s tendency to choose complex solutions over simple ones
• Different perspectives: some see intentional complexity, others see AI taking first viable path
• Discussion of prompting strategies to encourage simpler solutions
• Recognition that advanced users typically ask AI for complex problems, skewing perception
[01:00:58] – File Path Capture and Drag Ninja Tool
• Joe introduces concept of capturing file paths when dragging files in Windows Explorer
• Introduction of standalone “Drag Ninja” tool for clipboard path capture
• Discussion of workflow improvements for file management automation
[01:04:32] – Drive Mapper Updates and Registry Management
• Irfan shows enhanced Drive Mapper with icon and label customization capabilities
• Tool now uses Windows registry for persistent drive naming and icon assignment
• Demonstration of virtual drive creation, customization, and cleanup processes
• Discussion of error handling for disconnected drives and registry cleanup needs
*Brief Summary*
The session showcased several innovative automation approaches, from PWAs enabling cross-platform deployment to AI-assisted debugging workflows. Key takeaways include the value of keeping tools focused rather than feature-heavy, the emerging potential of Progressive Web Apps for automation developers, and practical solutions for common workflow challenges like file path capture and drive management.
AHK Hero 2026 02 14 Saturday Hour 1
*Summary*
This video captures a Valentine’s Day team meeting focused on software development and AI tool integration. The discussion centers around improvements to ASM (AutoHotkey Script Manager), video/audio processing tools, and various AI integrations including Claude in Excel. The team demonstrates new features, discusses error handling best practices, and explores different approaches to using AI tools for productivity.
*Key Points*
**[00:00:00] – Valentine’s Day Opening and Tool Demonstration**
• Team exchanges Valentine’s Day greetings with mixed enthusiasm
• Joe mentions having reminders set weeks in advance for important dates
• Introduction to a segmentation tool for automatically identifying and extracting segments from video/audio files
• Irfan prepares to demonstrate the current GUI status but encounters technical difficulties with Git
**[00:03:20] – Segmentation Tool GUI and Features**
• Tool allows API key input and AI selection (OpenAI or Claude) for segmentation
• Uses Assembly AI for transcription with customizable prompts for content extraction
• Features dropdown menus for length (short/medium/long) and skill level (beginner/intermediate/advanced)
• Joe explains these dimensions are independent of custom prompts, making them easier for users to adjust frequently
**[00:06:20] – FFMPEG Integration and Silence Detection**
• Joe demonstrates a new GUI for FFMPEG’s built-in silence detection capabilities
• Tool can detect silence levels and duration thresholds for automatic removal
• Successfully reduced a 4 minute 52 second extract to 2 minutes 24 seconds at 2x speed
• Discussion about optimal playback speeds (1.25x-1.5x preferred over 2x) and the benefits of removing silence gaps
**[00:14:30] – ASM Improvements and Error Handling**
• Claude AI provided comprehensive suggestions for ASM optimization using the new million-token threshold
• Irfan implemented performance improvements including removing single-instance forcing for faster file loading
• Detailed discussion about proper error handling practices, emphasizing the importance of try-catch statements
• Isaiah provides technical guidance on error management, explaining why removing try-catch blocks is generally inadvisable
**[00:41:30] – Claude Integration Methods and Security Considerations**
• Joe demonstrates Claude plugin working directly in Excel through Microsoft Store installation
• Ray discusses Cowork desktop integration challenges and context window management issues
• Isaiah warns about prompt injection vulnerabilities when using AI plugins, recommending sandbox testing
• Team explores different approaches: direct Excel plugin vs. Cowork integration for broader file system access
**[00:52:30] – Real Estate AI Application and Meeting Wrap-up**
• Connie shares practical use of Claude in Excel for house hunting with custom criteria development
• Joe discusses advanced regression analysis possibilities for real estate valuation using AI
• Team acknowledges multiple valid approaches to AI integration depending on specific use cases
• Meeting concludes with Valentine’s Day wishes and Joe’s philosophical reflection on Socratic questioning methods
*Brief Summary*
The meeting showcased significant progress in AI-powered development tools, from video processing automation to enhanced error handling in ASM. The team successfully demonstrated multiple approaches to AI integration, with particular emphasis on Claude’s capabilities in Excel and the importance of security considerations when adopting new AI plugins.
AHK Hero 2026 02 13 Friday Hour 2
*Summary*
This video captures a technical discussion between software developers focusing on automation tools, Git version control, and Android emulation on Windows. The conversation covers enhancing Win32 control syntax writers with AI assistance, exploring advanced Git commands for development workflows, and examining the Windows Subsystem for Android as an alternative to traditional Android emulators.
*Key Points*
• **[00:00:00] – AI-Enhanced Control Syntax Writer Development**
• Team discussed a client call involving CAD program automation using Win32 controls
• Enhanced their control syntax writer tool by having Claude AI add missing methods, doubling or tripling available functionality
• Tool helps users identify control types, provides method lists, and generates exportable code
• Demonstrated post message functionality for precise control manipulation like selecting specific characters in edit fields
• **[00:09:02] – Essential Git Commands for Development**
• Covered five “magical” Git commands: blame, archive, stash, grep, and worktree
• Git blame tracks code changes and identifies authors for debugging and collaboration
• Git archive creates clean zip files excluding ignored files, useful for distribution
• **[00:18:01] – Advanced Git Workflows and Branch Management**
• Explored Git stash for managing multiple concurrent development tasks
• Discussed Git grep for repository-specific searching with Git rules integration
• Introduced Git worktree concept as separate working copies versus branch pointers
• Explained practical applications for client-specific versions and parallel development
• **[00:36:03] – Git Worktree Applications and Team Collaboration**
• Detailed worktree benefits for Dropbox-shared development environments
• Compared branches (pointers) versus worktrees (physical file copies) for different use cases
• Discussed garbage collection (git gc) for repository maintenance and space optimization
• Addressed team workflow challenges when sharing code across different development contexts
• **[00:41:00] – Windows Subsystem for Android Exploration**
• Examined Windows Subsystem for Android as alternative to BlueStacks and Android Studio emulators
• Discussed Hyper-V requirements and potential compatibility issues with other software
• Explored emulated Pixel 5 device integration with Windows file system
• Considered automation possibilities and limitations for Android app testing
• **[00:46:00] – Tool Enhancement and OCR Automation Challenges**
• Reviewed menu syntax writer improvements with AI-generated export functionality
• Addressed UI design considerations for tool workflow and button placement
• Discussed OCR tool challenges with disappearing menus and proposed solutions using screen capture techniques
• Explored AI-assisted video creation combining transcript processing, audio generation, and automated GUI interaction
*Brief Summary*
The discussion demonstrates how AI tools like Claude are revolutionizing software development workflows, from enhancing existing automation tools to streamlining Git operations. The team’s exploration of advanced Git commands and worktree functionality reveals sophisticated approaches to managing complex development scenarios, while their investigation of Windows Android emulation shows ongoing efforts to expand automation capabilities across different platforms.
AHK Hero 2026 02 13 Friday Hour 1
*Summary*
This is a Friday morning development team meeting where the group discusses AutoHotkey programming best practices, file handling improvements, and demonstrates a new AI-powered video segmentation tool. The conversation covers technical topics like variable scoping, class inheritance, file locking mechanisms, and showcases an innovative approach to automatically breaking long videos into smaller, topic-specific segments using AI transcription and analysis.
*Key Points*
• **[00:00:00] – Meeting Opening and ASM Development Updates**
– Team discusses recent improvements to ASM (AutoHotkey Studio Manager) including bug fixes and help documentation
– Joe created 10 instructional videos covering core functionality
– Claude AI was used to analyze ASM codebase and suggest optimizations, leading to discussions about local vs global variable declarations
• **[00:09:17] – Variable Scoping and Class Inheritance Deep Dive**
– Detailed explanation of AutoHotkey v2’s variable scoping behavior, particularly how global variables can be accessed within functions
– Discussion of when to explicitly declare local variables to avoid naming conflicts in large codebases
– Comprehensive walkthrough of class inheritance limitations, showing how extending classes only copies properties and methods, not special methods like constructors
• **[00:18:30] – File Handling Best Practices and Dropbox Issues**
– Team explains why file objects with locking are preferred over FileAppend for logging operations
– Demonstration of how cloud sync services like Dropbox can interfere with file operations, causing access errors
– Discussion of performance implications: FileAppend hammers drives with repeated open/close operations, while file objects allow batch processing
• **[00:36:55] – GUI Positioning and Off-Screen Window Detection**
– Presentation of a solution for automatically recentering windows that appear off-screen due to monitor configuration changes
– Technical discussion of using monitor coordinates and margins to detect when windows are positioned outside visible screen areas
– Exploration of system-level approaches using SysGet for virtual screen dimensions versus monitor-specific coordinate checking
• **[00:50:30] – AI-Powered Video Segmentation Tool Development**
– Joe demonstrates a real-world use case where he helped a neighbor segment a 2.5-hour auction video into 26 topic-specific clips in minutes
– Discussion of transcription service comparisons between Assembly AI and OpenRouter, with Assembly AI providing superior timestamp accuracy
– Irfan shows the new integrated tool that combines video transcription, AI analysis, and FFMPEG processing for automated video segmentation
• **[00:57:45] – Video Processing Technical Details**
– Explanation of FFMPEG’s fast extraction vs. rendering modes, including keyframe considerations and quality trade-offs
– Discussion of potential enhancements like adding intro/outro clips and barcode recognition for product identification
– Team emphasizes the importance of FFmpeg and ImageMagick as essential tools for any media processing automation
• **[01:02:00] – Automation Philosophy and Tool Recommendations**
– Philosophical discussion about pain thresholds that drive automation decisions
– Strong recommendation for FFmpeg and ImageMagick as must-have command-line tools for video/image processing
– Emphasis on how AI can now generate working code for these tools instantly, making complex media manipulation accessible
*Brief Summary*
The meeting showcases the team’s commitment to both technical excellence and practical problem-solving, from low-level AutoHotkey programming concepts to innovative AI-powered video processing solutions. The new video segmentation tool represents a significant advancement in automated content creation, combining multiple technologies to solve real-world problems efficiently.
AHK Hero 2026 02 07 Saturday Hour 1
*Summary*
This is a Saturday technical discussion session focused on VS Code workspace management and AI programming tools. The conversation begins with troubleshooting VS Code concepts like profiles versus workspaces, then transitions into managing multiple AI extensions, and concludes with an experimental discussion about AI programming language preferences.
*Key Points*
• **[00:00:00] – VS Code Profiles vs Workspaces Explanation**
• Profiles manage VS Code environment settings, extensions, hotkeys, themes, and layout configurations
• Used for different workflows (e.g., tutorial recording vs daily development work)
• Can be exported as JSON files and shared across computers
• Workspaces organize multiple project folders from different locations for specific development contexts
• **[00:08:46] – Workspace Implementation and Use Cases**
• Shared experience using multiple programming languages (6 languages in one project) for specialized tasks
• **[00:58:30] – AI Integration and Future Outlook**
• Discussed parallel AI workflow management across multiple conversation threads
• Mentioned competitive landscape between AI providers (Claude vs OpenAI advertising strategies)
• Explored AI’s proactive assistance and anticipatory features
• Reflected on AI meeting long-held expectations of computer interaction from science fiction
*Brief Summary*
The session effectively demonstrated practical VS Code organization strategies while showcasing advanced AI integration techniques. The group’s experimental approach to testing AI programming preferences revealed interesting insights about different models’ capabilities and biases, leading to valuable discussions about hybrid development approaches using multiple languages and AI assistance.
AHK Hero 2026 02 06 Friday Hour 2
*Summary*
This video captures a technical discussion among AutoHotkey developers focusing on game automation challenges, asynchronous programming concepts, AI-assisted development, and various debugging techniques. The conversation covers practical solutions for hotkey conflicts in game automation and demonstrates real-world applications of concurrent programming principles.
*Key Points*
• **[00:00:00] – Game Automation Hotkey Issues**
• Discussion of automating a race car game for wealthy clients where hotkeys mysteriously stopped working
• Discovery that launching a second script instance would work while the first failed
• Root cause identified as keyboard hook registration conflicts between the game and AutoHotkey scripts
• Solution involved using keyboard hooks instead of standard hotkey registration to avoid conflicts with game’s dynamic hotkey setup
• **[00:09:43] – Keyboard Hook Technical Deep Dive**
• Explanation of how AutoHotkey registers hotkeys using operating system’s register hotkey function versus keyboard hooks
• Games can replace AutoHotkey’s hotkey table when they register their own hotkeys dynamically
• Keyboard hooks monitor physical key presses and notify all listeners, making them immune to table replacement
• Demonstration of using install keyboard hook and use hook directives for more reliable hotkey handling
• **[00:19:20] – Asynchronous Programming and Performance Optimization**
• Comparison between sequential API calls versus asynchronous requests using stock tracking script example
• Sequential processing requires waiting for each request to complete before starting the next (500ms × n requests)
• Asynchronous approach sends all requests simultaneously, completing in single request time (500ms total)
• Real-world analogy using house painting and voice-to-text processing to illustrate multitasking benefits
• **[00:28:40] – AI Development Tools and Debugging Challenges**
• Demonstration of newsletter content management tool built with AI assistance using SQLite database
• Discussion of AI’s strengths in code generation versus weaknesses in debugging AI-generated code
• Preference for using AI as conversational tool for solutions rather than having AI write and debug code
• Challenges with AI debugging including inability to send screenshots and context, leading to ineffective troubleshooting
• **[00:38:43] – File Management and GUI Dialog Improvements**
• Demonstration of locked file deletion tool that attempts multiple deletion strategies including ownership changes and ACL modifications
• Solution for dialog ownership issues where dialogs can hide behind main windows causing confusion
• Implementation of “own dialogues” option to ensure dialogs stay on top of parent windows
• Upgrade from older dir select to newer file select directory for better user experience
• **[00:54:20] – Quick Access Tools and Script Management**
• Showcase of Windows settings quick access tool built with AI featuring categorized menus and icons
• Discussion of single instance script conflicts when running from different locations
• Suggestion to use GUIDs for unique program identification across different file paths
• Plans to add search functionality to filter tools similar to existing Prompt Assistant implementation
*Brief Summary*
The session effectively demonstrated how modern AutoHotkey development benefits from understanding both low-level system interactions (like keyboard hooks) and high-level programming concepts (like asynchronous processing). The team’s approach of combining AI assistance with manual debugging and their focus on practical GUI improvements shows a mature development workflow that balances automation with hands-on problem-solving.
AHK Hero 2026 02 06 Friday Hour 1
*Summary*
Ray presents his AI-powered legal document automation system built with Claude 4.6, demonstrating how he processes legal source documents through a six-step pipeline to generate professional invoices and dockets for Legal Aid submissions. The system transforms what previously took three days of manual work into automated processing that can handle multiple cases in a single day with significantly higher quality output.
*Key Points*
• **[00:00:00] – AI Legal Document System Overview**
• Ray demonstrates his VS Code-based system using Claude 4.6 to automate legal billing documentation
• System processes source documents (emails, hearing notices, board decisions) through six instruction steps
• Generates comprehensive invoices with narrative summaries, detailed dockets, and proper formatting
• Includes automatic bolding for readability and calculates billable vs administrative hours
• **[00:08:45] – Multi-Step Processing Pipeline with Quality Gates**
• Six-step process: P0 extracts facts to JSON, P1 converts to structured format, P2 creates docket entries
• Each step includes “definition of done” with 22 gates based on Nate B. Jones methodology
• System performs comprehensive auditing including activity tracing, cumulative hour validation, and overlap detection
• Built-in error checking prevents common issues like time overlaps and calculation errors
• **[00:17:25] – Data Privacy and System Reliability Concerns**
• Discussion of privacy risks when sending sensitive legal data to external AI services
• Recommendation for six-month manual validation period due to AI’s potential for masked errors
• Context window limitations addressed through separate processing steps with summary handoffs
• PDF processing challenges and suggestions for deterministic text extraction tools
• **[00:25:45] – COM Objects and Programmatic Automation**
• Detailed explanation of Windows COM objects as programming interfaces for applications like Outlook and Excel
• COM objects provide programmatic access without requiring visible application interfaces
• Examples include connecting to Excel, HTTP requests, and email processing through standardized APIs
• Available across multiple programming languages with consistent behavior
• **[00:34:45] – Alternative Approaches: Programs vs AI Processing**
• Nick advocates for using AI to create programs rather than processing data directly through AI
• Deterministic tasks (calculations, formatting) better suited for traditional programming
• AI best reserved for fuzzy tasks like narrative generation and document structure interpretation
• Cost and reliability benefits of local program execution vs repeated AI API calls
• **[00:43:15] – Testing Strategies and Quality Assurance**
• Recommendation to test system with historical cases where outcomes are known
• Importance of running identical inputs multiple times to verify consistency
• Discussion of AI’s improving capabilities with recent model releases from OpenAI and Claude
• Balance between leveraging AI improvements and maintaining validation protocols
• **[00:52:30] – Future of AI Development and Programming Skills**
• Debate over AI’s impact on traditional programming roles and skill requirements
• Ray’s transformation from manual legal work to AI-assisted automation represents broader trend
• Concerns about losing ability to validate AI-generated code as systems become more complex
• Analogy to manual transmission cars – skills becoming obsolete as technology advances
*Brief Summary*
Ray’s legal automation system demonstrates both the tremendous potential and inherent risks of AI-powered document processing. While achieving remarkable efficiency gains and quality improvements, the discussion reveals critical considerations around data privacy, system validation, and the evolving relationship between human expertise and AI capabilities in professional workflows.
AHK Hero 2026 01 31 Saturday Hour 1
*Summary*
This is a Saturday morning technical discussion among developers working on various AI-powered automation tools and applications. The session covers troubleshooting drive renaming issues, demonstrating a skills management tool, exploring AI development platforms, and debating the merits of different development environments for creating automated workflows and web applications.
• Isaiah demonstrates an AI-powered financial analysis web application built with AI Studio
• App processes bank transactions in batches, categorizes them automatically, and learns from user corrections
• Shows intelligent pattern recognition where correcting one transaction updates similar entries
• Discusses the challenge of preventing AI from overwriting previously categorized transactions
• **[00:48:12] – AI Development Platform Trade-offs**
• Comparison between AI Studio, Opal, VS Code, and Anti-Gravity for different development needs
• AI Studio excels at rapid web app prototyping but limits code control and portability
• Discussion of when to choose web apps versus desktop applications based on system access requirements
• Emphasis on understanding each platform’s strengths and limitations before committing
• **[00:55:32] – Tool Selection Philosophy and Learning Strategy**
• Debate between focusing on mastering one tool versus exploring multiple options
• Ray advocates for cross-pollination learning from multiple tools to enhance overall understanding
• Isaiah recommends specializing in one primary tool while maintaining awareness of alternatives
• Agreement that tool choice should align with specific project requirements and long-term goals
*Brief Summary*
The session emphasizes the importance of strategic tool selection in AI-assisted development, balancing the benefits of specialization with the value of broad exposure. The team demonstrates that while AI significantly accelerates development and troubleshooting, success still requires understanding each platform’s trade-offs and choosing the right tool for specific use cases rather than trying to master everything simultaneously.
AHK Hero 2026 01 30 Friday Hour 2
*Summary*
This video captures a technical team meeting where developers discuss various coding challenges, tool development, and AI-assisted programming experiences. The conversation covers debugging issues with text selection in ASM (AutoHotkey Script Manager), virtual drive naming problems, and demonstrations of AI-powered applications including crossword puzzles and financial transaction categorizers.
*Key Points*
• **[00:00:00] – ASM Text Selection Debugging**
• Team investigates a text selection visibility issue in ASM where selected text doesn’t display properly during mouse selection
• Discussion reveals the problem stems from AutoHotkey event handling rather than the underlying Scintilla library
• Comparison between different Scintilla implementations shows the issue is specific to ASM’s custom event processing approach
• Exploration of inconsistent behavior when renaming virtual drives created by their drive creation tool
• Technical analysis reveals some drives can be renamed while others cannot, potentially related to system permissions, page files, or drive relationships
• Team decides to research the root cause using AI assistance rather than implementing unreliable rename functionality
• **[00:29:15] – Code Syntax Best Practices Discussion**
• Brief educational moment about using double quotes versus single quotes in AutoHotkey scripts
• Explanation focuses on preventing syntax errors when user-generated content contains apostrophes
• Demonstrates practical coding considerations for dynamic content generation
• **[00:33:30] – AI Skills and Learning Moments Demo**
• Ray demonstrates Claude AI skills system for automatically capturing and organizing learning moments from conversations
• Shows meta-thinking skill designed to prevent over-engineering by evaluating available tools before building new solutions
• Discussion of trigger words and automatic skill activation reliability in AI systems
• **[00:45:20] – Transcription Tool Version Issues**
• Troubleshooting session for Connie’s transcribe and summarize tool that’s using an outdated version
• Explanation of the newer Assembly AI integration that simplifies token management for users
• Quick resolution by identifying the need to update to the current tool version
• Joe demonstrates a football-themed crossword puzzle app created in 30 minutes using Gemini AI
• Isaiah presents a financial transaction categorization tool built with AI Studio, highlighting both capabilities and debugging challenges
• Discussion of the trade-offs between rapid AI-assisted development and the complexity of debugging generated code
*Brief Summary*
The meeting showcases both the power and challenges of modern AI-assisted development, from rapid application creation to complex debugging scenarios. The team demonstrates a collaborative approach to problem-solving while highlighting the importance of understanding underlying systems even when using AI tools for development.
AHK Hero 2026 01 30 Friday Hour 1
*Summary*
This AutoHotkey development team meeting covers several key topics including handling broken web links in code, using the Wayback Machine for recovery, implementing no-close functionality in applications, and creating enhanced GUIs with AI assistance. The team demonstrates various tools and techniques while discussing VS Code workspace management and showcasing AI-generated solutions for complex programming challenges.
*Key Points*
• **[00:00:00] – Broken Link Recovery and Wayback Machine Usage**
• Team discovers a referenced website domain is now for sale with missing content
• Demonstrates using Internet Archive’s Wayback Machine to recover lost web pages
• Shows how to use Grepwin tool to find and replace broken links across multiple script files
• Discusses broader implications of link rot and systematic approaches to fixing references
• Presents AI-solved challenge of creating alternating row colors in AutoHotkey ListViews
• Reveals use of LV Colors library for complex GUI enhancements
• Demonstrates “meta thinking” approach to AI problem-solving
• Shows how AI can find and implement existing solutions rather than creating from scratch
*Brief Summary*
The session effectively demonstrates the evolution of development practices with AI integration, showing how tools like Claude can accelerate GUI creation and solve complex programming challenges. The team’s exploration of various utilities, from link recovery to performance optimization, illustrates practical approaches to common development obstacles while highlighting the growing importance of AI-assisted coding workflows.
AHK Hero 2026 01 24 Saturday Hour 1
*Summary*
This AutoHotkey Hero Club meeting covers AI-assisted programming, code sharing practices, and web automation techniques. The discussion focuses on using Claude and other AI tools for AutoHotkey development, debugging challenges, and the benefits of collaborative programming through shared repositories.
*Key Points*
**[00:00:00] – Meeting Opening and AI Tool Discussion**
• Members discuss weather and begin sharing experiences with AI coding assistants
• Connie shares usage of Microsoft Copilot for quick tasks like translation and text improvement
• Tommy describes successful project planning using Copilot and Claude for system tray icon management
• Ray demonstrates improved debugging approach by requesting robust debugging functions upfront
**[00:09:20] – Ray’s Complex Script Demonstration and Code Sharing Philosophy**
• Ray showcases a 2000-line script manager built with Claude that organizes and launches AutoHotkey scripts
• Discussion emerges about making projects publicly available for community learning
• Isaiah emphasizes that sharing code concepts and solutions benefits the broader programming community
• Members explore the value of Git repositories and collaborative development practices
**[00:18:34] – Database Performance Challenges and Pagination Solutions**
• Isaiah demonstrates a database application with 7,000+ companies and 122,000+ people records
• Explains AutoHotkey performance limitations when loading large datasets (30-second load times)
• Describes implementing pagination and lazy loading to improve script responsiveness
• Discusses the universal nature of programming problems across different applications and languages
**[00:37:03] – AI Tool Comparison: Claude vs ChatGPT Approaches**
• Claude asks questions and builds incrementally, better for learning and debugging
• ChatGPT provides full solutions quickly but creates debugging challenges later
• Discussion of AI limitations with AutoHotkey compared to Python/JavaScript environments
**[00:41:15] – Agent Skills Framework and Testing Automation**
• Introduction to AgentSkills.io as an open standard for AI tool integration
• Isaiah explains creating custom skills for AutoHotkey testing and debugging
• Concept of building wrapper scripts that AI can execute to test AutoHotkey functionality
• Discussion of screenshot-based validation and automated syntax checking
**[00:49:30] – Code Sharing Platforms and Community Building**
• Debate over optimal platforms for sharing AutoHotkey projects (Git, forums, Dropbox)
• Consideration of public vs private repositories for Hero Club members
• Discussion of helping newcomers while maintaining advanced development focus
• Exploration of different approaches to teaching AutoHotkey concepts
**[00:55:20] – JavaScript Injection Techniques for Web Automation**
• Isaiah demonstrates reliable method for sending JavaScript through browser URL bar
• Detailed explanation of clipboard-based approach to avoid keystroke timing issues
• Code example showing proper activation, delay management, and error prevention
• Practical implementation with query selectors and DOM manipulation for web scraping
*Brief Summary*
The meeting highlighted the evolving landscape of AI-assisted AutoHotkey development, emphasizing the importance of choosing appropriate AI tools for different development phases. The community demonstrated strong interest in collaborative code sharing and established practical techniques for web automation that address common reliability issues in browser-based scripting.
AHK Hero 2026 01 23 Friday Hour 2
*Summary*
This AutoHotkey community session covers hot strings implementation, programming concepts like promises and asynchronous operations, and troubleshooting clipboard issues. The discussion begins with comparing Espanzo (Mac tool) to AutoHotkey capabilities, then explores advanced programming concepts including linear vs. event-driven execution, timers, and promises in AutoHotkey development.
*Key Points*
• **[00:00:00] – Hot Strings and Text Automation**
• Alex asks about replicating Espanzo functionality in AutoHotkey for launching Python scripts and pasting text
• Demonstration of AutoHotkey V2 hot string syntax using double colons (::) for shortcuts
• Shows how to execute multiple actions using brackets and the ‘X’ option for commands vs. text
• Creates robust paste function with clipboard backup, restoration, and error handling
• **[00:08:52] – Toolkit Discussion and Python Integration**
• Discussion about syntax highlighting issues in Toolkit when using the ‘X’ option
• Explanation of valid vs. invalid option color coding in the development environment
• Reference to 12-year-old Python-AutoHotkey integration work for bidirectional functionality
• Ray’s OneDrive path issues with Directory Opus layouts causing invalid folder references
• **[00:17:42] – Programming Paradigms and Asynchronous Operations**
• Explanation of linear programming vs. event-driven execution in AutoHotkey
• Introduction to GUI event handling and how it breaks linear code execution
• Deep dive into timers and their impact on code flow, creating non-linear execution patterns
• Discussion of promises as a solution for managing asynchronous operations and data availability
• **[00:26:15] – Promise Implementation and Advanced Libraries**
• Introduction to Tigbee’s promise library for AutoHotkey with JavaScript-like “then” functionality
• Overview of Tigbee’s extensive library collection including WebView2, OCR, audio APIs, and networking tools
• Explanation of how complex libraries translate original functionality into AutoHotkey syntax
• Discussion of programmer vs. end-user perspectives on library complexity
• **[00:35:23] – Clipboard Troubleshooting and Timing Issues**
• Ray demonstrates clipboard pasting problems in Directory Opus vs. other applications
• Analysis of timing issues between clipboard operations and program processing speeds
• Solution involves increasing sleep delay from 1000ms to 2500ms for Directory Opus compatibility
• Explanation of why different programs require different timing for reliable clipboard operations
*Brief Summary*
The session successfully addressed hot string implementation questions and resolved a complex clipboard timing issue specific to Directory Opus. The discussion highlighted the evolution from simple linear programming to complex asynchronous operations in AutoHotkey, demonstrating both practical solutions and advanced programming concepts for community members.
AHK Hero 2026 01 23 Friday Hour 1
*Summary*
This AutoHotkey community meeting covers several technical topics including voice command development, microphone detection challenges, web scraping limitations, drive security tools, and regional date/time formatting issues. The discussion demonstrates the collaborative problem-solving approach of the community while highlighting various AutoHotkey programming challenges and solutions.
*Key Points*
[00:00:00] – Weather Discussion and Voice Command Development
• Team members share weather conditions across different locations (Vegas, Toronto, Netherlands)
• Connie introduces his HAL voice command program inspired by previous discussions
• Discussion of microphone detection challenges and the need for reliable device identification
• Exploration of DLL calls versus AutoHotkey built-in functions for audio device management
• Joe explains use case for hiding drives when others access his computer remotely
• Irfan demonstrates Windows Disk Management and automated drive hiding tool
• Discussion of security through obscurity versus actual data protection
• Safety considerations and warnings for drive manipulation operations
[00:44:04] – Voice Command Integration and Accessibility Features
• Discussion of Windows Voice Access capabilities for button detection
• Exploration of dynamic voice commands that work across different applications
• Integration possibilities between custom voice tools and system accessibility features
• Connie’s plans for future voice command demonstrations
[00:52:16] – Regional Date/Time Formatting Issues
• Isaiah demonstrates critical problem with AM/PM display in different locales
• Live troubleshooting session using Ray’s Canadian system settings
• Discovery that French Canadian locale removes AM/PM options entirely
• Technical explanation of how regional settings affect AutoHotkey date/time controls
[01:11:32] – Date/Time Control Customization and Documentation
• Detailed exploration of date/time format strings and custom symbols
• Discussion of locale-dependent variables and their limitations
• Plans to improve AutoHotkey documentation based on discovered issues
• Encouragement for community members to contribute to open-source documentation
*Brief Summary*
The meeting showcased the AutoHotkey community’s collaborative approach to solving complex technical challenges, from audio device management to regional formatting issues. The team demonstrated practical tools while identifying areas where AutoHotkey’s built-in functions have limitations, leading to discussions about documentation improvements and alternative solutions using external libraries or manual workarounds.
AHK Hero 2026 01 17 Saturday Hour 1
Summary The audio file is a detailed discussion among members of the AutoHotkey Hero group, focusing on various technical issues and solutions related to programming and software tools. Key speakers include Joe Glines and Isaias Baez, who delve into topics such as debugging, software functionality, and the use of specific tools like ASM and Site for coding and debugging. The conversation also touches on personal anecdotes related to technology and programming challenges.
Key Points – [00:00:00] – Introduction and Initial Discussion • The session opens with greetings and a brief check-in among members. • Discussion about various personal and technical updates, including issues with software and hardware being used by the members.
– [00:06:52] – Technical Discussion on Debugging and Software Tools • Joe and Isaias discuss specific debugging scenarios and the use of tools like ASM and Site. • They explore the functionalities of these tools in real-time coding environments and address member questions about software settings and configurations.
– [00:13:42] – In-depth Analysis of Debugging Techniques • The conversation shifts to more technical aspects of debugging. • Detailed walkthroughs of using conditional breakpoints and managing variable scopes within debugging sessions are provided.
– [00:27:31] – Member Interaction and Problem Solving • Members share their coding issues and receive advice on debugging and tool optimization. • Isaias provides a live demonstration on setting up and using debugging tools effectively.
– [00:54:45] – Concluding Remarks and Future Plans • The session concludes with a summary of the discussed topics and a forward-looking plan regarding the use of ASM and other tools. • Members express their plans to integrate learned techniques into their workflows.
Brief Summary The discussion among AutoHotkey Hero members, led by Joe Glines and Isaias Baez, was rich with technical insights into debugging and software tool usage. The session included live demonstrations, problem-solving, and interactive Q&A, providing members with practical knowledge and solutions to enhance their programming skills. Future sessions are anticipated to further delve into these tools and techniques.
AHK Hero 2026 01 16 Friday Hour 2
*Summary*
This transcript details a technical discussion among members of the AutoHotkey Hero group, focusing on the use of Google Maps API and data handling techniques. Key speakers include Joe Glines and Isaias Baez, who explore various aspects of data extraction, manipulation, and presentation using AutoHotkey scripts.
*Key Points*
[00:00:00] – Introduction and Overview
• Joe Glines and Isaias Baez discuss ongoing projects and challenges with Google Maps API.
• The conversation includes technical details on handling and trimming large datasets.
[00:05:40] – Deep Dive into Google Maps API Data
• Exploration of data types and structures returned by the API, such as business status, operational names, and addresses.
• Discussion on the utility of various data points and decision-making on data retention based on relevance.
[00:11:21] – Data Processing Techniques
• Techniques for parsing and organizing data from JSON files are discussed.
• The focus is on optimizing data for usability and performance in applications.
[00:22:32] – Implementation of AutoHotkey Scripts
• Practical demonstration of using AutoHotkey scripts to automate data handling and improve workflow efficiency.
• Examples include automating Excel interactions, such as opening files and formatting data.
[00:45:04] – Q&A and Troubleshooting Session
• The session concludes with a Q&A, addressing specific technical questions from participants.
• Troubleshooting common issues with script implementation and functionality enhancements.
*Brief Summary*
The discussion in this transcript revolves around advanced data handling and automation techniques using AutoHotkey, particularly in the context of Google Maps API data. Joe Glines and Isaias Baez lead the conversation, providing insights into effective data manipulation, automation strategies, and the practical application of these techniques in real-world scenarios. The session ends with a Q&A, highlighting the community’s collaborative approach to problem-solving and skill enhancement.
AHK Hero 2026 01 16 Friday Hour 1
*Summary*
The audio file contains a detailed discussion among members of the AutoHotkey Hero group, focusing on various technical issues and solutions related to programming and debugging. Key speakers include Joe Glines and Isaias Baez, who share insights and experiences on using different tools and techniques to enhance coding efficiency and solve common problems encountered in their projects.
*Key Points*
[00:00:00] – Introduction and Initial Discussion
• Joe Glines and Isaias Baez open the meeting, greeting members and setting the stage for the discussion.
• Various technical issues and updates on projects are briefly mentioned, setting the context for deeper discussions.
[00:06:52] – Debugging Techniques and Tools
• The conversation shifts to more technical aspects, focusing on debugging techniques.
• Specific tools like DaVinci Resolve and NotebookLM are discussed in the context of their application in programming and debugging.
[00:13:42] – Encoding Issues and Solutions
• A significant portion of the discussion is dedicated to addressing encoding issues encountered by the members.
• Solutions involving different software settings and tools like Dropbox and Site editor are explored to resolve these issues.
[00:27:31] – Advanced Debugging Scenarios
• Members delve into more complex debugging scenarios involving conditional breakpoints and variable tracking.
• The effectiveness of various debugging tools and methods in different coding environments is evaluated.
[00:54:45] – Wrap-up and Final Thoughts
• The session concludes with a summary of the key solutions and techniques discussed.
• Members express their plans to apply the discussed strategies to their ongoing projects and anticipate future meetings to share results.
*Brief Summary*
The discussion among AutoHotkey Hero members was rich with technical insights, focusing on debugging practices, tool usage, and solving encoding issues. Key contributions from Joe Glines and Isaias Baez highlighted practical approaches to common programming challenges, providing valuable takeaways for all participants. The session ended with members looking forward to applying the discussed techniques in their projects.
AHK Hero 2026 01 03 Saturday Hour 1
*Summary*
This AutoHotkey Hero call features Joe Glines and Isaias Baez discussing automation projects, AI integration, and OCR tools. The session covers newsletter automation workflows, OCR implementation for gaming applications, and Google Maps API integration for business data scraping.
*Key Points*
• [00:00:00] – Newsletter Automation Discussion
• Joe demonstrates his newsletter workflow using a categorization tool for AI news, humor, and testimonials
• Discussion of automating content selection using AI to find relevant articles based on newsletter themes
• Implementation of hotkey-based content categorization system with JSON storage
• [00:06:01] – AI Usage Philosophy and Best Practices
• Debate about AI assistance versus complete AI dependency in programming
• Isaias emphasizes the importance of understanding code when using AI-generated solutions
• Discussion of trade-offs between efficiency and knowledge when leveraging AI tools
• [00:12:02] – OCR Tool Development for Gaming
• Isaias presents an OCR solution for extracting player names from game interfaces
• Comparison between Windows Snipping Tool OCR and Windows RT OCR capabilities
• Implementation of hotkey-based screenshot capture with area selection functionality
• [00:23:57] – Development Efficiency and Autocomplete
• Discussion of how autocomplete and IDE features dramatically speed up coding
• Real-world example of building OCR tool in 40 minutes using efficient development practices
• Debate about balancing tool dependency with fundamental programming knowledge
• [00:47:55] – Google Maps API Integration Project
• Irfan demonstrates WebView2 integration with Google Maps for location selection
• Implementation of latitude/longitude extraction from map interactions
• Discussion of API calls for business data scraping and review collection
• UI improvements including progress bars and button state management
*Brief Summary*
The session showcased practical automation projects combining traditional programming with modern AI assistance. The team demonstrated how WebView2, OCR technologies, and API integration can create powerful automation tools while maintaining a balance between leveraging AI capabilities and retaining programming expertise.
AHK Hero 2026 01 02 Friday Hour 2
*Summary*
This AutoHotkey Hero call features Joe Glines and Isaias Baez discussing various automation tools and techniques. The session covers Google Maps scraping using WebView2, Git repository management best practices, OCR capabilities in Windows, and an in-depth demonstration of AutoHotkey debugging functionality developed by team member Irfan.
*Key Points*
• [00:00:00] – Google Maps Scraping Tool Demonstration
• Irfan demonstrates a Google Maps scraping tool built with WebView2 and AutoHotkey that extracts reviewer data from business listings
• The tool injects custom HTML buttons into Google Maps pages to initiate scraping processes
• Discussion reveals Google’s API limitations (only 5 reviews for public access) versus unlimited browser-based scraping capabilities
• Team explores the potential for contacting reviewers to solicit reviews for client businesses
• [00:05:50] – WebView2 Integration and Technical Implementation
• Detailed explanation of how WebView2 allows injection of custom JavaScript and HTML into existing web pages
• Discussion of timing conflicts between AutoHotkey and JavaScript execution requiring delay mechanisms
• Comparison between WebView2 approach versus traditional API calls for data extraction
• Technical challenges of coordinating multiple scripting languages simultaneously
• [00:11:37] – Git Repository Management and Best Practices
• Practical demonstration of safely renaming Git repositories and testing for potential conflicts
• Explanation of when Git operations break (submodules, remote references) versus safe scenarios
• Introduction of Git garbage collection (git gc) for repository maintenance and size optimization
• Discussion of Dropbox/syncing tool conflicts with Git operations and recommended workarounds
• [00:23:07] – OCR Technology and Windows AI Integration
• Exploration of OCR use cases for extracting text from applications that don’t provide direct data access
• Discussion of Windows built-in OCR capabilities through Snipping Tool and voice recognition improvements
• Comparison of local versus cloud-based AI processing for OCR tasks
• Investigation into whether Windows Copilot features operate locally or require internet connectivity
• [00:32:20] – AutoHotkey Debugging System Development
• Comprehensive demonstration of Irfan’s custom AutoHotkey debugger with step-through capabilities
• Technical explanation of event handling conflicts between Scintilla editor and debugging APIs
• Showcase of debugging features including breakpoints, variable watching, and step execution controls
• Discussion of debugging challenges unique to AutoHotkey development environment
*Brief Summary*
The call showcased advanced AutoHotkey development techniques ranging from web scraping automation to sophisticated debugging tools. The team demonstrated practical solutions for common development challenges while exploring the integration of modern AI capabilities with traditional automation approaches, highlighting the continued relevance and evolution of AutoHotkey in contemporary software development.
AHK Hero 2026-01-09 Hour 1
*Summary*
This AutoHotkey Hero call features Joe Glines and Isaias Baez discussing debugging issues with AI-generated code and exploring advanced AI coding methodologies. The session begins with troubleshooting a Claude-generated icon search tool that works for one user but fails for another, ultimately revealing file encoding issues as the root cause.
*Key Points*
• [00:00:00] – Opening and Claude Desktop Issues
• Members discuss weather and burn bans in their areas
• Joe mentions upcoming Claude Code CLI exploration for next week
• Connie reports problems with Claude desktop app not displaying code properly
• Discussion reveals potential differences between web browser and desktop app performance
• [00:06:00] – AI Icon Search Tool Debugging
• Connie presents an AI-generated tool for finding Windows DLL icons that works for him but fails for Joe
• Focus shifts to examining the actual code structure and logic flow
• [00:11:59] – Code Analysis and File Encoding Discovery
• Isaias identifies hard-coded UTF-16 file encoding as a potential issue
• Systematic examination reveals the tool reads from INI files with specific encoding assumptions
• Discussion covers global variables, DLL calls, and 32-bit vs 64-bit compatibility issues
• [00:23:55] – Root Cause Identification
• Joe confirms the encoding issue was the actual problem – changing to UTF-8 fixed it
• Detailed explanation of how INI file creation affects encoding (manual vs programmatic creation)
• Discussion of best practices for file encoding in AutoHotkey projects
• [00:34:30] – AI Coding Methodology Deep Dive
• Isaias demonstrates his structured approach: Ask ? Plan ? Edit using different AI models
• Shows real example of log file analysis tool creation using VS Code AI integration
• Explains switching between thinking models for planning and simpler models for execution
• [00:47:49] – Advanced AI Integration Techniques
• Discussion of VS Code’s AI modes (Ask, Edit, Agent, Planning) and their specific use cases
• Demonstration of AI accessing GitHub repositories through VS Code for real-time documentation
• Exploration of model selection strategies based on task complexity and specificity
• [00:52:30] – Model Selection and Tool Access
• Comparison of different AI models (GPT, Claude, Gemini) and their strengths
• Discussion of VS Code’s preferential treatment of Microsoft models vs third-party options
• Explanation of fetch tools for accessing current web information beyond training data
• [00:55:45] – AI Model Hierarchy and Control
• Breakdown of typical three-tier model structure: Mini/Fast, Standard, and Thinking models
• Importance of matching model capability to task requirements
• Discussion of user control vs automated model selection in various AI platforms
• [00:57:30] – Platform Limitations and Workarounds
• Isaias explains VS Code integration challenges with non-Microsoft AI models
• Comparison of direct web access vs IDE integration for different AI services
• Final thoughts on balancing convenience with functionality across platforms
• [00:59:00] – Session Wrap-up
• Brief discussion of custom agent creation in VS Code
• Plans for future exploration of AI coding techniques
• Session conclusion with technical insights gained
*Brief Summary*
The session successfully resolved a file encoding issue in an AI-generated AutoHotkey tool while revealing sophisticated AI coding methodologies. Isaias demonstrated how strategic model selection and structured workflows can significantly improve AI-assisted programming outcomes, emphasizing the importance of planning phases and appropriate tool selection for different development tasks.
AHK Hero 2026 01 03 Saturday Hour 1
*Summary*
This AutoHotkey Hero Saturday call features Joe Glines and Isaias Baez discussing automation projects, AI integration, and OCR tools. The session covers newsletter automation workflows, Windows OCR capabilities, and a Google Maps API integration project for business data scraping.
*Key Points*
• [00:00:00] – Newsletter Automation Tool Development
• Joe demonstrates his newsletter creation workflow using hotkeys to categorize content (AI news, humor, quotes)
• Building a JSON-based system to store and randomly select testimonials and quotes
• Plans to use AI to automatically find three relevant news articles based on newsletter themes
• Discusses the balance between manual curation and AI automation for content selection
• [00:06:03] – AI Usage Philosophy and Best Practices
• Debate about whether you need to understand code before using AI to generate it
• Isaias argues AI works well for creative/randomized tasks but struggles with static requirements
• Discussion of trade-offs between AI assistance versus manual coding knowledge
• Examples of successful AI code generation even without full understanding of the output
• [00:07:37] – OCR Tool Development for Gaming
• Isaias presents an OCR solution for extracting player names from game screens
• Compares Windows RT OCR versus Windows Snipping Tool OCR accuracy
• Explores offline AI OCR capabilities built into Windows
• Creates hotkey system to capture screen regions and save text to files for OBS integration
• [00:12:02] – OCR Implementation and Windows APIs
• Technical discussion of Windows RT library versus newer Windows AI imaging APIs
• Comparison of OCR accuracy between different Windows tools
• Investigation of local versus cloud-based AI OCR processing
• AutoHotkey autocomplete functionality and development efficiency benefits
• [00:23:57] – Development Speed and Tool Efficiency
• Isaias completes OCR tool in 40 minutes using autocomplete features
• Discussion of how development tools impact coding speed and accuracy
• Philosophical debate about AI assistance levels in professional versus personal projects
• Examples of successful automation without deep technical understanding
• [00:36:00] – Google Maps API Integration Project
• Irfan demonstrates WebView2 integration with Google Maps for location selection
• Debugging latitude/longitude extraction from map interactions
• Building GUI with AutoHotkey controls embedded around WebView2 component
• Implementing callback system for status updates and progress feedback
• [00:47:54] – API Implementation and User Interface
• Troubleshooting coordinate extraction and API parameter handling
• Adding progress bars and button state management for better user experience
• Successfully generating TSV files with business data from Google Places API
• Discussion of status bar enhancements and progress indicators
• [00:52:00] – Project Architecture and Data Flow
• Explanation of two-phase approach: Places API for business discovery, then detailed scraping
• Using map interface for latitude/longitude selection rather than manual entry
• Planning hidden WebView2 for review scraping while showing progress to users
• Integration strategy for combining API data with web scraping techniques
• [00:56:00] – UI Enhancement and Status Feedback
• Implementing button disable/enable states during processing
• Adding thin progress bars for visual feedback
• Discussion of status bar progress indicators and click handling
• Examples of professional UI patterns for long-running operations
• [00:58:00] – Project Wrap-up and Future Plans
• Summary of Google Maps integration success for business data collection
• Discussion of sharing open-source projects versus client work
• Planning next steps for review scraping and data export functionality
• Scheduling follow-up for status bar progress implementation
*Brief Summary*
The session showcased practical automation development with multiple working demonstrations, from newsletter content management to OCR gaming tools to Google Maps API integration. The team successfully debugged and implemented real-world solutions while discussing the philosophical balance between AI assistance and technical understanding in modern development workflows.
AHK Hero 2026 01 02 Friday Hour 2
*Summary*
This AutoHotkey Hero call features Joe Glines and Isaias Baez discussing various automation tools and techniques. The session covers Google Maps scraping using WebView2, Git repository management best practices, OCR capabilities in Windows, and an in-depth demonstration of AutoHotkey Script Manager’s debugging functionality.
*Key Points*
• [00:00:00] – Google Maps Scraping Tool Demonstration
– Irfan demonstrates a Google Maps scraping tool built with WebView2 and AutoHotkey
– Tool injects custom HTML buttons into Google Maps to extract reviewer data
– Successfully scrapes ratings, reviews, and reviewer information for business outreach
– Discusses API limitations (only 5 reviews) versus browser scraping capabilities
– WebView2 allows seamless integration of web content with desktop automation
• [00:05:50] – Advanced Scraping Techniques and Code Structure
– Shows JavaScript injection methods for creating interactive scraping buttons
– Demonstrates handling timing conflicts between AutoHotkey and JavaScript
– Tool can extract hundreds of reviews by automatically scrolling and loading new content
– Exports data to JSON format for further processing
– Discusses advantages of WebView2 over traditional browser automation
• [00:11:38] – Git Repository Management and File Operations
– Isaias explains safe practices for renaming and moving Git repositories
– Demonstrates how to test for potential conflicts before making changes
– Shows proper use of git status, git remote commands for repository health checks
– Discusses issues with submodules and external references that can break when moving folders
– Covers Git garbage collection for managing large repository sizes
• [00:16:50] – Windows File Explorer Auto-refresh Discussion
– Team discusses inconsistent Windows 11 Explorer refresh behavior
– Some users experience automatic file updates while others require manual F5 refresh
– Explores potential solutions for reliable file system monitoring
– Highlights differences between Windows versions and user configurations
• [00:19:30] – Git and Cloud Storage Synchronization Issues
– Isaias explains conflicts between Git operations and Dropbox/cloud sync services
– File locking by sync tools can break Git commands during commits and operations
– Recommends working locally and using scheduled sync instead of real-time synchronization
– Discusses Task Scheduler solutions for periodic backup to cloud storage
– Covers specific issues with executable file creation and icon modification
• [00:23:06] – OCR Technology and Screen Text Extraction
– Discussion of OCR needs for extracting text from applications that don’t provide data access
– Explores use cases for Citrix/virtual environments where traditional automation fails
– Considers developing area-locked OCR tools that move with windows
– Examines Windows built-in OCR capabilities and potential API access
– Discusses local vs. cloud-based AI solutions for text extraction
• [00:27:40] – Local AI and Automation Tool Evolution
– Reviews past experiences with local AI models for OCR tasks
– Discusses Claude’s superior performance compared to other solutions
– Reflects on the slower-than-expected adoption of AI automation tools
– Covers the evolution from traditional automation to API-based approaches
– Examines why browser automation has become less reliable than direct API calls
• [00:30:15] – Windows Voice Recognition and Snipping Tool Updates
– Demonstrates improved Windows H voice recognition using AI
– Shows Windows Snipping Tool’s new AI-powered text extraction feature
– Tests accuracy of built-in OCR capabilities for numbers and text
– Discusses potential for accessing these AI features programmatically
– Plans to test offline functionality of Windows AI tools
• [00:32:30] – AutoHotkey Script Manager Debugging Features
– Irfan demonstrates advanced debugging capabilities in ASM
– Shows event handling conflicts between Scintilla editor and debugging API
– Implements enable/disable event management for smooth debugging operation
– Covers breakpoint management, variable watching, and step-through debugging
– Addresses stability issues and crash prevention during debugging sessions
• [00:46:11] – Debugging Interface and User Experience
– Detailed walkthrough of debugging icons and their functions (play, pause, step in/out)
– Demonstrates variable inspection and watch list functionality
– Shows how to debug scripts with errors versus normal execution
– Covers breakpoint setting during active debugging sessions
– Explains the relationship between script state and debugging capabilities
*Brief Summary*
The session showcased sophisticated automation techniques ranging from web scraping to advanced debugging tools. Key takeaways include the power of WebView2 for web automation, proper Git repository management practices, and the impressive debugging capabilities being developed for AutoHotkey Script Manager. The team also explored emerging Windows AI features and their potential for local automation tasks.
AHK Hero 2026 01 02 Friday Hour 1
*Summary*
This AutoHotkey Friday office hours session covers several technical topics including Windows security updates affecting file previews, AutoHotkey script templates and requirements directives, object cloning versus copying, UIA automation challenges with Zoom, and web scraping techniques for secure websites. The team discusses practical solutions and workarounds for common automation challenges.
*Key Points*
• **[00:00:00] – Windows Security Update File Preview Issue**
• Recent Windows security update prevents file preview in Explorer for downloaded files
• “Mark of the web” attribute gets applied to files from internet sources including Outlook/Gmail attachments
• Workarounds include registry modifications or scripts to remove the web mark attribute
• Issue affects all file types and requires manual unblocking or automated solutions
• **[00:08:55] – AutoHotkey Script Templates and Requirements**
• Discussion of #Requires directive for specifying AutoHotkey versions and modules
• Template system in AutoHotkey Dash allows custom script templates with predefined includes
• VS Code extension provides autocomplete for version requirements and comparison operators
• File encoding defaults (UTF-8) discussion for cleaner code without repetitive encoding specifications
• **[00:17:46] – Object References vs Cloning in AutoHotkey**
• Objects are passed by reference by default, not copied, for memory efficiency
• Cloning creates independent copies when you need to modify without affecting original
• Functional programming approach requires explicit cloning to maintain object state control
• Use cases for cloning include preventing unintended modifications and preserving object snapshots
• **[00:25:31] – UIA Automation and Detect Hidden Windows**
• Zoom mute button automation using UIA to read button status from floating windows
• DetectHiddenWindows setting can cause issues with complex applications like Zoom
• Applications may have hundreds of hidden windows that complicate element identification
• Recommendation to use DetectHiddenWindows carefully and understand window hierarchy
• **[00:43:18] – Web Scraping Authentication Techniques**
• HTTP request automation using custom fetch functions to handle cookies and XSRF tokens
• Manual cookie extraction from browser developer tools as fallback method
• GUI applications for non-technical users to access hidden website functions
• Bookmarklet creation process from console testing to bookmark storage
• JavaScript injection through WebView controls in AutoHotkey applications
• Balance between AutoHotkey capabilities and specialized tools for specific tasks
*Brief Summary*
The session demonstrates the collaborative problem-solving approach of the AutoHotkey community, addressing both system-level issues like Windows security updates and advanced automation techniques. The team emphasizes choosing appropriate tools for specific tasks while sharing practical workarounds and implementation strategies for common automation challenges.
