Blog

  • Resumption Blocks

    I just discovered “Resumption Blocks”, and they are, in my opinion, quite possibly the next best thing to sliced bread when using AI for lengthy, complicated projects – at least for the time being. Resumption Blocks can be incredibly helpful for saving time, money, and most importantly, your sanity.

    The basic idea is simple:

    A resumption block is a structured set of instructions and project information that allows you (or another AI chatbot) to pick up a project exactly where you left off, without having to reconstruct the entire conversation.

    Think of it as a combination of a project status report, a handoff document, and a set of instructions for your AI assistant, and your “later self”.

    I. Why are Resumption Blocks useful?

    Imagine you’re working with an AI on a project that takes several days or weeks – I know this one well; it happens to me a LOT.

    Over that time, you might:

    – Develop scripts and modify them several times.
    – Establish specific project requirements, then change them as the project progresses.
    – Troubleshoot errors, and go through many iterations before resolving the problem.
    – Make decisions about folder structures, and make changes as necessary.
    – Develop documentation.
    – Change your approach as the project evolves.

    Eventually, the conversation becomes very long.

    There are several potential problems with this:

    – The AI may lose track of earlier decisions (happens to me all the time, GRRR).
    – Important technical details may get buried in the conversation.
    – You might start a new conversation and have to explain everything again.
    – The AI might suggest something you’ve already tried.
    – You might accidentally use an outdated version of a script or configuration.

    A resumption block helps prevent these problems.

    II. What should a resumption block contain?

    I recommend organizing it into eight sections.

    | Section | Purpose |
    | ——————- | ——————————————— |
    1. Project Overview | What you’re building and why |
    2. Project Objectives | What the finished product should accomplish |
    3. Current Status | Where the project stands right now |
    4. Environment | Operating system, software, tools, versions |
    5.Files and Structure | Existing files, directories, scripts |
    6. Decisions Made | Approaches already selected |
    7. Outstanding Issues | Errors, incomplete work, unresolved questions |
    8. Next Steps | Exactly what needs to happen next |

    There is one additional section I consider especially important:

    Instructions to the AI.

    This tells the next chatbot how to approach the project.

    For example:

    – Don’t assume previous instructions were completed successfully.
    – Don’t overwrite working scripts without discussing changes.
    – Provide complete replacement scripts rather than isolated code fragments when appropriate.
    – Give commands that can be copied and pasted.
    – Explain where files should be saved.
    – Verify assumptions before recommending changes.
    – Keep project documentation updated.

    III. Example: My Washington State Legal Knowledgebase project

    Let’s use my Washington State RCW/WAC knowledgebase project as an example. I recently needed to address some legal knowledge deficits, so I decided to download and parse all current Washington State laws into my local instance of OpenWebUI.

    A resumption block I created for this project looked something like this:

    PROJECT RESUMPTION BLOCK

    Example
    Washington State Legal Knowledgebase

    1\. Project Overview

    I am building a comprehensive Washington State legal knowledgebase for import into OpenWebUI, allowing an AI chatbot to search and reference Washington statutes and administrative regulations.

    2\. Project Objectives

    – Download Washington Revised Code (RCW).
    – Download Washington Administrative Code (WAC).
    – Organize documents by title.
    – Include session laws and codification tables.
    – Produce documents suitable for LLM knowledgebase ingestion.

    3\. Current Environment

    – Operating system: Linux
    – Python: 3.13
    – Virtual environment: `.venv`
    – Project directory:

    `~/Desktop/Washington-State-Law-Downloader-Scripts`

    4\. Existing Files

    – `download_washington_rcw.py`
    – `README-RCW-Downloader.md`
    – `requirements-rcw.txt`
    – `washington-rcw/`
    – `washington-rcw.zip`

    5\. Progress

    – RCW downloader successfully executed.
    – RCW archive created.
    – Legal knowledgebase builder partially implemented.
    – RCW Title 9 processing started.
    – WAC Title 16 processing encountered an error.

    6\. Outstanding Issues

    – WAC section URL processing fails during sorting.
    – A proposed corrected builder script has not yet been supplied.
    – Need to diagnose the original traceback before proceeding.

    7\. Immediate Next Steps

    1. Obtain the complete traceback.
    2. Inspect the current builder script.
    3. Correct WAC URL processing.
    4. Test RCW and WAC downloads.
    5. Verify resulting directory structure.

    8\. Instructions to AI

    – Continue from the current project state.
    – Do not assume scripts have been modified unless verified.
    – Provide complete replacement scripts when practical.
    – Provide executable Linux commands.
    – Preserve working functionality.
    – Document changes and troubleshooting steps.

    This is substantially more useful than simply telling a new chatbot, “Let’s continue working on my Washington legal knowledgebase.”

    4. Three types of resumption blocks

    I actually recommend maintaining three different levels of resumption information.

    A. Quick Resumption Block

    For every conversation

    A short summary of what you accomplished, where you stopped, and what to do next.

    Usually 10–20 lines.

    B. Master Project Resumption Block

    Long-term reference

    Contains the complete project background, objectives, environment, decisions, file structure, and current status.

    I update it as the project evolves.

    C. Project Documentation

    Permanent reference

    The actual technical documentation: installation instructions, scripts, configurations, troubleshooting, architecture, and operational procedures.

    This is the authoritative record of how the project works.

    The distinction is important: a resumption block tells the AI where to continue, while project documentation explains how the project works.
    5. My recommended workflow

    For substantial projects, I use the following workflow:

    AI-assisted project lifecycle

    1. Start a project

    Load the master resumption block and relevant project documentation.
    2. Work on the project

    Develop, troubleshoot, research, and document changes.
    3. Update project documentation

    Record successful changes, new decisions, commands, and configurations.
    4. Generate a new resumption block

    Summarize the current state and identify the next action.
    5. End the conversation

    Save the updated resumption block alongside the project documentation.
    6. Resume later

    Start a new conversation, provide the resumption block, and continue.

    6. An additional recommendation: Have the AI generate its own handoff

    One of the most useful things you can do is establish a standing instruction for the AI:

    At the end of each substantial working session, have it automatically prepare:

    1. A summary of completed work.
    2. A list of files created or modified.
    3. A record of decisions made.
    4. Any unresolved problems.
    5. The exact next steps.
    6. A revised resumption block.
    7. Any project documentation that needs updating.

    This makes the AI responsible for maintaining continuity rather than leaving you to reconstruct everything.

    7. What I would recommend for your projects

    In writing this post, I got an idea that it might be good to establish a reusable AI Project Continuity System that can be used across different technical projects.

    For example:

    “`
    Project/
    │
    ├── README.md
    │
    ├── PROJECT_MASTER.md
    │
    ├── PROJECT_RESUMPTION.md
    │
    ├── CHANGELOG.md
    │
    ├── DOCUMENTATION/
    │ ├── Installation.md
    │ ├── Configuration.md
    │ ├── Troubleshooting.md
    │ └── Architecture.md
    │
    ├── SCRIPTS/
    │
    └── ARCHIVE/
    └── Previous_Resumption_Blocks/
    “`

    Each file has a specific responsibility:

    – `PROJECT_MASTER.md` — Permanent project requirements and background.
    – `PROJECT_RESUMPTION.md` — Most recent working state and next steps.
    – `CHANGELOG.md` — Chronological record of changes.
    – `DOCUMENTATION/` — Detailed technical documentation.
    – `ARCHIVE/` — Historical resumption blocks.

    Some of you may notice that this is structured like a software development project in Git – that is intentional, because this structure is clear and concise, functional, well documented, tried and true.

    The biggest advantage to using resumption blocks is this: You aren’t dependent on any particular chatbot, conversation history, or AI provider. You can take the project to another chatbot and continue working.

    With all the various chatbots and agents available, this seems (at least to me) to be a good idea to prevent getting “scattered”. Trust that my ADHD already makes things challenging; I don’t need to make things harder, and this really helps to keep focused and organized with regard to my MANY projects.

    Note To Self and Others: Just make sure that your output of this resumption file contains all variables, constants, EVERYTHING in the current conversation.

    If you are like me, and don’t have an endless budget to spend on AI, please consider employing OpenWebUI on your PC or other capable LAN host on your network – It keeps your data under your control, and saves you money, even if you have subscriptions to major AI providers. That way you only use your paid models to do the heavy lifting, not the little stuff that consumes your tokens.

  • If Your IoT Device Could Talk, It would Tell You: “Please Update My Firmware!”

    I must be just a “little extra” geeky with regard to the firmware update frequency of my IoT devices – literally all of the ones I own, save for the ones sitting in my electronics toolbox drawer, not being used yet(surprisingly) are fully updated to the newest firmware. When I pull one out to start a project, I flash the newest firmware/software, and regularly update them after that, usually on a weekly or at least monthly basis. This is especially true if they are being tasked with something sensitive, or connected to my network(s).

    According to IEEE, less than 3% of IoT devices are actually running the latest firmware. That is a somewhat scary thought, considering the kinds of duties that folks entrust these devices with, especially with the state of the Internet these days. So take a moment, and give some love to your IoT devices, and feed them that (probably) much needed firmware update today!

    Here are some official firmware and software download links for some of my favorite IoT and microcontroller platforms:

  • Welcome to The Geek Den!

    This is my personal WordPress Blog, the place where I share my “Geekiness” with others. I sincerely hope that you find something here to satisfy, or soothe your cravings for “the technical stuff”, and if you don’t, well, Have a Good Day, Anyway! 🙂

    If you would like to see or purchase some of the things that I make in my “Geek Lab”, please visit my business website at https://creative-makerworks.com.

  • DIY Advanced Indoor/Outdoor Environmental Monitoring & Weather Station

    My Weather Station in Progress! Please forgive my muddy tractor, she works "real hard" year round, and is often put away wet…
    My Weather Station in Progress…

    For all of you that might be a little bit of a “Weather Geek” like me, and care about your respiratory health, here is a project that may be of interest to you, especially with regard to environmental exposures monitoring, along with a standard local weather station. I have put together this project that you can build for yourself, and it can be expanded to measure other aspects of your local environmental/weather conditions as well. I have listed this project on Thingiverse (https://www.thingiverse.com/thing:7347425), and plan to put up a Github repository for the code, as well as an Instructables page to provide instructions for the build process. This project can be used to set up a weather feed on Internet weather websites, too – mine can be found at wunderground.com.

    *Everything here is a “Work In Progress”, so just know that things will change with regard to this project over time. At the end of this post, I will attach a BOM for those who wish to attempt this project.*

    It is a Raspberry Pi Zero 2W/Raspberry Pico 2 based wireless indoor/outdoor environmental conditions station that happens to also function as a local weather station. For this project, I chose to use a Raspberry Pi Zero 2W for the main server “base” station, and 2 Raspberry Pico 2‘s for the “remote” devices, to take the following measurements:

    1. Outdoor Weather (With UV Index)
    2. Outdoor Air Quality (Particulate Matter)
    3. Indoor Air Quality (CO² Concentration)

    The Raspberry Pi Zero 2W will function as the central server to receive and report the measurements of the 2 Raspberry Pico 2W sensor devices, and render the data it receives from them in the WeeWX webserver interface that you can access from your web browser on your computer, smartphone, or tablet on your local area network. It has has the following software installed:

    On the 2 Raspberry Pico 2‘s that I am using for this project, I have chosen to install Circuit Python onto them, since it is the most compatible version of Python for Adafruit Industries devices. Some of you might want to choose to use Micropython for this use case, but be forewarned that when I wrote this post, I found out that Micropython did not have working drivers for at least one of these device’s sensors – specifically the Bosch sensor on the Adafruit BME680. As an added bonus, CircuitPython provides a builtin lightweight webserver interface that can be accessed over your local area network (LAN) for troubleshooting, device resetting, and easily editing/updating the code contained on each Raspberry Pico 2W unit. This has definitely come in handy for me on more than one occasion.

    In my setup, the Raspberry Pico 2‘s take the following sensor readings:

    The first of the Pico’s in this setup will be located outdoors, and the second one will be indoors. The first Pico (we’ll call that one “AQO-Pico”). It will be taking the following measurements:

    It is important to note here that AQO-Pico will be taking an air quality index measurement, in the form of a particulate matter measurement, given in μg/m³. It senses particulate matter of various sizes, and the ones that we will be measuring are in the 1 μg/m³, 2.5 μg/m³, and 10 μg/m³ ranges respectively.

    Particulates 2.5 μg/m³ or smaller are the ones that are “bad” for us, since these are ones that are small enough to enter our aveoli (the small sacs in our lungs that allow oxygen to get into the bloodstream), and negatively impact our health – pretty much immediately for people with breathing problems, like asthma or bronchitis, and for healthier individuals, they cause harm over time, contributing to “wonderful” 🤢 diseases like COPD, emphysema, and lung cancer.

    But enough of the health science stuff for now, let’s get back to the topic at hand – the weather station build!

    Okay, so the second Pico in my setup(which I will call “AQI-Pico”), will be tasked with measuring the following values indoors:

    Just as outdoor particulate matter can be harmful to our health, excessively high indoor concentrations of CO² can be harmful to us as well, that is why measuring it is important.

    Ok, so now that we know what devices we have in our setup, and what they will be doing/measuring, we can now move on to the sensors portion of things. For this project, I chose to use the following sensors, sourced from Adafruit Industries:

    The one sensor I did not buy from Adafruit, but is included in this build, is the ds18b20 temperature sensor, which is used to measure ambient temperature. I installed it on the mast of the Weather-Pico outdoor unit, housed in

    For the weather monitoring part of things, including the wind direction, wind speed, and precipitation measurements, I bought the Wind/Rain Sensor Assembly from Argent Data Systems, since it was much cheaper than I could find it anywhere else on the Internet.

    To make things a simple as possible to cleanly connect the Wind/Rain sensor assembly, I chose to get the BC Robotics Raspberry Pi Pico 1591B Weather Board, with which I am really impressed/super happy about, save for 2 caveats:

    • You have to solder the Raspberry Pico 2W to it, so you should have good soldering skills, and the right equipment to do the soldering.
    • If you are having it shipped to the U. S., you will pay more in tariffs than you will for the PCB. It cost me $16.78 USD for the board itself, and I ended up paying $89 USD for it by the time I paid for shipping, tariffs, and brokers fees to get it across the border. I think the shipping cost was $11 for my order, from Nanaimo, British Columbia, Canada, to Mossyrock, Washington, USA (188 miles).

    For the power supply end of things, I bought the following items: