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
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.
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
___ | | _____ |_ | / \ \ | | \ | \ | / \ \____ \_ \ \ \_/ | ___. \_ _/ .-, / \ | | | \ _/ `--_/ \_ \ \________/ /\ \ | / \_ \ `-----------, | \ \ | / \ | | | | \ / | \__| / _ | / / \_ \ | / \__ __--` _/ / \ _/ ___/ / \_/ / / `----`
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
- Chapter 1: Confessions of a Recovering Tech Addict
- My journey from chasing shiny new objects to embracing timeless tools.
- The allure of the Amiga and the quest for the perfect digital environment.
- Why the LPvg stack (Linux, Python, vim, git) is your secret weapon for future-proofing.
- NixOS and flakes: Building a future-proof foundation for your digital life.
- The dangers of blindly following tech trends and the importance of critical thinking.
- Chapter 2: Escaping the Cloud’s Clutches
- The localhost revolution: Why it’s more than just a tech trend.
- Reclaiming your digital sovereignty: Owning your data and your tools.
- The power of self-sufficiency and the beauty of local AI.
- The hidden costs and risks of cloud dependence: Data security, privacy, and vendor lock-in.
- Chapter 3: The Tao of the Pipemaster
- Unveiling the server-side state management pipeline: The elegance of simplicity.
- HTMX and FastHTML: The dynamic duo of streamlined web development.
- Building a workflow that sings: Simplicity and power in harmony.
- Digital minimalism: The art of decluttering your tech stack for focus and efficiency.
Part 2: Mastering the LPvg Stack
- Chapter 4: Linux: The Unsung Hero of the Digital Age
- The power of the penguin: Why Linux is the ultimate foundation for tech enthusiasts.
- From servers to desktops: The versatility of Linux and its open-source ecosystem.
- Unlocking the command line: Mastering the shell for efficiency and control.
- A historical perspective: The evolution of Linux and the open-source movement.
- Chapter 5: Python: The Language of the People
- The lingua franca of the modern world: Why Python is the language of choice for diverse fields.
- From data science to web development: The versatility of Python and its extensive libraries.
- The Zen of Python: Embracing the beauty of simplicity and readability.
- Pythonic philosophy: A deep dive into the principles that make Python so effective.
- Conway’s Law and the importance of team/project structure alignment.
- The Mythical Man-Month and the dangers of adding manpower to late projects.
- Zeno’s Paradox and the problem of diminishing returns in software development.
- Chapter 6: Vim: The Text Editor That Time Traveled
- More than just a text editor: Why Vim is a way of life for many developers.
- Muscle memory mastery: Unlocking the efficiency of modal editing and keyboard shortcuts.
- The text editor wars: Why Vim has stood the test of time.
- Flow state and productivity: How mastering Vim can enhance your coding experience.
- The Unix philosophy as a guiding principle for future-proof development.
- Chapter 7: Git: The Time Machine in Your Pocket
- The unsung hero of open source: Why Git is essential for collaboration and version control.
- Mastering the art of version control: Branching strategies, merging, and conflict resolution.
- Git for knowledge sharing: The broader implications of Git for open collaboration and innovation.
Part 3: The AI-Powered Future
- Chapter 8: LLMs: The Ghosts in the Machine
- Unveiling the magic: The potential of large language models (LLMs) in various fields.
- From code generation to creative collaboration: The power of LLMs as assistants and partners.
- Ethical considerations: The responsible use of LLMs and the future of human-AI partnerships.
- The philosophical implications of AI: Consciousness, sentience, and the impact on human identity.
- Chapter 9: Building Your Local AI Dream Team
- Choosing the right LLMs: Selecting and setting up local LLMs for your specific needs.
- Integrating LLMs into your workflow: Supercharging your productivity with AI assistance.
- The future of work: How AI will transform the way we create and collaborate.
- Democratizing technology: The potential of AI to empower individuals and bridge the digital divide.
- Chapter 10: The Localhost Renaissance
- The future of tech is personal: Why local, portable, and powerful tools are essential.
- Building a sustainable tech ecosystem: Empowering individuals and fostering open collaboration.
- Technology serving humanity: Creating a future where technology benefits everyone.
- Techno-optimism: The potential for technology to address global challenges and create a better future.
Part 4: The SEO Revolution
- Chapter 11: SEO in the Age of AI
- The changing landscape: How AI is transforming SEO and content creation.
- Beyond keywords: The importance of user intent, context, and natural language.
- AI-powered SEO tools: Leveraging AI for content optimization, analysis, and automation.
- The ethical considerations of AI SEO: Avoiding manipulation and ensuring transparency.
- Chapter 12: Building Your AI SEO Toolkit
- Essential tools and techniques: Combining AI with traditional SEO practices.
- Content optimization with LLMs: Generating high-quality, engaging content that ranks.
- AI for technical SEO: Automating tasks, analyzing data, and improving website performance.
- The future of AI SEO: Emerging trends and the evolving role of AI in search.
- Chapter 13: The Pipulate Revolution
- Introducing Pipulate: A Python-based framework for AI-powered SEO automation.
- Building custom SEO tools: Leveraging Pipulate for data analysis, visualization, and reporting.
- Integrating with APIs: Accessing and analyzing SEO data with vendor products.
- Real-world applications: Case studies and examples of Pipulate in action.
- Discussion on the pipeline pattern’s application in SEO automation, drawing parallels with Unix pipes and data processing workflows.
Epilogue: The Ballad of the Pipemaster
- A reflection on the journey: Lessons learned and insights gained along the way.
- Embracing simplicity and challenging conventions: The power of independent thinking and creative problem-solving.
- A call to action: Shaping the future of tech with passion, purpose, and a human-centric approach.
Appendix: The Pipemaster’s Toolkit
- Essential resources: A curated collection of tools, libraries, and frameworks for building your localhost empire.
- From NixOS to HTMX: Practical guides and tutorials for mastering the technologies covered in the book.
- Critical thinking and information literacy: Resources for navigating the digital age with discernment and responsibility.
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.
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, 2024This 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.