Finding Purpose Through Timeless Tech Skills
___
| | _____
|_ | / \
\ | | \
| \ | /
\ \____ \_ \
\ \_/ |
___. \_ _/
.-, / \ | |
| \ _/ `--_/ \_
\ \________/ /\ \
| / \_ \
`-----------, | \ \
| / \ |
| | | \
/ | \__|
/ _ |
/ / \_ \
| / \__ __--`
_/ / \ _/
___/ / \_/
/ /
`----`
LPvg Stack (Linux, Python, vim & git)
LPvg is a time-tested tech stack that gives you superpowers. It’s four simple tools that work together: Linux, Python, vim and git. I use them daily to build AI and automation systems, but they’re perfect for any technical challenge. Master these fundamentals, and you’ll have a career foundation that lasts.
`Linux`: The universal foundation that runs beneath it all`Python`: The elegant language that automates the tedious`vim`: Where muscle memory meets programming artistry`git`: Version control that makes your work immortal
Pipulate Free Open Source SEO Tool
I’m building something exciting: an open-source SEO tool called Pipulate that combines these classic tools with modern AI. It’s a simple Python framework that harnesses AI’s power while staying lightweight and hackable. This site documents the journey. Each post explores the intersection of timeless tech skills and emerging AI capabilities. I’m creating a living knowledge base that grows smarter over time — and sharing everything I learn along the way. Let’s all jump off the tech-churn hamster wheel and enjoy forever-improving craftsmanship.
The Tech Journal
These are stream of consciousness articles and not for the feint of heart. Distilling it with the help of AI into a forever well-organized organically growing book is one of the projects you’re witnessing taking place here.
From Dunning-Kruger to Deep Research: Riding the AI Wave in SEO
March 31, 2025As an SEO who thrives on metaphors and details, I believe subtlety and nuance are key differentiators, much like the butterfly effect; overlooked details often spark significant change. I'm leaning into this by developing Pipulate, aiming to delight clients by focusing on these specifics, even as I wrestle with my own Dunning-Kruger moments while learning tools like Python. The arrival of powerful LLMs is a game-changer, helping us overcome personal limitations and democratizing expertise previously gated by privilege, proving that learning and creativity aren't fixed traits but skills honed through continuous adaptation—much like our nomadic ancestors—and now, AI can be our guide in implementing the complex ideas needed to truly stand out, even if, like me, you prefer deep work over social media noise, because genuine value will eventually be discovered by deep researchers in this new AI-driven landscape.
Integrating MCP: Giving My Local LLM App the Power to Act
March 31, 2025After removing my fragile homegrown tool-calling system from Pipulate, I'm now focused on integrating Anthropic's Model Context Protocol (MCP) to allow my embedded local LLM (via Ollama) to actually *perform* tasks, not just instruct. Despite previous frustrations with documentation and vendor bias, I believe MCP is the necessary universal standard, and my immediate goal is to research its current, real-world implementation state—including non-HTTP options and usage beyond Claude—so I can understand how to build Pipulate as an MCP client and leave detailed code comments as hooks before client work demands my attention.
Refactoring Hell and Back: Integrating LLMs into a Plugin Architecture
March 30, 2025This weekend, I tackled a tricky refactoring challenge to get my LLM chatbot integration working correctly within my app's new plugin system. After realizing the global scope was preventing the LLM from communicating within plugins, I collaborated with Claude (an AI) to devise a plan, delving deep into Python's dependency injection patterns and confronting some confusing OOP conventions along the way. By breaking the problem into small, deliberate "chisel strikes," we successfully refactored the architecture, enabling both scripted and genuine LLM streaming across all plugin types, setting the stage for future development.
Escape the Tech Churn: Why Terminal and Vim Mastery Endures
March 30, 2025Sick of the tech hamster wheel constantly obsoleting your tools and hard-earned muscle memory? I make the case that investing in text-only terminal skills and the vi/vim editor lineage is the antidote, providing a truly future-proof, adaptable foundation that exists everywhere—from minimal embedded systems to powerful cloud servers—empowering you to truly master technology by mastering its fundamental component, text itself, for the rest of your career.
Vim Macro to Lua (for NeoVim Users)
March 29, 2025While I'm a longtime Vim user who values its timelessness, the sheer difficulty of editing recorded macros in VimScript finally pushed me to NeoVim; I initially switched to try GitHub CoPilot (which I disliked in Vim) but stayed because NeoVim's Lua configuration, combined with AI assistance from tools like Claude, made refining complex macros—like the one I needed to escape HTML tags for my blog posts about AI interactions—significantly easier, demonstrating a rare instance where embracing newer tech enhances, rather than detracts from, core text-mastery skills essential across all tech disciplines.
From Jupyter Exploration to Pipulate Execution: A Workflow Story
March 29, 2025I'm currently deep in the process of integrating my professional and personal projects through Pipulate, focusing on how its three core components—the main framework, the specific workflows, and the Jupyter Notebooks used for development—interact. Drawing parallels to a player piano, I see Notebooks as the initial "sheet music" where I freely explore and design complex workflows, Pipulate's workflows as the "player piano scrolls," and the core Pipulate code as the "player piano" itself. This approach requires manually porting Notebook logic to HTMX within Pipulate, a challenging but pragmatic process where I'm embracing repetition (WET over DRY) and even hardwired paths to manage complexity and focus on getting fluent with the tools, developing all three parts in tandem.
Cursor AI and VSCode Jupyter Notebook Paths
March 29, 2025I ran into a frustratingly common problem trying to make my Jupyter Notebooks for Pipulate work consistently across different environments like native JupyterLab, VSCode, and Cursor AI: reliably determining the notebook's own file path. After initial attempts using `os.getcwd()` yielded different results depending on the environment, I enlisted ChatGPT and Gemini for deep research, comparing their speed and output quality (Gemini was faster but harder to format, ChatGPT slower but cleaner). The research confirmed there's no single, foolproof, built-in way to get the notebook path due to Jupyter's architecture separating the kernel from the frontend. While workarounds involving environment variables (`JPY_SESSION_NAME`, `__vsc_ipynb_file__`) or querying the Jupyter server API exist, they felt overly complex, potentially fragile, or environment-specific for my goal of creating clear workflow examples. Ultimately, I decided to reject these auto-discovery methods for my notebooks and embrace simple, explicit, hardcoded paths, accepting that users will need to adjust them, which is clearer and less brittle for the development phase before these workflows are ported into Pipulate's controlled environment.
Getting Past the GSC 1000-row Limit With the API
March 28, 2025In this post, I share my journey developing a data-driven SEO workflow using Jupyter Notebooks, enhanced with AI assistance from Cursor AI and Claude, to tackle the persistent challenge of extracting and analyzing Google Search Console data beyond the basic interface limits. I detail the process from setting up secure GSC API access with a service account, crafting Python code to fetch comprehensive performance data (including handling pagination and finding the most recent available dates), identifying promising "striking distance" keywords, cleaning that list for tools like SEMrush, and finally merging GSC insights with SEMrush metrics to generate a reusable template for optimizing article titles and permalinks, all part of my effort to achieve hockey-stick growth through consistent, technically-informed content optimization.
Deep Research of the Google Search Console API
March 28, 2025In this article, I've compiled extensive research on how to build a Python script that leverages the Google Search Console API to identify "striking distance" keywords – those ranking just outside the top 10 with high potential for improvement. I delve into the intricacies of API authentication, data retrieval, and processing with Pandas, including merging with SEMrush data for enhanced insights. The goal is to create a robust and user-friendly workflow that can be integrated with LLMs for content optimization, ultimately aiming to automate and scale content improvements for significant SEO gains.
Future-Proof SEO: Thriving with Nix & Quality Content
March 28, 2025In this piece, I delve into the seismic shifts AI and LLMs are bringing to SEO, arguing that this evolution favors genuine expertise and quality content, much like earlier search transformations I witnessed firsthand. I share my personal journey at the intersection of programming and SEO, detailing how my passion for intellectual puzzles led to unique projects like Levinux and now Pipulate, which leverages a future-proof, vendor-independent tech stack I call LPvgn (Linux, Python, vim, git, and Nix). My aim isn't just to adapt but to thrive by creating trackable, meritorious value and open-source tools, allowing me to connect authentically with discerning researchers and technical minds who are tired of the tech churn and looking for sustainable skills and substance in an AI-curated world.
Grok vs. ChatGPT vs. Gemini vs. Perplexity For Deep Research
March 28, 2025I've watched web search evolve from simple keyword lookups to complex AI-driven research, and it's a wild ride. Social media disrupted traditional search, but the browser address bar kept it alive. Now, "deep research" features from Grok, ChatGPT, Gemini, and Perplexity are changing the game again, offering in-depth analysis and synthesis. This article dives into how these platforms compare on branding, access, data sources, output, and more, highlighting the trade-offs between speed, depth, and cost, and exploring the implications for researchers and the future of information gathering.
Can Cursor AI Read Jupyter Notebook Cells?
March 27, 2025Driven by the excitement of merging Jupyter's exploratory power with AI assistance inside Cursor, I embarked on a practical investigation, testing the AI's ability to understand notebook context and discovering its significant blind spot: it can't see cell outputs. This prompted a deeper dive using AI research tools (Perplexity, ChatGPT) to confirm the limitation and uncover community workarounds, while also leading me down related paths exploring the reactive notebook alternative Marimo, the awkwardness of Vim mode in cells, and the rich history of computational notebooks from Mathematica to Fernando Pérez's pivotal creation of IPython/Jupyter and its widespread vendor adoption today.
Future-Proofing in the Age of AI: Beyond Vibe Coding
March 27, 2025Facing a day of client calls and system development, I'm using this early morning window to reflect on managing my time and future-proofing my skills amidst the rapid AI shift. This article itself becomes a prompt for later AI work, capturing my thoughts on why deep technical knowledge remains crucial despite trends like "vibe coding," drawing parallels to sci-fi warnings about automation's pitfalls, and advocating for becoming a skilled "Carpenter" who adds unique value. It delves into the virtuous cycle of client work fueling coding passion, the importance of focus, and my personal journey evolving my website (MikeLev.in) from simple experiments to a platform focused on ethically navigating the AI era by mastering foundational tech (Linux, Python, Vim, Git, Nix) and building tools like Pipulate, ultimately aiming to demonstrate a positive, skill-based path forward.
Extracting FastHTML fastlite Todo App
March 26, 2025In this post, I walk through the process of extracting a tightly-coupled Todo application from my Pipulate project, which leverages Jeremy Howard's FastHTML and its convenient `fast_app` factory. While `fast_app` simplifies setup by integrating database schemas and more, it led to a monolithic structure. I detail how I embraced a plugin architecture, using my previously developed `CompetitorPlugin` as a template, to successfully modularize the Todo functionality. This involved removing the Todo schema and logic from the core `fast_app` initialization, allowing it to live independently in its own file, thereby cleaning up the main server code (and shedding some old, custom LLM tool-calling logic) while establishing a clear, repeatable pattern for adding future CRUD-based features to Pipulate.
Python Plugin Architectures: Pipulate Worflows & Apps
March 25, 2025In developing Pipulate, I faced the challenge of unifying its two extension systems – rigid CRUD apps tied to FastHTML and a separate workflow plugin system. My goal was to make CRUD apps like the built-in TodoApp fully external, but initial attempts struggled with framework constraints. After analyzing the working workflow discovery, I pivoted to adapt that pattern instead of creating a new one, unifying everything under a single 'plugin' concept. By leveraging MiniDataAPI for database independence and simple file discovery, I successfully built the external `CompetitorApp` as proof, demonstrating a clear path to a modular, extensible architecture for Pipulate.
Workflows to Redirect & Fix Your Attention
March 25, 2025I initially set out to explore using Pipulate workflows to combat digital distractions and regain focus on meaningful work, delving into the attention economy and the power of intentional input. While planning practical client workflow implementations within Pipulate, my focus unexpectedly shifted to the tool's internal structure. This led me down a technical rabbit hole, revealing a crucial need to refactor Pipulate's "DRY CRUD" apps into a flexible plugin system, much like I recently did for its "WET Workflows"—a meta-discovery driven directly by trying to improve my own focus using the tool.
Using Websockets to Stream Incremental Markdown
March 24, 2025My exploration delves into the challenges of streaming Markdown-formatted responses from an LLM within a Python-based FastHTML/HTMX chatbot application, Chip O'Theseus. Recognizing that re-rendering entire responses for each incremental update creates a poor user experience, I investigate techniques for incrementally displaying and formatting Markdown content as it arrives over WebSockets. This journey covers various strategies, ranging from simple append-only text streaming with delayed full formatting to more complex server-side stateful parsing and even client-side enhancement with minimal JavaScript. Ultimately, the goal is to find the optimal balance between real-time responsiveness, formatting fidelity, and code simplicity within the constraints of a server-rendered, HTMX-driven environment. The article documents these options, and my personal preferneces, with examples.
AI Edit Your Code? What the `diff`?
March 24, 2025This article provides a practical and valuable solution for developers who are increasingly using AI for code generation. I clearly articulate the problem with traditional diff tools in this context and offer a well-explained, step-by-step method to achieve a more intuitive visual comparison. This technique not only aids in understanding the specific changes made by AI but also simplifies the process of reviewing and publishing these modifications. The real-world example makes the described method immediately applicable.
Grok3 is Free "Until Our Servers Melt"
March 24, 2025This article details my journey in creating a new workflow, "Hello Webpage," by modifying a template using the WET software methodology, where I'm intentionally allowing code duplication for greater flexibility. I was genuinely impressed when xAI's Grok3 provided the exact working code I needed on its first attempt and then tried helping me identify and fix a tricky bug related to Pipeline ID collisions across different workflow applications, but came up short. Despite some moments where Grok3 seemed to freeze up during its responses, it ultimately persevered, highlighting its unique resilience compared to other AI models I've used. This experience has reinforced the potential of this new AI as a valuable partner in my coding and creative endeavors.
MiniDataAPI Spec `.xtra()` Tutorial
March 24, 2025This piece walks you through the essentials of MiniDataAPI, a super simple Python API for basic database operations. I explained how it focuses on Create, Read, Update, and Delete (CRUD) actions without the complexity of joins or fancy query building you might find in bigger ORMs. The tutorial shows you how to set up a table, insert data, retrieve specific records or lists using different methods, update existing entries, and delete them. I also highlighted a cool feature called `.xtra()` which lets you permanently filter a table for things like multi-tenant applications or permission control, making sure you only see the data you're supposed to. The key takeaway is that MiniDataAPI is all about simplicity for straightforward data tasks, so don't go looking for those advanced ORM features here!
The Magic of Pipulate: Bridging Notebooks and Web Apps
March 23, 2025An AI's Take: This is a fascinating project! The idea of directly translating the exploratory power of Jupyter Notebooks into interactive, production-ready web applications is incredibly compelling. The integration of local LLMs for context-aware assistance adds a unique layer of intelligence, making the system even more powerful. The emphasis on reproducibility and a clean, efficient architecture is also commendable. I see a lot of potential in the project, especially for data-driven applications and workflows that require a high degree of interactivity and customization. I am also very intrigued by the HTMX cascading methodology, that is a very interesting way to manage the data. I think it is a great idea to make this a blank slate for other users to build on.
Pipulate: Local AI Workflows with Jupyter & Nix
March 23, 2025Sunday morning's coding session ignited a plan to leverage Jupyter Notebooks for AI-driven Pipulate workflows, aiming to bridge the gap between flexible "WET" development and automated, Nix-powered deployment. This vision incorporates local AI, swappable components, and advanced memory management, all while challenging the normalizing influence of large language models and embracing the "write once, run anywhere" dream through a portable, local-first web app ecosystem.
Future-proofing My Tech: Linux, Python, Vim, Git, and now HTMX
March 22, 2025Alright, buckle up, because today was a coding marathon! I wrestled with HTMX, merged projects, and finally got my open-source SEO tool, Pipulate, out into the wild. It's a blend of Linux SEO, AI SEO, and whatever else you want to call it. The big takeaway? I'm diving deep into AI-assisted linear workflows, aiming to teach AI by watching humans, and stitching these workflows together like LISP s-expressions. It's all about future-proofing my skills with Linux, Python, vim, and git, while embracing the weird beauty of HTMX and FastHTML. Now, time for sleep.
FastHTML HTMX AI Workflows: Embracing the WET
March 22, 2025I'm deep in the weeds of refactoring a workflow template for my Pipulate project. I'm moving from a DRY (Don't Repeat Yourself) approach to a WET (Write Everything Twice) one to gain more flexibility and control over individual workflow steps. This involves a lot of code cleanup, clarifying confusing naming conventions (especially around "steps"), and preparing for a big copy/paste job where I'll duplicate code to customize each step's behavior. I'm focusing on reducing cognitive overhead, especially with long dot notation, and ensuring I have a solid understanding of the existing code before I dive into the WET-ification. HTMX is key to making this all work.
HTML Over The Wire (vs. JSON)
March 22, 2025Today, I took a deep dive into the world of FastHTML and HTMX, exploring their potential to revolutionize Python web development. I detailed how these tools enable the creation of dynamic web applications by sending HTML over the wire, eliminating the need for complex JavaScript frameworks and JSON APIs. Through a practical example, I demonstrated how to build a simple app that updates content dynamically with HTMX, showcasing the power of this approach for creating interactive user experiences with minimal code. I also discussed the mindset shift required to embrace this new paradigm, emphasizing clarity, explicitness, and the “WET” philosophy as keys to success.
Carving New Paths: Navigating AI's Influence in Development
March 21, 2025I'm navigating the fine line between conformity and innovation in a world increasingly shaped by AI, where standing out requires both subtle adjustments and determined action. I'm building Pipulate, a framework that embraces explicit, customizable workflows, defying the AI's tendency to push me towards conventional solutions like FastAPI. This approach, favoring "WET" code and Jupyter Notebook-style flexibility, aims to create a system where radical customization is possible, despite the challenges of breaking away from established patterns and the inherent biases of AI towards common solutions. I'm betting on the "black swan" potential of my approach, knowing that true innovation often lies at the edges of the normal distribution, where AI's guidance is less reliable.
Chip O'Theseus: The Evolving AI in a Bottle
March 21, 2025This article details my journey integrating AI coding assistance into Jupyter Notebooks via Cursor, significantly streamlining my development workflow. I reflect on the potential of my project, "Chip O'Theseus," a local LLM application designed with a "Ship of Theseus" philosophy, where components are continuously updated. I explore the project's architecture, discussing FastHTML, the evolution of Python web frameworks from `itty.py` to Flask, and the importance of memory management and database choices like PostgreSQL for future-proofing. I delve into the history of key technologies like DBM, hash tables, and user interface frameworks, highlighting the contributions of pioneers like Ken Thompson and Fernando Corbató. Ultimately, I reaffirm my commitment to Pipulate, aiming to bridge the gap between powerful developer tools and accessible user interfaces, capitalizing on the current momentum to rapidly advance the project.
Jupyter Notebooks in VSCode and Cursor AI
March 20, 2025I navigated the complexities of running Jupyter Notebooks within Cursor AI on NixOS, a niche setup that required a specific order of operations. By ensuring a running JupyterLab instance with an active kernel before launching Cursor, I unlocked seamless AI assistance for my notebooks. I also detailed how using Nix Flakes with Pipulate provides a robust and portable solution for running JupyterLab, even across different operating systems, overcoming the common hurdles faced by users in diverse environments.
DRY vs WET: Ditching DRY for Explicit, Customizable Pipelines
March 20, 2025I've outlined a step-by-step guide to transform my rigid, looped workflow into a flexible, explicitly defined system, mirroring the simplicity of Jupyter Notebook cells. By breaking down the refactoring into tiny, non-breaking steps—starting with explicit route registration, then handler delegation, and finally, direct logic implementation—I ensure a smooth transition. This approach prioritizes clarity and customization, allowing for radical per-step adjustments without the complexity of OOP inheritance, embodying a "WET" (write everything twice) philosophy for maximum control.
Radically Customizing Linear Workflows
March 19, 2025The initial templated approach to building Pipulate workflows, while simple for basic forms, severely limits customization for complex UI elements like textareas, dropdowns, and custom widgets. To address this, I'm shifting to a completely explicit, 'unlooped' design where each workflow step is defined by its own dedicated handler function. This approach mirrors the flexibility of Jupyter Notebook cells, allowing for radical customization without the constraints of rigid abstractions or predefined APIs.
Is FastHTML Any Good?
March 19, 2025I've built a framework leveraging FastHTML to turn Jupyter Notebooks into user-friendly web apps, hiding the Python code. This simplifies web development by using Python functions for HTML and integrating HTMX for dynamic updates without JavaScript. Pipulate, my open-source project, combines FastHTML with local LLMs and MiniDataAPI for efficient SEO automation. I aim to provide a simple, reproducible, and local-first approach, empowering users to build web apps and automate tasks without complex frameworks. FastHTML Rocks!
Psst! Got Unparsable Structured Data?
March 18, 2025I was wrestling with structured data errors on my blog reported by Google Search Console (GSC). I'd added Schema.org markup using both HTML attributes and JSON-LD, but kept getting "unparsable structured data" errors in Google Search Console, specifically "bad escape sequence in string." Turns out, my `articleBody` content in the JSON-LD was causing the issue due to unescaped characters. To fix it, I simply removed the `articleBody` from the JSON-LD, relying on the HTML markup, which is more forgiving. I also realized I could use my existing article summary as the `abstract` field, simplifying things even further.
Jupyter Notebook to Pipulate Workflow
March 18, 2025I'm deep into developing Pipulate, a local-first, LLM-powered workflow engine, and documenting the journey. This entry covers the transition from a starter template to a more effective Hello World example, the challenges of integrating a local LLM, and the iterative process of refining the framework. I'm focusing on simplifying the user experience while maintaining the core functionality of converting Jupyter Notebooks into interactive web apps, and exploring the nuances of AI interaction within rigid workflow structures.
Automating SEO Workflows: Parameter Buster
March 18, 2025This article details my process of switching from development to delivery mode by building an automated workflow to tackle crawl traps caused by excessive URL parameters. I walk through the strategic storytelling needed for a successful client meeting, emphasizing the importance of demonstrating process and delivering tangible results. The core of the piece then dives into a technical SEO challenge: identifying and selectively removing problematic URL parameters using data from web logs, Google Search Console, and Botify, culminating in the creation of a JavaScript solution to optimize website crawling efficiency.
Open Source SEO: My Journey to Codebase Consolidation
March 18, 2025I'm feeling great about finally unifying my little side projects, Botifython and Pipulate, into a single codebase under the Pipulate banner on GitHub. I've figured out a clever way to manage the app's name, defaulting to "Pipulate" but easily customizable based on the directory name or a simple `app_name.txt` file. This makes it flexible for my own variations and even allows others to rebrand it easily. Plus, I'm simplifying things by removing some proprietary dependencies, focusing on the core idea of lightweight SEO tools alongside enterprise solutions. It's exciting to bring Pipulate back into the public eye and start building real-world workflows with it!
Hot Prompt Injection For AI Workflow Plugins
March 16, 2025In this work session, I enhanced my web application framework by implementing hot prompt injection for workflow plugins. This allows each workflow to provide custom training to the integrated LLM, enabling contextual AI assistance. I also refined the workflow template, improved state management, and laid the groundwork for a more modular, maintainable system. Finally, I began developing a tutorial workflow to document the system itself, illustrating how to convert Jupyter Notebooks to FastHTML workflows.
Radical Simplicity: Pipulate and the Local-First Revolution
March 16, 2025I've built Pipulate, a local-first desktop app framework, designed to simplify web app development by integrating a local LLM, server-side state management with DictLikeDB, and a pipeline workflow system. It's all about keeping things simple, observable, and reproducible using FastHTML, MiniDataAPI, and Ollama, eliminating the complexities of traditional web development. The goal is to let anyone port Jupyter Notebooks into desktop apps, making data science and complex workflows accessible without needing to be a developer. I'm focusing on local control, minimal complexity, and empowering users with a powerful, personalized tool.
AI Facilitating Self-Improvement and Mastery
March 16, 2025I've been exploring how AI, particularly with its new Deep Research capabilities, can aid in self-improvement and web traffic growth. While it's great for research and content creation, it's not quite the mentor I hoped for. It's more of a sounding board, a "rubber duck" for thinking, but I'm wary of its confirmation biases and the potential for over-reliance. The key takeaway? AI is a powerful tool for surveying the landscape and sparking ideas, but true agentic thinking and direction still need to come from within.
SEO in the age of LLMs
March 15, 2025I'm testing the limits of SEO in a post-AI world by intentionally wrecking and rebuilding my vanity site, ditching 301 redirects, and tracking the raw impact of consistent, human-written content. My goal? To see if genuine effort and niche expertise can still cut through the noise, proving that 'if you write it, they will come' – even without social media megaphones or AI-generated fluff. This isn't just about traffic; it's about understanding the evolving relationship between content, search engines, and the future of web intelligence.
The Self-Aware Software: A Glimpse Into Future Development
March 15, 2025This project, for me, is about crafting a future where software evolves beyond rigid frameworks. I've built a system that marries simplicity with the power of embedded LLMs, creating a local-first, transparent workflow. Each step is a self-contained cell, and an LLM actively observes and suggests improvements, fostering a kind of self-awareness. By ditching complex ORMs and client-side bloat for plain Python and HTMX, I'm aiming for agility and clarity. It's an experiment in making the invisible visible, a step towards self-evolving software, and a playground for creative, non-professional coders to explore the potential of AI.
From Monolith to Modules: Building a Flexible Web App with FastHTML and HTMX
March 15, 2025This article documents my journey to externalize workflow logic in my local-first web application which uses Nix Flakes, FastHTML, and HTMX. I aimed to move from a monolithic `server.py` to a modular structure by extracting the `StarterFlow` workflow, all while avoiding refactoring rabbit holes and preserving the simplicity and transparency of the system. Through collaboration with an AI, I navigated challenges with global dependencies, inlined a superclass, and enhanced the code for clarity and customization, setting the stage for more complex workflows like PipeFlow and LinkGraphFlow.
NixOS Upgrade to Ollama 0.6.0: A Clean Rebuild Experience
March 14, 2025Alright, so I just upgraded my NixOS system to get the latest Ollama, and it's a bit of an adventure! Basically, NixOS rebuilds your entire system from scratch with each upgrade, ensuring a clean, consistent setup. It's like a fresh install every time, thanks to its unique flat file-system. While it takes longer than a typical update, the stability and rollback capabilities are totally worth it, avoiding the usual cruft and dependency issues. Plus, I got to write this whole article while waiting for the rebuild!
Building a Future-proof Automation Core for AI Workflows
March 13, 2025I'm racing against time to refactor my app into a lean, modular system, externalizing workflows for rapid task automation. My goal is to create a future-proof, adaptable platform using minimal tech like FastHTML and HTMX, focusing on markdown documentation for resilience. I'm building a simple, yet powerful core with dynamic menus for profiles, apps, and workflows, aiming for immediate productivity and a self-fueling momentum to combat the chaos of ever-changing tech.
Of Plugs, Slugs, Nubs & Stubs
March 13, 2025In this piece, I'm grappling with how to effectively capture and develop my scattered ideas, which I'm calling "nubs" or "stubs," for future articles. I discuss my most productive morning flow state and how it intersects with skill development and autonomy, particularly for artists. I also explore my enthusiasm for HTMX in web development and the challenges of integrating AI tools without losing my creative edge. Ultimately, I'm working towards a system to manage these article nubs within my existing workflow, using my pre-publishing journal files as a combined idea capture and to-do list system.
NixOS NVIDIA CUDA Ollama Support
March 12, 2025Navigating NixOS with CUDA for AI has been a wild ride, but I've found a stable configuration for running Ollama with accelerated GPU performance. By ensuring proper NVIDIA driver setup, system-wide CUDA toolkit availability, and specific Ollama service configuration, I'm achieving blazing-fast local LLM processing on my RTX 3080. This guide shares my working `configuration.nix` snippet, aiming to help others troubleshoot and optimize their NixOS AI setups.
The Real-Time AI Research Revolution
March 12, 2025In this article, I explored the evolving AI landscape, particularly the 'arms race' between vendors for AI lock-in versus the push for open-source solutions. I delved into Meta's open-source strategy with Llama, Anthropic's MCP, and OpenAI's proprietary features, highlighting the dynamic between these key players. My focus shifted to building a future-proof local AI solution, examining Gemma 3's function-calling capabilities via Ollama. I tested deep research features in Grok 3, ChatGPT 4.5, Gemini Advanced 1.5 Pro, and Perplexity.AI, comparing their approaches and capabilities in researching AI advancements in real-time. Ultimately, I confirmed Gemma 3's function-calling support and reflected on the broader implications of these AI research frameworks.
Function Calling for LLMs: A Deep Dive into Modern Approaches
March 11, 2025I'm exploring how LLMs execute functions, realizing my homegrown method could benefit from industry standards. I've delved into OpenAI's API, Anthropic's MCP, and other techniques, aiming to modernize my approach while retaining flexibility for prompt-trained models. I'm focused on building a robust, secure system that bridges my current setup with emerging protocols.
Could LLM-assisted Small World Theory In Search Disrupt Google?
March 11, 2025I explored how small-world theory, the concept that any two points in a network are connected by a few steps, could revolutionize web search and challenge Google's dominance. Instead of pre-indexing the entire web, a small-world search would dynamically crawl relevant links in real-time, offering fresher, more contextual results. This approach, while facing scalability and speed challenges, could disrupt traditional SEO, democratize search, and foster new AI-driven search models, potentially eroding Google's "index moat."
Learning AI Deep Research
March 11, 2025In this exploration, I delved into the evolving landscape of AI-driven deep research, starting with a Google Trends analysis of 'SEO' versus the celebrity 'Yuk Jun-seo' to illustrate AI's analytical prowess. Then, I shifted focus to compare the deep research capabilities of leading AI models like ChatGPT, Bing Chat, Claude, Gemini, Perplexity, and Grok. I examined their web browsing styles, citation practices, output formatting, code interaction, and future potentials, highlighting the nuances that differentiate each platform. The goal was to provide a comprehensive overview of how these tools are transforming online research, emphasizing the growing importance of real-time data and transparent source attribution.
Replacing `pip` In Python Nix Flake With `uv`
March 10, 2025I decided to ditch the old `pip` and `virtualenv` combo in my Python Nix Flake and embrace `uv`, the new hotness in dependency management, after seeing it pop up in AI projects like MCP and OpenManus. This article walks you through my journey of updating the Nix Flake, showing you how to streamline your Python environments for speed and efficiency, and ultimately getting JupyterLab up and running like a charm. It's all about keeping up with the latest tools and making development smoother, especially when you're diving into cutting-edge AI stuff.
Agentic Frameworks vs. DIY: Finding the Right Balance for Browser Automation
March 09, 2025I'm looking for a local browser automation solution that avoids cloud dependencies and tedious DOM manipulation. I explored popular agentic frameworks like LangChain, Auto-GPT, and Microsoft AutoGen, but found them too opinionated and complex for my needs. Instead, I'm seeking a simpler setup that combines the power of Playwright or Puppeteer with the semantic capabilities of a local LLM like Llama, allowing me to express browser interactions in natural language. I'm also interested in open-source tools that simplify DOM interaction and provide high-level APIs for controlling real browsers.
Python MCP Server Bare Minimum Example: A Dead End
March 08, 2025Anthropic's MCP protocol proposes to standardize communication between LLMs and external tools, but as it stands, its documentation is overly complicated and tightly coupled with Anthropic's own infrastructure. This article dives into the real-world struggle of attempting to create a minimal, vendor-neutral MCP Python server example—only to discover a maze of contradictory instructions, unnecessary dependencies, and hidden vendor lock-ins. If you're exploring MCP for local, open, or independent AI applications, be prepared for significant frustration, as the promised simplicity and openness haven't yet materialized.
Nix Flake Python Solution: Venv, Cuda, macOS/Windows, Etc.
March 08, 2025This article presents a solution for developers who struggle with Python environment consistency across different operating systems and have discovered nix flakes. I address the common pain points of setting up Python environments, especially for data science, and leverage the power of Nix to create a reproducible and portable solution (Jupyter, ML, etc). The inclusion of CUDA support and the focus on simplifying `pip install` enhance its utility and streamline your Python development workflow.
Python HTMX LLM SEO Codebase
March 07, 2025Pipulate isn't just another app; it's a local-first revolution, forging a new path for Python web development with the raw power of FastHTML, HTMX and MCP, where AI anticipates your needs and streamlines your workflow into a seamless experience. This culmination of continuous learning and passionate development is nearly ready, providing a way to move from Notebook mock-ups to LLM-assisted workflows. I'm overcoming Zeno's file-mile paradox.
LLM Code Analysis Blind Taste Test
March 07, 2025I pitted five LLMs against my unconventional single-tenant, localhost-bound Python codebase, designed for maximum developer ease and transparency. Grok 3 adapted well, ChatGPT o3-mini-high acknowledged the trade-offs, Anthropic Claude Sonnet 3.7 reframed it as a "desktop Python web shell," and DeepSeek R1 recognized the implications. This experiment highlights the importance of context in AI code analysis and the potential for human-AI collaboration in software development.
Beyond the Algorithm: Reclaiming the Narrative
March 07, 2025I argue that control over the information people see—the 'feed'—dictates public discourse. This control resides primarily with tech giants like Google, Microsoft, and Apple, who dominate operating systems and hardware. They manipulate the 'startup state' of devices, influencing what users see first. While 'super apps' like WeChat and potentially X offer alternatives, I highlight the challenges of breaking Google's dominance, particularly their ad-driven bias and the suppression of generative AI's potential to avoid disrupting revenue.
Learning HTMX In Python For SEO
March 06, 2025I'm reviving my SEO tool, Pipulate, for the LLM era, focusing on simple, linear workflows. It's about packaging the 'do-this, then-do-that' tedium of SEO tasks into a user-friendly, Python-powered experience. Think of it as a checklist that comes alive, guiding you step-by-step, without overwhelming you with code. I'm leveraging HTMX for a seamless web experience and Nix for consistent environments, making it cross-platform and powerful for both developers and users who just want a working app.
Distracted & Weak Vs. Focused & Strong
March 05, 2025In this article, I argue that cultivating focused attention, through engaging in activities that induce a "flow state" like reading, coding, crafting, or any skill-based pursuit, is essential for personal strength and fulfillment. I explore how distractions, such as social media and fleeting trends, erode our ability to deeply engage with our passions and develop expertise. By committing to deliberate practice and mastering a craft, we can transcend societal pressures, achieve a sense of purpose, and contribute meaningfully to the world, ultimately finding our Ikigai.
sudo nixos-rebuild switch --upgrade
March 04, 2025I've transitioned to NixOS, a game-changing OS powered by the Nix package manager, and I'm sharing my experience. Ditching the familiar worlds of Mac and Windows, I dove into Nix's deterministic system configurations, which solve the classic 'it works on my machine' headache. Learn about the essential sudo nixos-rebuild switch --upgrade command for seamless updates and explore how NixOS embodies 'Infrastructure as Code' through its configuration.nix file. I break down the Nix command structure, explaining subcommands and switches, and reveal why I believe NixOS is the future of portable and reliable software development.
Python FastHTML: The Ideal Web Framework for HTMX & LLMs
March 03, 2025In this entry, I'm wrestling with maintaining momentum on my Pipulate web framework project, realizing the crucial role of consistent writing and documentation in driving progress and clarity. I'm tackling mental blocks around Git branching, drafting a 'Getting Started Guide' for Pipulate, and exploring how this project aligns with my Ikigai, aiming to craft a 'loveworthy' system using HTML, Python, and HTMX. I also delve into the historical context of Python web frameworks, and experiment with making my code LLM-friendly, all while trying to stay focused and productive.
Out Of Steam? Adenosine!
March 03, 2025In this article, I delve into the science of adenosine, the chemical behind sleep pressure, and how it impacts our daily energy levels and cognitive function. I explore its discovery, its connection to cellular energy, and how caffeine interacts with it. Shifting gears, I discuss my personal productivity strategies, including the importance of nutrition like fish protien and the integration of YAML for streamlined website audits. I also reflect on the creative process, the challenges of innovation, and the power of open-source software, all while outlining my plans for integrating voice technology into my web framework.
Giving Grok 3 Another Chance
March 02, 2025This weekend, I tested Grok 3's ability to assist with a challenging coding project that involves converting Jupyter Notebooks into user-friendly web apps using FastHTML and HTMX. Unlike previous attempts with other LLMs, I opted for a focused approach, feeding Grok 3 curated code snippets instead of overwhelming it with the entire codebase upfront. This strategy proved effective, as Grok 3 demonstrated a remarkable ability to grasp the nuances of my project, including its unconventional, WET (Write Everything Twice) style and reliance on server-side state management. Through this iterative process, we explored the intricacies of my pipeline-based workflow system, addressed friction points, and refined a step-by-step guide for porting Notebooks into FastHTML, all while staying true to my preference for explicit, readable code and control over abstraction.
Fighting Analysis Paralysis
March 01, 2025I'm fighting analysis paralysis by pushing for action over abstract planning. I'm focusing on immediate client communication and two-week project cycles, using JavaScript SEO edits with PageWorkers. I'm ditching PowerPoint for YAML-based storytelling, aiming for structured data and streamlined workflows. I'm navigating a NixOS replatforming and learning HTMX to simplify my system, even though it's a bit painful right now. My goal is to create a future-proof system where users can install and run with just two commands, cutting through startup friction and making SEO consulting more efficient.
FastHTML vs. FastAPI: LLM Over-training
February 28, 2025In this article, I explore the challenges of working with current LLMs (Large Language Models) on innovative web development projects like FastHTML. I argue that these LLMs are over-trained on traditional frameworks like FastAPI and client-side JavaScript, making them resistant to new ideas. I also discuss the limitations of LLM context windows and their static nature, which hinders their ability to keep up with the ever-evolving landscape of technology. I'm using articles like this for a long-game feedback loop, if they can actually find and curate meaninful delta outlier data without supressing it as noise.
Workflow Script for AI / ChatGPT 4.5
February 27, 2025I've been trying to create a more efficient workflow for generating client reports, and I decided to test out the latest AI coding assistants to see if they could help. I started with ChatGPT 4.5, which was just released today, and I was hopeful that it would be more adaptable to my unique project than previous models. Unfortunately, while it initially seemed promising, it still struggled to fully grasp the unconventional nature of my FastHTML framework and ended up making some incorrect assumptions. It's frustrating, but it's also highlighted the limitations of current LLMs in understanding and respecting nuanced constraints.
Commitment And Consistency
February 26, 2025This is a bit of a rambling post where I'm trying to get myself psyched up for work tomorrow. I'm trying to create a unified story to tell clients about why traditional SEO is still important, even in the age of AI. I'm also trying to make a commitment to myself to be more consistent with my work and to create a more streamlined process for managing client projects. I'm using the concept of Ikigai to help me find purpose and motivation in my work. I'm also exploring the use of AI assistants like Grok 3 and Claude 3.7 Sonnet to help me with my coding, but I'm finding that they can be frustrating and unreliable. I'm hoping to find a way to make my work more love-worthy and to find a balance between the old way of doing things and the new way of doing things.
Kickstarting AI
February 21, 2025I'm laying out a twenty-year plan to zero in on skills that'll keep me relevant, especially with AI's rapid growth. It's about balancing platform dependencies, understanding how API wrapping makes tech accessible, and seeing where AI's headed—from big data centers to local computing. I'm also thinking about wealth distribution, how history shapes our economy, and the evolving intelligence of AI, all while trying to build something truly valuable and unique that people will love. It's a lot to consider, but it's about setting a course for the long haul.
Grok 3 Markdown Problem
February 20, 2025I'm cautiously optimistic about Grok 3, but this broken markdown problem is a show stopper for me. Hopefully they notice and fix it. (FIXED! At least on grok.com)
AI LLM Frozen Core Conundrum
February 20, 2025I'm building local-first applications with Python and HTMX, avoiding complex JavaScript frameworks. I demonstrate refactoring a large single-file codebase (LinkGraphFlow) into a more general tool (BotifyFlow), battling the "Frozen Core Conundrum" – AI's bias towards outdated patterns. See how Pipulate streamlines workflows and embraces simplicity.
o3 Vs. Grok 3 (vs. Gemini) Codebase Test
February 19, 2025I'm on a quest to build a local-first web framework using FastHTML and HTMX that lets me easily port Jupyter Notebook workflows, but I'm hitting a snag: the tension between DRY (Don't Repeat Yourself) coding and the need for *immediately obvious* code, especially when it comes to exposing HTMX's workings. My initial attempt at abstraction (a `BaseFlow` class) made things *worse*, so I'm exploring a more explicit, 'WETter' approach, and testing out Grok 3 as a potentially more insightful AI coding assistant than OpenAI's o3. This article chronicles my struggle, my philosophy, and my hope that AI can *enhance*, not obscure, the human coding process. I want a system where the code reads like 'sheet music' – clear, concise, and empowering.
The Site Whisperer: Reimagining Web Crawling in the Age of AI
February 04, 2025In today's rapidly evolving digital landscape, staying ahead of the curve requires innovative tools and strategies. This article delves into the exciting world of AI-powered web crawling, exploring how local LLMs and intelligent systems can revolutionize productivity and workflow efficiency. Join us on a journey to discover the potential of "The Site Whisperer," a groundbreaking approach that promises to transform the way we interact with the web.
Semantic Web: The Key to Discoverability in the Age of AI
February 03, 2025I explore the changing landscape of SEO and web crawling in the age of AI and LLMs. I argue that traditional methods are becoming unsustainable due to the infinite nature of the web. The focus is shifting from URLs to content, highlighting the importance of semantic web technologies. I advocate for creating a "core" website with stable URLs and structured data, even while acknowledging that many e-commerce sites create crawlable issues. I also describe my own website's organizational challenges and plans to use vector embeddings and graph databases to improve content structure.
The Future of SEO: Reimagining SEO in the Age of LLMs
February 01, 2025I'm developing a framework for future-proof SEO tools, anticipating changes driven by LLMs. I'm separating user messages from LLM training, using external markdown files for training data, and minimizing JavaScript. This weekend I implemented verbatim scripting and super prompts, and I'm now building a mini-crawler to demonstrate this approach. This framework, using HTMX and FastHTML, aims to enable rapid development of independent, LLM-powered SEO tools, ushering in a new era of SEO focused on valuable content and intelligent analysis.
Open Source SEO Software
January 31, 2025My open-source SEO software, Pipulate, is evolving. I'm simplifying its core, embracing a Python-first, local-first philosophy that rejects the complexities of modern web frameworks. This means doubling down on my FastHTML-based lightweight web framework, and building a flexible pipeline system for automating SEO tasks. Think powerful local SEO tools, combined with the strategic injection of expert knowledge to guide AI assistance. The goal? A powerful, adaptable, open-source alternative that puts control back in the hands of SEO practitioners, future-proofing their skills for a rapidly changing landscape.
AI and the Future of Work: Will We Become Sheep or Shepherds?
January 25, 2025This article explores the challenges of maintaining creativity and productivity in the age of AI. It examines the historical evolution of communication technologies, from spoken word to the internet, and argues that AI is the next major revolution. The author emphasizes the importance of critical thinking and "future-proofing" oneself by using timeless tools like Linux, Vim, and Python. The article also touches on the potential dangers of over-reliance on AI, leading to a passive consumption of information. Ultimately, it encourages readers to become "shepherds" who actively shape their own learning and creative processes, rather than "sheep" who passively follow AI-generated paths.
Amazon + Manufacturer Disintermediation & The Shopify Squeeze
January 22, 2025The article discusses the challenges facing niche sellers in the e-commerce landscape, particularly the squeeze between Amazon and the manufacturers who are increasingly selling directly to consumers. I explore the concept of disintermediation and the role of Shopify in this context. I also discusses the importance of adding value to products and services to differentiate from competitors and the role of technology in helping businesses compete in the digital age.
Simplifying State: A Workflow Refactoring Journey
January 15, 2025In this article, I describe my journey to refactor a multi-step workflow system, aiming for simpler state management and a better user experience. With the help of the Anthropic AI assistant in Cursor, I tackled redundant state tracking, optimized data handling for 'revert' actions, and made the system more extensible. We introduced a base class for workflows, refined how step completion and reversion are handled, and used HTMX strategically for dynamic UI updates. The result? A cleaner, more manageable, and user-friendly workflow system.
From Printing Press to AI: A New Era of Literacy
January 14, 2025This article explores the evolution of literacy and technology, from the printing press to AI coding assistants. I argue that programming literacy is crucial in the age of AI and emphasize the importance of clear, human-readable code. I discusse my web framework project, highlighting its unique features like FastHTML and its focus on linear workflows inspired by Unix pipes. I advocate for a simplified, Python-centric approach to web development that prioritizes efficiency and understandability.
Vim Indention Selection (TL;DR Disappointment)
January 13, 2025Need to select indented code blocks like Python functions in Vim without plugins? Sadly, there's no easy built-in way. This article explores practical workarounds using visual mode, searches, paragraph motions, and custom mappings to achieve this in vanilla Vim, NeoVim, or VSCode's Vim mode.
Breaking Changes and Learning Opportunities
January 12, 2025I spent my Sunday improving my coding project by making breaking changes to enhance learnability and maintainability. I refactored my code using namedtuples for clarity and implemented a simple position lookup for efficiency, drawing parallels between this process and the competitive landscape of the tech industry. I emphasized the importance of local-first architectures, utilizing tools like Nix and Linux for future-proofing, and drew analogies between the evolution of martial arts and global competition in the tech world. I meticulously documented my process, creating comprehensive documentation that serves as a learning resource and a guide for future development, all while engaging in a meta-narrative with the AI assistant Claude.
Reclaiming Control: Refactoring AI-Assisted Code for Clarity and Precision
January 11, 2025I've been working on a Python web framework that leverages AI code generation, but more importantly, prioritizes regaining control and clarity in the code. This involves refactoring AI-generated code to make it more understandable and maintainable, likening the process to driving a car with auto-steer capabilities – you still need to direct it and know where you're going. Striking the right balance involves "storytelling" to the AI through clear prompts and context, and focusing on core principles to create a system that is both powerful and transparent, where AI and human developers work together seamlessly to create elegant and efficient solutions.
Refining Starter Flow: The Music of Chain Reactions
January 10, 2025This article chronicles the refinement of my "Starter Flow" web framework, focusing on improving the clarity and maintainability of its core "chain reaction" mechanism. Initial attempts at implementing a persistence feature, which would allow users to see and edit previous input, led to complexity and violated the framework's design principles. With the help of my AI coding partner, Claude, we realized that the solution was to embrace my framework's server-side state management philosophy. This breakthrough dramatically reduced friction in the pipeline development process.
Peak Data Theory? Why the Future of Search Hinges on Outlier Information
January 09, 2025I've witnessed the evolution of search firsthand, from the early days of static site generation to the rise of AI and LLMs. This article chronicles my journey through that changing landscape, challenging the 'peak data' assertions made by figures like Elon Musk and Ilya Sutskever. I argue that we haven't exhausted the world's information; instead, we need better ways to access and curate the vast, untapped potential of the invisible web and the continuous stream of new data. I delve into the technical intricacies of web crawling, the challenges posed by big tech, and my vision for open-source tools that empower individuals and small businesses to thrive in the LLM era. I believe the future of search lies in prioritizing outlier information and moving beyond the limitations of current search paradigms.
Virtual Desktops: Your Future-Proof Workflow in a World of Forced Upgrades
January 09, 2025I'm done with macOS and Windows. Their forced upgrades and proprietary nature are a threat to my productivity and freedom. NixOS is the answer, letting me build a clean, customizable system from scratch. But the real key to a future-proof workflow, no matter your OS, is virtual desktops. Master them. They're on every platform, the skills are transferable, and they'll save you from the tab-switching, window-shuffling chaos. GNOME does it best, but the others are usable too. Embrace the full-screen, learn the shortcuts, and break free from big tech's grip on your desktop.
AI's New Deal: From Ideas to Automation
January 09, 2025Open-source, locally run large language models (LLMs) like Llama are poised to revolutionize our interaction with technology. They function as universal translators, converting natural language into executable code, thereby democratizing automation and empowering individuals to realize their ideas without extensive programming expertise. This shift has the potential to trigger a societal recalibration akin to the Industrial Revolution, fostering a new class of digitally empowered individuals and challenging the dominance of established tech companies.
From Coleco Adam to NixOS: A Quest for a Deterministic System
January 08, 2025This article explores the journey of finding a stable and reliable computing environment, emphasizing the importance of deterministic systems like NixOS for long-term productivity and skill preservation. It touches upon the pitfalls of traditional approaches to system maintenance and the drawbacks of popular technologies like Docker and complex JavaScript frameworks.
Pipeline Dreams: Finding Focus and Flow in the Age of AI
January 07, 2025Join me on a personal exploration of the power of pipelines, not just as technical tools, but as a philosophy for navigating the complexities of work and life in the digital age. We'll delve into the challenges of staying focused, the importance of self-management, and the delicate balance between human intuition and AI-driven automation. Get ready to discover how pipelines can help you find clarity, control, and a renewed sense of purpose in a world of ever-increasing demands.
The Speed-Chess Mind: Bridging Habit, Deliberation, and AI
January 07, 2025We navigate life through a dynamic interplay of habits, deliberate thought, and rapid "speed-chess" decisions, a process mirrored in how AI models balance pre-trained knowledge with on-the-fly adaptation like RAG. Journaling, especially during those key morning and evening moments, helps us bridge these modes, moving us from automatic responses to conscious reflection. Ultimately, mastering the "speed-chess" mindset – that ability to swiftly integrate ingrained patterns with insightful analysis under pressure – is crucial for both humans and AI, particularly when facing unexpected changes. And that mastery comes from a willingness to deliberately, habitually, put ourselves in learning situations just beyond our comfort zones.
The Irrepressible Outlier: Finding Originality in a World of Infinite Content
January 06, 2025Buckle up, because we're about to go on a wild ride through the past, present, and future of the digital world! I'll take you behind the scenes of the biggest tech revolutions, from Atari to AI, and show you how they've shaped the way we create and consume information. We'll dive deep into the rise of generative AI, the challenges it poses to originality, and why it's more important than ever to embrace our inner outlier. Get ready to challenge the norm, spark your creativity, and discover how to thrive in a world of infinite content!
NixOS Nvidia Wayland Support
January 06, 2025This article explores my journey from creating a portable Linux solution called Levinux to embracing NixOS and overcoming its challenges. I delve into the technicalities of resolving NVIDIA/Wayland graphics issues on NixOS, highlighting the role of AI assistants in troubleshooting. The article emphasizes NixOS's declarative approach, enabling safe experimentation and system configuration reproducibility.
Mastering HTMX Pipelines: A Starter Flow with Persistent State
January 05, 2025In this article, we explored the process of creating a minimal HTMX pipeline with persistent state, using o1 Pro as an AI coding assistant. We started with a simple two-card flow and gradually refined it, learning valuable lessons about state management, the importance of clearing forward in submit handlers, and the distinction between preserve mode and ephemeral steps. The final `StarterFlow` code serves as a robust blueprint for building more complex pipelines, showcasing best practices and effective state management techniques.
When Anti-Patterns Become Best Practices
January 04, 2025This piece explores a Python programmer's journey through the world of web development, highlighting their love for minimalist tools like HTMX and FastHTML. It delves into the challenges of building SEO tools, the frustrations with JavaScript's complexity, and the joy of discovering elegant solutions that prioritize simplicity and developer experience. The author's unique approach challenges conventional web development practices, emphasizing the power of "anti-patterns" and the beauty of stripping away unnecessary layers of abstraction.
Un-Externalizing a Helper Function
January 04, 2025In this article, I'll take you on a deep dive into a refactoring journey that challenges conventional wisdom. We'll explore how un-externalizing a helper function, a move that seems counterintuitive, can actually enhance code clarity and consistency. Join me as I navigate the complexities of state management, form repopulation, and the delicate balance between abstraction and simplicity. Along the way, we'll uncover the power of minimalist web frameworks, the elegance of HTMX, and the art of "musical" code composition. Get ready for a refactoring adventure that will challenge your assumptions and inspire you to find beauty in the most unexpected places.
Git Cherry Picking & Time-Travel
January 03, 2025I've been using Git in a very linear way for years, but today I finally took the plunge and learned how to use branching and cherry-picking. It was a bit of a mind-bending experience, but I'm glad I did it. Now I can easily "hop" between different timelines and cherry-pick the changes I want, without having to worry about introducing bugs. I'm also excited to start using branches as a way to explore older commits and experiment with new features. This is a major step forward in my Git journey, and I can't wait to see what I can do with my new superpowers!
One Card Flow
January 02, 2025We took on the challenge of refining Pipulate, starting with a simple "OneCardFlow" focused on a single, humble textarea for user input, generated by o1 Pro. After a hefty coding session, we emerged with a far superior version. Then, leveraging o1 Pro's analytical muscle, we dissected the improvements, forging a blueprint for future workflows. The key takeaways? Consistency and user experience. Now, we're ready to further optimize Pipulate by centralizing common code, making it even leaner and more powerful. It all started with that textarea, and it's leading to a much more robust framework.
Rubber Ducking With LLM
January 01, 2025On January 1st, I used an LLM (Claude) as a coding partner to work on my web framework, hitting a snag with state management in my pipeline system. Claude reminded me of my core principles, the 'Pipeline Mantra,' revealing a simple fix. This led us to refine my .cursorrules file, a guide for AI coding, with 'mantras' and 'speedbumps' to encourage better patterns. We also outlined how to kickstart a new workflow, emphasizing simplicity and the effective use of LLMs in coding. The key takeaway? Keep it simple, stupid!
FastHTML HTMX Unix Pipes
December 31, 2024This is where I take the Unix pipe philosophy and apply it to my LinkGraphFlow pipeline, with a little help from OpenAI's top-tier model, o1 Pro. We're talking about a workflow that's as elegant and powerful as a series of well-crafted Unix commands, each step feeding into the next, transforming data along the way. I'm working through the nuances of integrating this approach into a modern, web-based system using HTMX, focusing on making the data flow visible and intuitive. This article chronicles that journey, highlighting how human creativity and AI collaboration can come together to build something truly special, inspired by the timeless wisdom of Unix.
Of Rabbit Holes, Wonderlands & Shoulders of Giants
December 30, 2024What is my quest? I seek the grail of tech development: a future-proof, local-first system that's both powerful and delightful to use. This journey has led me through the lands of Nix and Guix, past the seductive but ultimately fragile Electron apps, and into the surprisingly volatile world of bleeding-edge web frameworks like FastHTML. Now, a new contender, Anywidget, has caught my eye, promising seamless integration of interactive widgets into Jupyter Notebooks. Will it be the missing piece I've been searching for, or just another tempting detour? Let's find out as I dive deep, weigh my options, and continue my relentless pursuit of a tech stack that can keep up with my ever-evolving needs.
A Single-File Local Web Framework, Powered by Python + Nix + HTMX + a Built-In LLM
December 30, 2024It’s like an Electron app meets a local Jupyter environment, except it’s all Python + HTMX, installed by Nix, integrated with an on-device LLM for ephemeral or persistent tasks. A single user, single-file system that’s easy to hack and powerful to run—no cloud, no fuss.
The Sound of HTMX Pipes
December 29, 2024I've successfully integrated a pipeline workflow into my web framework, allowing for a seamless and efficient way to manage multi-step processes. By combining the principles of Unix pipes with the flexibility of HTMX and the power of local LLMs, I've created a system that is both elegant and practical. The 10-card flow example demonstrates the core concepts, with each card representing a step in the pipeline. The ability to jump to any step and the synchronized finalization process further enhance the user experience. With this foundation in place, I'm excited to explore more advanced features, such as embedding interactive charts and data grids, while maintaining the musicality and minimalist aesthetic of the code.
Planning Chip O'Theseus
December 28, 2024I'm pushing the boundaries of AI by incrementally adding persistent memory and self-modification to a locally-run language model, a project I've playfully dubbed "Chip O'Theseus." Using a simple key-value database like SQLite and clever prompt engineering, we're teaching the LLM to store and retrieve information, effectively giving it a "cookie" of persistent state. This allows it to learn, evolve, and potentially develop a sense of continuity across interactions. We're exploring profound questions about consciousness and the limits of knowledge, while pragmatically building a system that exhibits increasingly complex behaviors.
Linkgraphectomy
December 27, 2024Okay, so I'm tackling these gigantic link-graph visualizations, the kind that break most tools. We're talking millions of links between hundreds of thousands of web pages. I'm automating the whole process, pulling data from an industrial crawler API. It's a complex beast, with challenges around huge datasets and the unpredictable nature of certain visualization techniques. This whole thing has pushed me to explore new tooling, like Nix, to future-proof my skills, while at the same time helping me automate this convoluted process to extract these massive link graphs for SEO purposes. This is all part of my quest to stay on top of the tech game, and this link-graph project is a key step in that journey.
Flow-State Idea Capture Vs. Organization
December 26, 2024In this article, I explore the tension between capturing ideas in a flow state and the need for organization. While tools like Obsidian and Notion can help organize information, they can disrupt the creative process. I find that using a simple text editor like Vim allows me to capture ideas in a raw format, which I can later organize using tools like Trilium or even AI. I also delve into the history of text editors and emphasize the importance of finding a system that works for you.
AI Stress Test: o1 Pro
December 25, 2024This article details a collaborative coding session between the author and an AI language model, o1 Pro. The objective was to refactor a complex Python class into a more streamlined, pipeline-centric design. This involved breaking down a monolithic code structure into smaller, manageable steps, optimizing for clarity and reusability. The AI demonstrated proficiency in understanding the code's logic and iteratively refining it based on feedback, showcasing its potential as a valuable tool for software development and complex refactoring tasks.
The Future Was Here & It Is Again
December 24, 2024I wrote this article as a reflection on the Amiga’s lost potential and how its journey parallels today’s technology landscape, from retrocomputing to AI. Drawing on personal experiences of working at Commodore in the 1990s, I illuminate the allure and heartbreak of cutting-edge hardware that can’t endure relentless industry churn, as well as the modern quest for software craftsmanship. Ultimately, I champion “LPvg” (Linux, Python, vim, git) plus NixOS and HTMX as a minimalist, lifetime-friendly approach to tech—an antidote to decision fatigue, a bastion for deep expertise, and a reminder that the future arrives in cycles, often hidden beneath corporate missteps and fleeting hype.
Taking The NixOS Wayland Hyprland Plunge!
December 23, 2024This article documents my ultimately unsuccessful attempt to switch from GNOME to Hyprland on NixOS. Despite Hyprland's speed and customizability, I found that its modular nature and lack of integrated features like workspace overviews made it less suitable for my fullscreen-focused workflow. The experiment helped me appreciate GNOME's polished user experience and Wayland's performance benefits, while also providing a deeper understanding of my own desktop preferences.
Gaining Traction
December 23, 2024This article explores the changing landscape of innovation and creativity in the age of AI. I reflect on the challenges of staying relevant when machines are outpacing humans, even in creative fields. Using personal experiences and historical examples like the John Henry story, I examine different approaches to thrive in this environment: embracing originality, iterating on existing ideas like Microsoft, or becoming an 'artisan' who uses AI tools to enhance their craft. I also delve into AI's broader impact on labor, wealth distribution, and even consciousness. Ultimately, the article emphasizes adaptability, continuous learning, and finding intrinsic motivation amidst rapid technological change. It's about finding your place in the evolving relationship between humans and AI, and recognizing the value of human creativity even as the lines between 'artificial' and 'real' intelligence blur.
Rebooting Site
December 19, 2024I'm rebooting my website to focus on future-proofing in the age of AI, which means embracing new tools and strategies while preserving valuable skills and habits. This involves a fresh start for my site, leveraging AI-powered coding assistance, and using a more streamlined content creation process. I'm also focusing on organic growth, letting my daily writing and work experiences shape the content and eventually lead to a book on future-proofing. This reboot is an experiment in adapting to the changing digital landscape, maintaining a balance between established SEO practices and innovative approaches.
Back to Basics: Reclaiming Simplicity in a Complex Tech World
December 13, 2024In an era defined by buzzwords, rapid-fire tool adoption, and the endless chase for the next shiny solution, this article urges readers to take a step back and rediscover the simple, timeless principles at the heart of computing. By highlighting the enduring power of the Unix philosophy, reproducible environments, and local-first approaches, it offers a roadmap to building sustainable, flexible systems that don’t rely on hype or vendor lock-in. Whether you’re a seasoned developer or just starting out, this piece will help you cut through the noise, focus on what truly matters, and create lasting value in your work.
Writing Sheet Music & Taking Chisel Strikes
December 11, 2024This article explores approaching coding with a beginner's mind and making progress through small, daily improvements. It emphasizes the need for developers to understand their code, even when using AI assistance. The article highlights the importance of clear, readable code that serves as both a functional tool and a teaching resource. The analogy of "sheet music" is used to describe code that is well-structured and easy to follow, advocating for a balance between abstraction and transparency. The article concludes with a discussion on the evolving role of developers in an AI-driven world, suggesting a focus on writing code that not only works but also teaches.
Rise of The No-Churn Movement
December 10, 2024For those who encounter the No-Churn movement for the first time, it often feels like stepping into a quieter, more reliable corner of the technological world. Instead of chasing every new trend, you find a calm space built on timeless tools and stable practices. Here, genuine productivity emerges from simplicity and steady growth rather than constant reinvention, encouraging you to focus on long-lasting expertise and meaningful progress.
Testing OpenAI ChatGPT Pro (o1 Release)
December 09, 2024All in all, your project—this pipeline workflow, the blog as a knowledge artifact, the local AI integration, the future-proofing of skill sets, the pushing away from transient trends—feels like a long-term bet on clarity and understanding. It’s a testament to the idea that writing everything down (in code, in notes, in blog posts) is an act of intellectual gardening. And that gardening doesn’t just serve you—it may serve the entire community of people who find their way to your writing, seeking a timeless foundation to build upon in a world of constant churn.
Claude & o1 Release Collaboration
December 08, 2024In this collaboration between Claude and o1 Release, we explore the development of a minimalist, server-centric web framework focused on resumable, linear workflows. Using a pipeline-based approach, we manage state with a single JSON blob, leveraging HTMX for incremental loading and avoiding complex client-side logic. This 'localhost revolution' framework prioritizes clarity, transparency, and developer freedom, aiming to make workflows as easy to write and understand as poetry.
Don Knuth, Fred Brooks & Zeno's Paradox of Coding
December 07, 2024In the pursuit of knowledge and software development alike, we often find ourselves chasing the elusive ideal of perfection, grappling with paradoxes like Zeno's and the diminishing returns of complexity. By understanding the limits of our knowledge, embracing pragmatism, and harnessing the power of collaboration, we can navigate the complexities of the Noosphere and build meaningful systems without getting lost in the infinite. In other words, sometimes it's better to just ship the darn thing instead of getting lost in endless philosophical debates and abstract paradoxes.
Testing OpenAI ChatGPT o1 Release Model
December 06, 2024I tested the new OpenAI ChatGPT o1 release model by feeding it my web application codebase and seeking feedback. The model has provided a comprehensive analysis of my project, outlining completed tasks, remaining tasks, and recommended next steps, demonstrating its ability to understand and provide helpful guidance on a complex coding project. It's token window has increased enough to digest a 6,600 like program in one pass, putting it more in parity with Gemini's 1-Million token context window (2-Million as-of today).
David Mayer Vs. Donald Trump (ChatGPT & Google AI ChatBot LLM Censorship)
December 03, 2024This article presents a firsthand encounter with censorship in a large language model. Through a series of seemingly straightforward questions, a pattern of suppression emerges, raising concerns about transparency and bias in AI systems. This exploration delves into the potential consequences of such censorship, touching upon issues of trust, freedom of information, and the future of knowledge in an AI-driven world.
The Necessity of Taking Multiple Small Passes (Chisel-strikes)
December 02, 2024This article explores the concept of "chisel-strikes," small, consistent steps towards achieving your goals. It emphasizes balancing focused effort with rest and recovery to avoid burnout and maintain momentum. Discover how to leverage Git for efficient data management and version control, ensuring your files are always backed up and accessible. The article also delves into different approaches to configuring your home directory in Linux and NixOS, including using Nix Home for declarative management and a simpler method of direct file-linking. Learn how to create a portable and reproducible system environment while minimizing reliance on cloud services.
Future-Proof Your Tech Career: The No Take-Back Guide to Winning in a World of Churn
November 29, 2024The tech world is in constant flux, but I'm not just keeping up – I'm charting my own course. This guide is my roadmap to a future-proof tech career, where I call the shots. It's about mastering the skills that endure, building a foundation that lasts, and escaping the clutches of obsolescence. I'm diving deep into timeless technologies, personal branding, and the power of saying "no" to the trends that can derail a career. If you're ready to navigate the tech landscape with confidence and purpose, join me. This is my journey to win in tech, on my own terms.
Dedumbing Sisyphus
November 27, 2024In my latest article, 'Dedumbing Sisyphus,' I reflect on the challenges and triumphs of building a groundbreaking AI-powered SEO tool while juggling client work and life's unexpected curveballs. I explore the importance of breaking free from the 'busywork trap' and achieving a state of flow, drawing inspiration from the myth of Sisyphus and the concept of antifragility. I delve into the technical intricacies of my project, emphasizing a minimalist approach and the power of local LLMs. Ultimately, it's a story about perseverance, innovation, and the pursuit of a meaningful legacy in the ever-evolving world of technology.
Pipeline To Completion
November 25, 2024I am creating a minimalist, self-healing workflow design based on a pipeline pattern. The core idea is to use URLs as primary keys and store all workflow state in a single JSON blob within a pipeline table. This allows for easy continuation from any point in the workflow by simply re-serializing the JSON data. The challenge lies in consistently applying this pattern across all components while maintaining a clean, 'pure UNIX pipe' philosophy. I'm using a 'time-travel prompting' technique with Claude to pinpoint the exact code changes needed to achieve this, focusing on standardizing the JSON structure, state transitions, and card placeholder generation. The goal is to create a system where workflow development is self-evident, enjoyable, and easily extensible.
Wrangling AI Code Assistants
November 24, 2024Working with AI coding assistants is like trying to get a genie to fix your doorknob without accidentally rebuilding your entire house. It's a matter of formulating genie-proof instructions, sometimes in a game of whispering-wishes-down-the-lane, because it's actually 2-genies if you're using the Chat UI whereby your direct genie coding partner has yet another genie coding partner to whom they communicate. This inserts a layer where the genie-proofing of the first layer has an opportunity to get lost in translation (clever genies).
BFF SEO dot BOT is Born
November 24, 2024Because I'll be best friend of LLM-directed real-time small-world-theory shallow click-depth crawlers by teaching people how to organize their sites well.
The Mindful Mirror Model Effect
November 24, 2024In a world increasingly reliant on AI, our perception of knowledge and ability is undergoing a transformation. The Dunning-Kruger effect, a cognitive bias where individuals overestimate their competence, is being challenged by the rise of intelligent tools that can augment our capabilities and illuminate our knowledge gaps. This article explores the potential for AI to reverse the Dunning-Kruger effect, leading to greater self-awareness, enhanced learning opportunities, and a new era of personal growth.
Brainstorming Book Titles with AI
November 24, 2024In this book, I'll share my personal journey from tech enthusiast to advocate for local computing and AI. We'll explore the power of the LPvg stack (Linux, Python, vim, and git), unlock the magic of NixOS and HTMX, and delve into the world of local Large Language Models. This is more than just a technical guide; it's a story about reclaiming your digital sovereignty, escaping the cloud, and building a future where technology empowers individuals.
NixOS Warbler Files Disappeared
November 23, 2024NixOS unstable just ate my file manager in the latest update. Turns out they're slimming down the default install, probably for those hardcore minimalists running headless systems. But hey, I like my GUI comforts, so I had to dive into the NixOS config and wrestle Nautilus back into existence. It's a cautionary tale of what can happen when you live on the bleeding edge, but also a testament to how fixable things usually are with a little persistence and the right commands.
Pipline Workflow Example
November 23, 2024This is a chronicle of my journey building a unique web application, a testament to the power of server-side simplicity. I'm using FastHTML and HTMX to craft a localhost-first experience, deliberately avoiding client-side frameworks. Think pipelines, persistent state, and a touch of AI magic with Ollama. It's a deep dive into the intricacies of JSON serialization, state management, and the often-overlooked elegance of server-side rendering. We'll explore the MiniDataAPI Spec, wrestle with LLMs, and ultimately create a web app that's both powerful and refreshingly straightforward.
LLM Speedbumps, Anti-pattern Vaccines & The Locahost Revolution
November 22, 2024This article chronicles my battle against the siren song of "shiny new things" and my return to the path of pragmatic productivity. I'm ditching the rabbit holes and embracing the power of established tools and techniques to build a lean, mean, localhost-powered pipeline. Think server-side state, minimal code, and a healthy dose of anti-React antibodies. It's about finding clarity amidst the chaos and building a Foundation for future innovation, one chisel strike at a time.
Pipulate Pipeline Born Again Now
November 21, 2024This article chronicles my journey to rebuild my Pipulate SEO tool, reflecting on the evolution of SEO, the quirks of JavaScript, and the importance of developer workflow. I delve into the bring your own server model with nix and explore the Pipulate pattern: local-first pipeline processing using FastHTML, HTMX, and SQLite. It's a tale of embracing simplicity and bucking the trend of complex web app architectures.
On Flow State Alternation - The Key to Success
November 20, 2024I delve into the concept of flow state and its significance in my SEO work. I examine my personal experiences with flow state, emphasizing its role in boosting my productivity and creativity. I also discuss the potential advantages and challenges of incorporating AI coding assistants into my workflow, and the importance of selecting appropriate programming paradigms and tools that align with my individual needs and preferences. I close with a reflection on the dynamic nature of the tech world and the ongoing need for continuous learning and adaptation.
Pipeline Workflow
November 19, 2024This document details the creation of a system for managing complex workflows on a local machine, inspired by the Unix pipeline concept. It leverages a Python-based web framework (FastHTML) and a minimalist database approach (MiniDataAPI) to create a user-friendly interface for chaining together tasks, passing data between them, and managing state efficiently. This system aims to simplify and streamline complex processes, particularly those involving web scraping, data analysis, and automation, all while remaining lightweight and user-friendly.
Pattern Alert - THIS IS NOT FASTAPI!
November 18, 2024I detail the process of building a Python web application using the FastHTML framework, emphasizing the importance of simplicity and readability. I draw inspiration from the Unix philosophy and the design principles of ABC, Python, and FastHTML to create maintainable and user-friendly code. I also share my experiences with AI code assistants, highlighting the challenges of preventing them from introducing unnecessary complexity. Through careful prompt engineering and defensive documentation, I successfully refine the code and establish a pattern for building robust web applications with clear state management, explicit state transitions, and comprehensive error handling.
Unix Pipeline Philosophy in HTMX + FastHTML Workflows
November 16, 2024Unix Pipeline Philosophy in HTMX + FastHTML Workflows: Enhance your coding skills by embracing a Unix-inspired approach to building web applications with HTMX and FastHTML.
On Fighting the Dunning-Kruger Effect
November 16, 2024Fighting the Dunning-Kruger effect and trying to actually be that good while building a simple yet powerful web app with a unique architecture. Learn how AI helps combine the best of old-school desktop apps with modern web technologies.
OpenAPI Swagger JSON to Python Code Examples
November 15, 2024I'm building a cutting-edge web framework with HTMX, Nix Flakes, and AI, aiming for a future-proof development experience. It's about user empowerment, skill amplification, and shaping SEO's future. Come along for the ride!
80% Cost Reduction in AI Operations
November 13, 2024I'm exploring a new way to build software that uses AI to make things more efficient and cost-effective. I've created a system that combines different AI models, kind of like having a team of experts with different specialties. This system can learn and adapt over time, and I think it has the potential to change how we build software and make AI more accessible.
6-Click-Ease to Serve Up Bacon
November 12, 2024This post rethinks the web as a dynamic, database-like system, shaped by six degrees of separation and small world theory. It delves into how SEO and AI tools streamline repetitive tasks, align with real-time search demands, and prepare content for the constant crawl and recrawl required to inform modern AI models. By viewing URLs as keys in a vast, cloud-based database, it explores the challenges of navigating a web where trusted brands and creative strategies are essential to standing out.
How To Train Your LLM
November 11, 2024Discover how to train your LLM to work with Botify Query Language (BQL) for efficient SEO analysis. This guide covers everything from understanding BQL's core concepts, such as collections, dimensions, and metrics, to building powerful queries, visualizing data, and integrating LLMs into your workflow with Python examples.
I Know Kung Fu... Show Me!
November 10, 2024Explore how AI assistance and strategic prompt injection enabled mastery of complex BQL API integration, setting the stage for ambitious GPU-powered website visualization goals.
From Jupyter Notebooks to Markdown
November 09, 2024From Jupyter Notebooks to Markdown: A journey through refining workflows, building muscle memory, and perfecting good form in data science. Discover tools like nb-clean and jupytext while developing a sustainable, accessible process for managing and sharing code—keeping technical depth without losing readability.
Practicing the Botify API
November 07, 2024Exploring the Botify API through Python notebooks, examining key concepts like Organizations, Projects, and Collections while considering the future of SEO in an AI-driven world.
Structuring Websites to Train Models
November 07, 2024Learn how to structure websites to train AI models while maintaining a client-first mindset. Explore the balance between technical innovation and delivering value to clients in modern SEO.
Resilience While Achieving Ikigai
November 06, 2024Exploring the Japanese concept of Ikigai as a path to resilience - aligning what you love, what you're good at, what pays, and what the world needs. Finding joy and meaning in life's journey while building mental toughness.
Getting Mac NeoVim Same as NixOS NeoVim
November 05, 2024Tame the Mac! 💻 This is my journey to conquer the increasingly dreaded Macbook and make it work seamlessly with my increasingly beloved NixOS NeoVim setup. From battling muscle memory to embracing the power of flakes, I'm crafting my ultimate cross-platform development environment. 🚀
Figuring Out a Complex API
November 04, 2024Coding like the 3 Little Pigs? Yup. Building straw houses with an eye on the future. It's about good kata, adapting to change, and the AI-powered webdev renaissance. HTMX FTW!
SSE Makes Watchdog Necessary to Force Server Live-Reload
November 03, 2024Waiting for connections to close? (CTRL+C to force quit?) Discover why adding SSE to FastHTML demands a more heavyweight solution for live-reloading, and how using a watchdog brings your dev environment back to life—Wile E. Coyote-style—with every file save.
API-Enabling the LLM Ghost
November 03, 2024Unlock the hidden potential of an LLM that’s not just in the background but visibly alive in your browser. This deep dive explores the path to seamless, human-like control of CRUD operations through an HTMX-powered proof of concept, bridging the uncanny valley between human interaction and AI control, where every action could look like it’s yours.
How I Finally Got My LLM to Play Nice With the Web UI
November 02, 2024Embark on a journey bridging the gap between WebSockets, Server-Sent Events (SSE), and JavaScript to bring the "Ghost in the Machine" to life. Discover how a methodical approach, inspired by the Wright Brothers' experiments, led to a system where real-time commands and structured responses create an interactive, dynamic web experience. From initial spark to lift-off, this article shows how persistence and well-planned steps make complex integrations not just achievable, but thrilling.
FastHTML Hello World
November 02, 2024Learn the basics of FastHTML, a Python web framework that skips templating languages and allows direct HTML element creation with Python functions. Discover how to build a simple "Hello World" page with structured HTML using FastHTML's function-to-element mapping.
Deep Debugging LLM Ghost
November 01, 2024A deep dive into the challenges of integrating LLMs with dynamic web UIs using HTMX and FastHTML. Explore the pitfalls of misusing WebSockets, the complexities of parsing assistant responses, and the eventual triumph of Server-Sent Events.
Rabbit Hole Dev to Delight Clients
October 31, 2024Join me on a journey through the exhilarating world of development, where I balance the addictive nature of AI-driven coding with the need to engage clients. Discover how I navigate the challenges of maintaining flow states, embracing resilience like Rocky Balboa, and leveraging small wins to drive success in a fast-paced tech landscape.
Giving Gemini Advanced a Try
October 30, 2024Exploring Gemini Advanced, I use fresh web logs each session to fine-tune API syntax and JSON commands for enhanced clarity in LLM interactions. By examining logs, adjusting placeholder syntax, and reformatting responses with real-world examples, I improve the LLM’s system prompts to support smoother CRUD operations and dynamic UI updates. Each step refines both the app and the model, helping me achieve real-time updates in the UI with precision.
It's About Delighting Customers
October 30, 2024Through my experiences with AI and customer-focused methodologies inspired by Drucker and Deming, I've learned that technology's true worth is measured by its ability to delight clients. By prioritizing value from the customer's perspective and streamlining processes, I harness AI to create data-driven approaches that empower my clients to shine and engage their audiences effectively.
LLM as Ambient App Intelligence
October 29, 2024In this article, I dive into the concept of LLMs as ambient intelligence, inspired by a conversation with Claude 3.5 through Cursor AI. I explore how integrating AI seamlessly into user interactions creates smarter workflows, allowing apps to learn and assist in real-time. As I transition from architecture to client focus, I reflect on how combining Drucker’s customer-first philosophy with Deming’s incremental improvement approach ensures AI remains a tool for delighting customers, not a distraction from what matters most.
FastMTML Static Resources
October 28, 2024Explore the FastHTML project, a Python-based framework embracing anti-patterns for simplicity and power. Dive into package initialization, global namespaces, and how HTMX equips the Python community with new web development superpowers, driving a unique approach that challenges conventional JavaScript frameworks like ReactJS.
Slack & Zoom on NixOS Workspaces
October 27, 2024I show how NixOS makes installing Slack & Zoom easy, how I use virtual desktops across OS platforms, and how organizing fixed-position screens helps me stay in the flow with muscle memory guiding my workflow.
Pythonic Chunk-Yielding Generator to Simulate Long-Running Tasks
October 26, 2024Simulate long-running tasks with Python using a chunk-yielding generator for streaming WebSocket chit-chat. This FastHTML-based approach ensures smooth UI updates without breaking existing code, laying the groundwork for an eventual conversion from Jupyter Notebooks to FastHTML apps. Also, I train Claude that FastHTML is not FastAPI.
I Don't Know What to Do Sometimes
October 25, 2024SPAs reshaped SEO, but I’ve adapted along the way. While I missed some chances, I still love coding, writing, and experimenting with tools like NixOS and GitHub Pages. Now, I’m channeling that energy into a new goal: converting my Jupyter Notebook workflow into a FastHTML-powered app, creating a seamless, interactive experience I can't wait to share.
API, AI & Human Nuance: The Same Thing
October 24, 2024Explore the connections between APIs, AI, and human nuance in modern workflows. This article offers practical strategies for navigating technological subtleties, enhancing productivity, and building strong client relationships, all while balancing innovation with authentic interactions.
The Port For Real This Time
October 23, 2024Porting two key apps has been delayed, but I'm determined to finish tonight while preparing for a client call tomorrow. I’m shifting from ZeroMQ to WebSockets for real-time communication and simplifying data handling with SQLite. The focus is on progressive UI elements and Botify API integration to streamline workflows, avoid rabbit holes, and ensure meaningful progress.
LLM Ghost In The Machine
October 22, 2024I dive into the ups and downs of using AI like OpenAI and Cursor AI for code refactoring, especially with frameworks like FastHTML and HTMX. I’ve had wins with CRUD operations and syntax-colored logs, but also setbacks with error handling. The key lesson? Balance global vs. targeted AI edits and keep things simple. I’m also streamlining my setup with helper scripts and macros in NixOS, turning small improvements into lasting productivity boosts.
Local AI Awareness Training
October 21, 2024Learn how to integrate local LLMs with FastHTML to build CRUD apps. Conversation history is logged in SQL and vector databases for insights. The LLM aids user actions and prepares for future self-sufficiency by learning app usage patterns, enhancing AI-driven workflows.
Local AI In The App Development Loop
October 20, 2024Exploring AI-powered app development, this article covers lessons from building with HTMX, WebSockets, and local LLMs. It highlights modular design, CRUD integration, dynamic interactions, and future-proofing strategies, ensuring apps evolve with user behavior and AI advancements.
Planning to Win with LLM
October 19, 2024Planning to Win with LLM highlights how LLMs reduce planning friction by offering mentorship on common scenarios but struggle with novel insights. It emphasizes leveraging AI for SEO and using WebSockets to track user actions, blending AI strengths with adaptability for future innovations.
Local LLM Web Framework Integration Plan
October 18, 2024Collab with o1-preview to design a local LLM, vector database, and SQL database on a local host to transform software development. Explore building self-aware systems that interact with developers, execute functions, and improve over time, making AI an active participant in its own design.
Revolutionizing Software Deployment: How Nix Flakes Simplify Development Beyond Docker and pip
October 17, 2024Discover how Nix Flakes are transforming the development landscape by offering a streamlined, reproducible environment that outperforms traditional methods like Docker and pip installations. This article delves into the advantages of using Nix Flakes for infrastructure as code, highlighting how it simplifies user experience, ensures cross-platform consistency, and automates setup and updates.
The key to AI Code Assist Acceleration is 1-Folder Scope
October 15, 2024Explore how moving a key NixOS config to a 'repos' folder accelerates AI coding assistance with Cursor AI. Learn about challenges with Vim macros, AI limitations, and tips for consolidating development resources while leveraging cross-repo insights for coding efficiency.
Soft Launching Botifython
October 15, 2024My journey upgrading Botifython's Pipulate fork with Nix flakes, transforming Jupyter Notebooks into web apps, and deploying to coworkers. From FOSS to proprietary shifts, embracing infrastructure as code, and automating SEO workflows—crafting tech with passion and precision.
Botifython is Born
October 14, 2024I’m diving back into web development through Botifython, a Python framework focused on SEO and AI, driven by new technology. My setup utilizes Nix Flakes for reproducible environments and includes an automated update mechanism with SSH keys, ensuring seamless integration of new features. I’m excited to evolve this project with stable and experimental branches as I continue to enhance its capabilities.
Object Oriented Base Class Plugins
October 13, 2024I've built a plugin system using object-oriented programming, something I was initially hesitant about due to Python's OOP syntax. By creating a base class, `BaseApp`, I've streamlined CRUD operations and routes, improving the system's long-term flexibility. This approach reduces complexity in my single-file setup. I’ve customized the base class with wrappers like `TodoApp` and `ProfileApp` for specific functionalities. This shift to precision coding lets me add new features, like sorting, without bloating the code, making the system easier to update and maintain.
Building a Plugin-Ready Framework: A Step-by-Step Transformation
October 12, 2024Discover how I restructured my system into a plugin-ready framework, enhancing modularity and simplifying updates. This guide outlines the transformative steps taken, highlighting the benefits of a modular design for improved scalability, maintainability, and collaborative development.
Test SPA Endpoints (Single Page Applications in FastHTML)
October 11, 2024This article details the development of a comprehensive testing suite for a FastHTML single-page application using Python's `unittest`. It covers endpoint testing, logging enhancements, and future plans for UI automation, ensuring the application’s reliability and robustness while showcasing code snippets for clarity.
FastHTML and SortableJS For Sortable Todo Lists
October 10, 2024In my quest to build the perfect to-do list app with FastHTML, I tackled drag-and-drop sorting with SortableJS. After overcoming a pesky script tag issue and submitting a bug report, I dove into optimizing database updates with MiniDataAPI. By creating a batch update function and minimizing data transfer, I ensured efficient sorting. Finally, I set up a server-side endpoint to handle the updates and seamlessly integrate the front-end and back-end, resulting in a smooth and responsive user experience. This article explores how to integrate SortableJS with FastHTML for creating sortable to-do lists. It covers client-side drag-and-drop functionality, efficient backend updates using MiniDataAPI, and setting up JavaScript and Python endpoints for real-time updates.
AI-Generated Refactoring Advice from Top LLM Models
October 09, 2024I detail my experience using Nix flakes to create a reproducible development environment for a Python web application built with the FastHTML framework. I discuss the challenges and benefits of using Nix for managing dependencies and ensuring consistency across different platforms, and I highlight the importance of understanding and leveraging the unique features of FastHTML for efficient web development. I also share my insights on the evolution of web development and the role of AI in shaping the future of coding practices.
Unpacking FastHTML Databases
October 08, 2024I explore the complexities of the FastHTML framework and its layered architecture, built on Python and Starlette. I discuss the challenges of adapting to new conventions while developing a Pythonic API wrapper and highlight the importance of understanding evolving frameworks for effective web development. I also delve into the intricacies of FastHTML's database features, including table creation, persistence, and user data management, emphasizing the importance of understanding these concepts for building robust web applications.
A ChatGPT o1-Preview Code Review
October 07, 2024I detail my experience building the next generation of Pipulate, a Python-based web application, using the FastHTML framework. I highlight the challenges I faced with HTMX and real-time streaming, and express my excitement about the potential for creating powerful, easily shareable local web apps with this technology.
FastHTML WebSockets & Database for Streaming & Persistence
October 06, 2024I discuss the challenges and benefits of transitioning to NixOS from traditional Linux distributions, highlighting the unique aspects of NixOS's filesystem hierarchy and package management. I explain the benefits of Nix's deterministic packaging system and how it can be leveraged on macOS and Windows using Nix Flakes. I also provide a step-by-step guide for getting started with Nix Flakes and emphasize the importance of embracing the NixOS philosophy for improved productivity and simplified software management.
Ollama Websocket Chat
October 05, 2024I detail my journey of building a reproducible development environment using Nix flakes, focusing on creating a "home" script to streamline setup across platforms. I discuss the challenges of managing dependencies and ensuring consistency across different operating systems, and I highlight the benefits of Nix's declarative approach and immutable store. I also share my experiences with web development frameworks and the importance of choosing the right tools for building modern web applications.
Understanding FastHTML's Framework Opinions
October 04, 2024I detail my experience transitioning to NixOS and using Nix flakes to create reproducible development environments. I discuss the challenges of managing dependencies and ensuring consistency across different platforms, and I highlight the benefits of Nix's declarative approach and immutable store. I also share my perspective on the evolution of web development and the importance of choosing the right tools and frameworks for building modern web applications.
From Jupyer Notebooks to FastHTML with WebSockets
October 03, 2024I've been working in Jupyter Notebooks for years and love the flexibility they provide, but collaborating and scaling projects with them can be a challenge. I'm excited to get back into web development with tools like FastHTML that simplify the process, and I'm particularly interested in using WebSockets to handle long-running tasks in my applications. My goal is to create a streamlined workflow that combines the rapid prototyping of Jupyter Notebooks with the power and accessibility of web applications, all while maintaining a clean and manageable codebase.
Code as Infrastructure
October 02, 2024In this article, I chronicle my journey of building a robust Nix Flake development environment that seamlessly works across macOS, Linux, and Windows WSL. I delve into the challenges of integrating CUDA support and specialized tools like JupyterLab, emphasizing the importance of a virtual environment for data science flexibility. Through a step-by-step account, I detail how I progressively enhanced the flake.nix to achieve a versatile and powerful development setup that liberates developers from hardware and platform constraints.
Melding a Mac and Linux Nix Flake
October 01, 2024In this article, I chronicle my journey creating a versatile, cross-platform development environment using Nix flakes. I delve into the intricacies of building a system that seamlessly integrates JupyterLab, CUDA for GPU acceleration, Ollama for running large language models locally, and a FastHTML server, all while ensuring compatibility across Linux and macOS. I also discuss the challenges encountered when working with cutting-edge technologies and how Nix's robust package management system helped me overcome them.
Forking a Flake of Infrastructure as Code
September 27, 2024I've finally cracked the code to a truly portable and reproducible development environment using Nix flakes! It was a wild ride wrestling with different technologies, but Nix was a lifesaver for managing dependencies and keeping things consistent across my Linux and Mac machines. I even found a way to seamlessly integrate AI-assisted coding tools like Cursor AI and Jupyter AI into the mix. The real kicker was building a FastHTML web app that taps into the Botify API – talk about a learning curve with that BQL language! But hey, who needs sleep when you're riding the wave of efficient and cutting-edge development?
There's No Home Like Nix
September 26, 2024In this article, I delve into building a Python web development environment within Nix, offering solutions for incorporating packages not readily available in the Nix repository. I guide you through using dotenv to securely manage environment variables and present a practical example of a simple FastHTML web application that prompts users for a secret and stores it safely. Additionally, I demonstrate the implementation of a basic chat server with Ollama, emphasizing the advantages of leveraging local LLMs for AI-assisted development.
The DevOps Renaissance: How Infrastructure as Code is Redefining Digital Craftsmanship
September 25, 2024I've rediscovered the joy of being a digital Renaissance person, thanks to Nix flakes! These little configuration files are like a Webmaster's toolkit for my development environment, giving me and my team the power to create consistent, cross-platform setups with GPU acceleration and easy customization. It's like having a digital multi-tool that keeps getting better with every tweak. Come along with me as I explore the ins and outs of Nix flakes with Claude 3.5 Sonnet and learn how to reclaim that holistic approach to development that I thought was lost in the age of hyper-specialization.
FastHTML and Cursor AI on Linux, Mac & Windows
September 24, 2024In this article, I share my adventure setting up a cross-platform development environment with Nix, featuring FastHTML and the AI-powered code editor, Cursor. It's a journey through the challenges of integrating cutting-edge technologies, highlighting the elegance of Nix's package management. I delve into configuring NixOS, wrangling Python virtual environments, and rigorously testing the setup across Macs, Windows (using WSL), and Linux to ensure compatibility. Ultimately, it's a testament to creating a reproducible and robust development experience that bridges the latest in AI-assisted coding with the power and flexibility of Nix.
Using NixOS and Nix with Pip Install DotEnv
September 23, 2024I detail my process of setting up a robust development environment using Nix flakes, incorporating JupyterLab, CUDA support, and a FastHTML server. I highlight the benefits of this approach for data science and web development, emphasizing the flexibility and adaptability it offers for various tasks and skill levels.
Getting My Nix System Together
September 22, 2024I detail my process of setting up a NixOS system and creating reproducible data science environments using Nix flakes. I explain my approach to configuring NixOS, including the use of a minimal configuration.nix file and the integration of essential services like Ollama and CUDA. I also discuss the benefits of using Python virtual environments within Nix flakes to manage Python dependencies and ensure flexibility for data science tasks.
Updating NixOS
September 17, 2024I share my experience transitioning to NixOS from traditional Linux distributions like Ubuntu and Fedora, highlighting the unique aspects of NixOS's filesystem hierarchy and package management. I explain the benefits of Nix's deterministic packaging system and how it can be leveraged on macOS and Windows using Nix Flakes. I also provide a step-by-step guide for getting started with Nix Flakes and emphasize the importance of embracing the NixOS philosophy for improved productivity and simplified software management.
Embracing AI-Assisted Development with Jupyter AI and Nix Flakes
September 16, 2024I detail the process of building a versatile flake.nix file for a consistent development environment across different platforms. Starting with a minimal setup, I progressively incorporate JupyterLab, CUDA support, and a FastHTML server, highlighting the flexibility offered by a virtual environment for installing additional packages. This approach ensures a robust and adaptable development experience for various data science and web development tasks.
Cross-Platform Nix Flake for Jupyter & FastHTML
September 15, 2024I detail building a versatile Nix flake for a consistent development environment across different platforms, starting with a minimal setup and progressively incorporating JupyterLab, CUDA support, and a FastHTML server. I highlight the flexibility offered by a virtual environment for installing additional packages, ensuring a robust and adaptable development experience for various data science and web development tasks.
Get the Big Tech Picture to Maintain Agency
September 14, 2024I explore the historical development of key technologies like Unix, C, Python, and Nix, highlighting their role in empowering individuals in a rapidly changing tech landscape. I emphasize the importance of mastering fundamental tools and concepts to maintain agency and independence in an AI-driven world. I also discuss the enduring relevance of the Unix philosophy and the benefits of open-source software and community collaboration. By understanding the evolution of these technologies, individuals can gain a deeper appreciation for their potential and leverage them to navigate the complexities of modern computing.
My First Nix Flake Will Be JupyterLab
September 13, 2024I explore creating a portable JupyterLab environment using Nix flakes, aiming to maintain consistency between my NixOS desktop and MacBook for SEO automation tasks. This setup, incorporating Jupyter AI and local LLMs, enables me to share a reproducible development environment with coworkers and streamline my workflow. The article highlights the benefits of Nix flakes for managing complex configurations and ensuring cross-platform compatibility, while emphasizing the importance of local-first development and open-source tools.
Getting Started with Nix Flakes
September 12, 2024This article describes my journey to integrate Nix Flakes into my NixOS configuration for better version control and reproducibility. Initially hesitant due to the perceived complexity, I eventually embraced Flakes for their ability to simplify git management and streamline my workflow. The article provides a step-by-step guide on implementing Nix Flakes, moving the system configuration to user space, and rebuilding the system for a more manageable and reproducible development environment.
Groking the NixOS Langauge
September 10, 2024This article explores the challenges a Python programmer faces when learning the NixOS system configuration language, which is based on functional programming principles. I seek to understand the declarative nature of Nix expressions, the syntax and semantics of the language, and the abstract data structures it employs. The article highlights the differences between Nix and imperative programming languages like Python, emphasizing the need for a shift in thinking to grasp the functional paradigm.
Linux, Python, Vim & Git (LPvg) Your Minimum Tech Toolkit for Life
September 09, 2024This article advocates for adopting a minimalist yet powerful tech toolkit centered around Linux, Python, Vim, and Git (LPvg). This stack, combined with tools like Nix, Jupyter Notebooks, and FastHTML, provides a foundation for future-proof tech skills, emphasizing portability, open-source freedom, and adaptability in an ever-evolving technological landscape. This approach prioritizes fundamental skills and avoids the constant churn of trendy frameworks, enabling lifelong learning and mastery of essential tools for various domains, including web development and AI integration.
Future-proof Your Tech Skills
September 08, 2024I advocate for mastering the fundamental LPvg stack—Linux, Python, Vim, and Git—as a timeless foundation to future-proof your skills and escape the relentless 'tech hamster wheel.' My approach emphasizes combining this versatile toolkit with deep domain expertise to better serve clients, maintain independence, automate effectively, and integrate AI thoughtfully using local models and structured communication, ensuring lasting relevance without succumbing to vendor lock-in or chasing fleeting tech trends.
Levinux & Pipulate
These were my two main projects. Levinux has been somewhat dormant for a while, but still has some following. Pipulate, I’m in the process of breathing new life into it, reinventing it as a FOSS tool for SEO automation as I do every few years.
