Future-proof your skills and escape the tech hamster wheel with Linux, Python, vim & git (LPvg) including NixOS, Jupyter, FastHTML and an AI stack to resist obsolescence.

Finding Purpose Through Timeless Tech Skills

I’ve discovered my ikigai — my reason for being — in mastering and teaching future-proof technology skills. While I’m a Technical SEO expert by trade with 25+ years of experience in content optimization and automation, my true passion lies in helping others escape the endless cycle of chasing trendy tools.

  • `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

            /)  ___
      /)\__//  /   \
  ___(/_ 0 0  |     |
*(    ==(_T_)==LINUX|
  \  )   \"\  |     |
   |__>-\_>_>  \___/

LPvg is my carefully curated tech stack that has stood the test of time. While I use these tools to build AI-powered SEO automation systems professionally, they’re versatile enough for any technical challenge. These aren’t just tools - they’re the foundation of a sustainable technical career that resists obsolescence.

        1. What's most broken?
2. Where's the biggest bang for buck?
    3. Which plates must be spun?

More Tools in Our Technical Arsenal:

  • `nix/NixOS`: Reproducible development environments anywhere
  • `tmux`: Persistent terminal sessions for robust background processes
  • `Jupyter Notebooks`: Interactive computing done right
  • `FastHTML`: Streamlined web development without framework bloat
  • `Ollama`: Local AI that keeps you in control
   Ikigai - overcome laziness find the love
  Kaizen - do one thing well keep polishing
Pomodoro - take chisel-strike bank small wins
  Hara Hachi Bu - don't burn out / eat less
     Wabi-Sabi - 80/20-rule imperfection
         Shoshin - Be like a beginner



                    ___
                   |   |         _____
                   |_  |        /     \
                     \ |       |       \
                     |  \      |       /
                      \  \____ \_      \
                       \      \_/      |
                 ___.   \_            _/
.-,             /    \    |          |
|  \          _/      `--_/           \_
 \  \________/                     /\   \
 |                                /  \_  \
 `-----------,                   |     \  \
             |                  /       \  |
             |                 |         | \
             /                 |         \__|
            /   _              |
           /   / \_             \
           |  /    \__      __--`
          _/ /        \   _/
      ___/  /          \_/
     /     /
     `----`

Did Somebody Say Rabbit Hole?

Daily Work Journal & AI Experiment

I maintain this site as a daily work journal 📝, not because I seek an audience or have products to sell, but as part of a larger experiment in knowledge capture and AI-assisted content distillation. Every post is a raw, unfiltered stream of consciousness 🌊, deliberately verbose and often meandering, forming the mouth of a topic mining funnel that will eventually crystallize into an organized book 📚.

There’s Nothing To See Here, Move Along

While humans are welcome to explore these technical musings, the density and sometimes pedantic nature of the content is actually optimized for AI consumption 🤖. This approach serves two purposes: feeding the frontier models that continuously sweep the web for training data, and providing rich context for real-time RAG (Retrieval-Augmented Generation) searches 🔍. It’s an organic, living project that anticipates the shift away from traditional crawl-and-index search paradigms toward a more interconnected “small world theory” approach to web navigation 🌐.

FastHTML & Local AI Integration

My latest project is a FastHTML-based web app framework that integrates a local AI (powered by Ollama) to provide real-time assistance and automation for SEO tasks. It’s designed for a single-tenant, localhost environment, prioritizing clarity and developer freedom over complex frontend frameworks. The AI is deeply embedded, learning from user interactions and eventually able to execute tasks autonomously. This approach aims to streamline SEO workflows, making them more efficient and user-friendly, while leveraging the power of local AI for enhanced privacy and customization.

Adaptive Architecture

Just like the Ship of Theseus, where parts are replaced over time while maintaining the ship’s identity, this project is designed to adapt and upgrade with new technologies and advancements, ensuring a future-proof foundation for AI-powered SEO automation.

The AI SEO Future Proof(ing) Book - Outline

Here’s the outline of the book so far, which I’m assembling from my daily blog posts using a simple Python script. The script combines all the .md files in chronological order, creating one master document that can be fed to the LLMs that have massive context windows (currently Google Gemini and ChatGPT o1). This organic approach allows the content to evolve naturally through daily writing while maintaining a coherent structure.

Part 1: Laying the Foundation

Part 2: Mastering the LPvg Stack

Part 3: The AI-Powered Future

Part 4: The SEO Revolution

Epilogue: The Ballad of the Pipemaster

Appendix: The Pipemaster’s Toolkit

Knowledge Distillation (From These Articles)

The outline above represents a distillation of knowledge extracted from the articles that follow. Like a funnel that captures diverse streams of information and a sieve that filters and refines them, I’ve gathered scattered insights about technology, AI, and human-centric computing into a coherent narrative. This approach reflects the modern knowledge worker’s challenge: making sense of an endless flow of information through careful curation and synthesis.

Just as Unix pipes transform raw data into meaningful output, these articles have been transformed into an actionable framework above. The outline represents carefully filtered tools and knowledge that have emerged from years of exploration, experimentation, and practical application. They form an idea map — a curated collection of interconnected concepts and tools that will help you build your own technological ecosystem.

  1. Writing Sheet Music & Taking Chisel Strikes

    December 11, 2024

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

  2. Rise of The No-Churn Movement

    December 10, 2024

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

  3. Testing OpenAI ChatGPT Pro (o1 Release)

    December 09, 2024

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

  4. Claude & o1 Release Collaboration

    December 08, 2024

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

  5. Don Knuth, Fred Brooks & Zeno's Paradox of Coding

    December 07, 2024

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

  6. Testing OpenAI ChatGPT o1 Release Model

    December 06, 2024

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

  7. David Mayer Vs. Donald Trump (ChatGPT & Google AI ChatBot LLM Censorship)

    December 03, 2024

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

  8. The Necessity of Taking Multiple Small Passes (Chisel-strikes)

    December 02, 2024

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

  9. Future-Proof Your Tech Career: The No Take-Back Guide to Winning in a World of Churn

    November 29, 2024

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

  10. Dedumbing Sisyphus

    November 27, 2024

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

  11. Pipeline To Completion

    November 25, 2024

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

  12. Wrangling AI Code Assistants

    November 24, 2024

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

  13. BFF SEO dot BOT is Born

    November 24, 2024

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

  14. The Mindful Mirror Model Effect

    November 24, 2024

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

  15. Brainstorming Book Titles with AI

    November 24, 2024

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

  16. NixOS Warbler Files Disappeared

    November 23, 2024

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

  17. Pipline Workflow Example

    November 23, 2024

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

  18. LLM Speedbumps, Anti-pattern Vaccines & The Locahost Revolution

    November 22, 2024

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

  19. Pipulate Pipeline Born Again Now

    November 21, 2024

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

  20. On Flow State Alternation - The Key to Success

    November 20, 2024

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

  21. Pipeline Workflow

    November 19, 2024

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

  22. Pattern Alert - THIS IS NOT FASTAPI!

    November 18, 2024

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

  23. Unix Pipeline Philosophy in HTMX + FastHTML Workflows

    November 16, 2024

    Unix Pipeline Philosophy in HTMX + FastHTML Workflows: Enhance your coding skills by embracing a Unix-inspired approach to building web applications with HTMX and FastHTML.

  24. On Fighting the Dunning-Kruger Effect

    November 16, 2024

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

  25. OpenAPI Swagger JSON to Python Code Examples

    November 15, 2024

    I'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!

  26. 80% Cost Reduction in AI Operations

    November 13, 2024

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

  27. 6-Click-Ease to Serve Up Bacon

    November 12, 2024

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

  28. How To Train Your LLM

    November 11, 2024

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

  29. I Know Kung Fu... Show Me!

    November 10, 2024

    Explore how AI assistance and strategic prompt injection enabled mastery of complex BQL API integration, setting the stage for ambitious GPU-powered website visualization goals.

  30. From Jupyter Notebooks to Markdown

    November 09, 2024

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

  31. Practicing the Botify API

    November 07, 2024

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

  32. Structuring Websites to Train Models

    November 07, 2024

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

  33. Resilience While Achieving Ikigai

    November 06, 2024

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

  34. Getting Mac NeoVim Same as NixOS NeoVim

    November 05, 2024

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

  35. Figuring Out a Complex API

    November 04, 2024

    Coding 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!

  36. SSE Makes Watchdog Necessary to Force Server Live-Reload

    November 03, 2024

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

  37. API-Enabling the LLM Ghost

    November 03, 2024

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

  38. How I Finally Got My LLM to Play Nice With the Web UI

    November 02, 2024

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

  39. FastHTML Hello World

    November 02, 2024

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

  40. Deep Debugging LLM Ghost

    November 01, 2024

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

  41. Rabbit Hole Dev to Delight Clients

    October 31, 2024

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

  42. Giving Gemini Advanced a Try

    October 30, 2024

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

  43. It's About Delighting Customers

    October 30, 2024

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

  44. LLM as Ambient App Intelligence

    October 29, 2024

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

  45. FastMTML Static Resources

    October 28, 2024

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

  46. Slack & Zoom on NixOS Workspaces

    October 27, 2024

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

  47. Pythonic Chunk-Yielding Generator to Simulate Long-Running Tasks

    October 26, 2024

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

  48. I Don't Know What to Do Sometimes

    October 25, 2024

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

  49. API, AI & Human Nuance: The Same Thing

    October 24, 2024

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

  50. The Port For Real This Time

    October 23, 2024

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

  51. LLM Ghost In The Machine

    October 22, 2024

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

  52. Local AI Awareness Training

    October 21, 2024

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

  53. Local AI In The App Development Loop

    October 20, 2024

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

  54. Planning to Win with LLM

    October 19, 2024

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

  55. Local LLM Web Framework Integration Plan

    October 18, 2024

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

  56. Revolutionizing Software Deployment: How Nix Flakes Simplify Development Beyond Docker and pip

    October 17, 2024

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

  57. The key to AI Code Assist Acceleration is 1-Folder Scope

    October 15, 2024

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

  58. Soft Launching Botifython

    October 15, 2024

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

  59. Botifython is Born

    October 14, 2024

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

  60. Object Oriented Base Class Plugins

    October 13, 2024

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

  61. Building a Plugin-Ready Framework: A Step-by-Step Transformation

    October 12, 2024

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

  62. Test SPA Endpoints (Single Page Applications in FastHTML)

    October 11, 2024

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

  63. FastHTML and SortableJS For Sortable Todo Lists

    October 10, 2024

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

  64. AI-Generated Refactoring Advice from Top LLM Models

    October 09, 2024

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

  65. Unpacking FastHTML Databases

    October 08, 2024

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

  66. A ChatGPT o1-Preview Code Review

    October 07, 2024

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

  67. FastHTML WebSockets & Database for Streaming & Persistence

    October 06, 2024

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

  68. Ollama Websocket Chat

    October 05, 2024

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

  69. Understanding FastHTML's Framework Opinions

    October 04, 2024

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

  70. From Jupyer Notebooks to FastHTML with WebSockets

    October 03, 2024

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

  71. Code as Infrastructure

    October 02, 2024

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

  72. Melding a Mac and Linux Nix Flake

    October 01, 2024

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

  73. Forking a Flake of Infrastructure as Code

    September 27, 2024

    I'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?

  74. There's No Home Like Nix

    September 26, 2024

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

  75. The DevOps Renaissance: How Infrastructure as Code is Redefining Digital Craftsmanship

    September 25, 2024

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

  76. FastHTML and Cursor AI on Linux, Mac & Windows

    September 24, 2024

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

  77. Using NixOS and Nix with Pip Install DotEnv

    September 23, 2024

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

  78. Getting My Nix System Together

    September 22, 2024

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

  79. Updating NixOS

    September 17, 2024

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

  80. Embracing AI-Assisted Development with Jupyter AI and Nix Flakes

    September 16, 2024

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

  81. Cross-Platform Nix Flake for Jupyter & FastHTML

    September 15, 2024

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

  82. Get the Big Tech Picture to Maintain Agency

    September 14, 2024

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

  83. My First Nix Flake Will Be JupyterLab

    September 13, 2024

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

  84. Getting Started with Nix Flakes

    September 12, 2024

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

  85. Groking the NixOS Langauge

    September 10, 2024

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

  86. Linux, Python, Vim & Git (LPvg) Your Minimum Tech Toolkit for Life

    September 09, 2024

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

  87. Future-proof Your Tech Skills

    September 08, 2024

    This article advocates for a "future-proof" approach to tech skills, focusing on mastering fundamental tools like Linux, Python, vim, and git (the "LPvg stack"). This approach emphasizes adaptability, independence, and long-term relevance in a rapidly changing technological landscape. It encourages professionals to develop technical skills as a complement to their domain expertise, enabling them to better serve clients and navigate the evolving world of AI and automation. The article also highlights the importance of clear communication protocols between humans and AI systems, as well as the benefits of leveraging local AI infrastructure for greater control and flexibility.


Levinux Logo - Linux-based educational operating system for beginners
Pipulate Logo - Open source SEO software for data-driven marketing