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.
Leave a Reply